aaru-dps/Aaru.Server
1
0
Fork 0
mirror of https://github.com/aaru-dps/Aaru.Server.git synced 2025-12-16 11:14:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

Refactor.

Browse Source
This commit is contained in:
Natalia Portillo
2019-11-02 21:37:09 +00:00
parent f653af2059
commit d4020f1a3f
52 changed files with 4207 additions and 4095 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
.editorconfig Normal file
View File

@@ -0,0 +1,16 @@
[*]
charset=utf-8
end_of_line=lf
trim_trailing_whitespace=true
insert_final_newline=false
indent_style=space
indent_size=4
[{.babelrc,.stylelintrc,.eslintrc,jest.config,*.uplugin,*.bowerrc,*.jsb3,*.jsb2,*.json}]
indent_style=space
indent_size=2
[{*.yml,*.yaml}]
indent_style=space
indent_size=2

1180
DiscImageChef.Server/App_Start/Ata.cs
View File

File diff suppressed because it is too large Load Diff

52
DiscImageChef.Server/App_Start/ScsiEvpd.cs
View File

@@ -47,44 +47,44 @@ namespace DiscImageChef.Server
/// <param name="evpdPages">List to put the key=value pairs on</param>
public static void Report(IEnumerable<ScsiPage> pages, string vendor, ref Dictionary<string, string> evpdPages)
{
foreach(ScsiPage evpd in pages)
foreach (var evpd in pages)
{
string decoded;
if(evpd.page >= 0x01 && evpd.page <= 0x7F) decoded = EVPD.DecodeASCIIPage(evpd.value);
else if(evpd.page == 0x81) decoded = EVPD.PrettifyPage_81(evpd.value);
else if(evpd.page == 0x82) decoded = EVPD.DecodePage82(evpd.value);
else if(evpd.page == 0x83) decoded = EVPD.PrettifyPage_83(evpd.value);
else if(evpd.page == 0x84) decoded = EVPD.PrettifyPage_84(evpd.value);
else if(evpd.page == 0x85) decoded = EVPD.PrettifyPage_85(evpd.value);
else if(evpd.page == 0x86) decoded = EVPD.PrettifyPage_86(evpd.value);
else if(evpd.page == 0x89) decoded = EVPD.PrettifyPage_89(evpd.value);
else if(evpd.page == 0xB0) decoded = EVPD.PrettifyPage_B0(evpd.value);
else if(evpd.page == 0xB2)
if (evpd.page >= 0x01 && evpd.page <= 0x7F) decoded = EVPD.DecodeASCIIPage(evpd.value);
else if (evpd.page == 0x81) decoded = EVPD.PrettifyPage_81(evpd.value);
else if (evpd.page == 0x82) decoded = EVPD.DecodePage82(evpd.value);
else if (evpd.page == 0x83) decoded = EVPD.PrettifyPage_83(evpd.value);
else if (evpd.page == 0x84) decoded = EVPD.PrettifyPage_84(evpd.value);
else if (evpd.page == 0x85) decoded = EVPD.PrettifyPage_85(evpd.value);
else if (evpd.page == 0x86) decoded = EVPD.PrettifyPage_86(evpd.value);
else if (evpd.page == 0x89) decoded = EVPD.PrettifyPage_89(evpd.value);
else if (evpd.page == 0xB0) decoded = EVPD.PrettifyPage_B0(evpd.value);
else if (evpd.page == 0xB2)
decoded =
$"TapeAlert Supported Flags Bitmap: 0x{EVPD.DecodePageB2(evpd.value):X16}<br/>";
else if(evpd.page == 0xB4) decoded = EVPD.DecodePageB4(evpd.value);
else if(evpd.page == 0xC0 && vendor.Trim() == "quantum")
else if (evpd.page == 0xB4) decoded = EVPD.DecodePageB4(evpd.value);
else if (evpd.page == 0xC0 && vendor.Trim() == "quantum")
decoded = EVPD.PrettifyPage_C0_Quantum(evpd.value);
else if(evpd.page == 0xC0 && vendor.Trim() == "seagate")
else if (evpd.page == 0xC0 && vendor.Trim() == "seagate")
decoded =
EVPD.PrettifyPage_C0_Seagate(evpd.value);
else if(evpd.page == 0xC0 && vendor.Trim() == "ibm")
else if (evpd.page == 0xC0 && vendor.Trim() == "ibm")
decoded = EVPD.PrettifyPage_C0_IBM(evpd.value);
else if(evpd.page == 0xC1 && vendor.Trim() == "ibm")
else if (evpd.page == 0xC1 && vendor.Trim() == "ibm")
decoded = EVPD.PrettifyPage_C1_IBM(evpd.value);
else if((evpd.page == 0xC0 || evpd.page == 0xC1) && vendor.Trim() == "certance")
else if ((evpd.page == 0xC0 || evpd.page == 0xC1) && vendor.Trim() == "certance")
decoded = EVPD.PrettifyPage_C0_C1_Certance(evpd.value);
else if((evpd.page == 0xC2 || evpd.page == 0xC3 || evpd.page == 0xC4 || evpd.page == 0xC5 ||
evpd.page == 0xC6) &&
vendor.Trim() == "certance") decoded = EVPD.PrettifyPage_C2_C3_C4_C5_C6_Certance(evpd.value);
else if((evpd.page == 0xC0 || evpd.page == 0xC1 || evpd.page == 0xC2 || evpd.page == 0xC3 ||
evpd.page == 0xC4 || evpd.page == 0xC5) &&
vendor.Trim() == "hp") decoded = EVPD.PrettifyPage_C0_to_C5_HP(evpd.value);
else if(evpd.page == 0xDF && vendor.Trim() == "certance")
decoded = EVPD.PrettifyPage_DF_Certance(evpd.value);
else if ((evpd.page == 0xC2 || evpd.page == 0xC3 || evpd.page == 0xC4 || evpd.page == 0xC5 ||
evpd.page == 0xC6) &&
vendor.Trim() == "certance") decoded = EVPD.PrettifyPage_C2_C3_C4_C5_C6_Certance(evpd.value);
else if ((evpd.page == 0xC0 || evpd.page == 0xC1 || evpd.page == 0xC2 || evpd.page == 0xC3 ||
evpd.page == 0xC4 || evpd.page == 0xC5) &&
vendor.Trim() == "hp") decoded = EVPD.PrettifyPage_C0_to_C5_HP(evpd.value);
else if (evpd.page == 0xDF && vendor.Trim() == "certance")
decoded = EVPD.PrettifyPage_DF_Certance(evpd.value);
else decoded = "Undecoded";
if(!string.IsNullOrEmpty(decoded)) decoded = decoded.Replace("\n", "<br/>");
if (!string.IsNullOrEmpty(decoded)) decoded = decoded.Replace("\n", "<br/>");
evpdPages.Add($"EVPD page {evpd.page:X2}h", decoded);
}

122
DiscImageChef.Server/App_Start/ScsiInquiry.cs
View File

@@ -35,7 +35,7 @@ using DiscImageChef.Decoders.SCSI;
namespace DiscImageChef.Server
{
static class ScsiInquiry
internal static class ScsiInquiry
{
/// <summary>
/// Takes the SCSI INQUIRY part of a device report and prints it as a list of values to be sequenced by ASP.NET in the
@@ -45,13 +45,13 @@ namespace DiscImageChef.Server
/// <returns>List of values</returns>
internal static IEnumerable<string> Report(Inquiry.SCSIInquiry? inquiryNullable)
{
List<string> scsiOneValue = new List<string>();
var scsiOneValue = new List<string>();
if(!inquiryNullable.HasValue) return scsiOneValue;
if (!inquiryNullable.HasValue) return scsiOneValue;
Inquiry.SCSIInquiry inquiry = inquiryNullable.Value;
var inquiry = inquiryNullable.Value;
switch((PeripheralQualifiers)inquiry.PeripheralQualifier)
switch ((PeripheralQualifiers) inquiry.PeripheralQualifier)
{
case PeripheralQualifiers.Supported:
scsiOneValue.Add("Device is connected and supported.");
@@ -70,7 +70,7 @@ namespace DiscImageChef.Server
break;
}
switch((PeripheralDeviceTypes)inquiry.PeripheralDeviceType)
switch ((PeripheralDeviceTypes) inquiry.PeripheralDeviceType)
{
case PeripheralDeviceTypes.DirectAccess: //0x00,
scsiOneValue.Add("Direct-access device");
@@ -146,7 +146,7 @@ namespace DiscImageChef.Server
break;
}
switch((ANSIVersions)inquiry.ANSIVersion)
switch ((ANSIVersions) inquiry.ANSIVersion)
{
case ANSIVersions.ANSINoVersion:
scsiOneValue.Add("Device does not claim to comply with any SCSI ANSI standard");
@@ -171,11 +171,12 @@ namespace DiscImageChef.Server
break;
default:
scsiOneValue
.Add($"Device claims to comply with unknown SCSI ANSI standard value 0x{inquiry.ANSIVersion:X2})");
.Add(
$"Device claims to comply with unknown SCSI ANSI standard value 0x{inquiry.ANSIVersion:X2})");
break;
}
switch((ECMAVersions)inquiry.ECMAVersion)
switch ((ECMAVersions) inquiry.ECMAVersion)
{
case ECMAVersions.ECMANoVersion:
scsiOneValue.Add("Device does not claim to comply with any SCSI ECMA standard");
@@ -185,11 +186,12 @@ namespace DiscImageChef.Server
break;
default:
scsiOneValue
.Add($"Device claims to comply with unknown SCSI ECMA standard value 0x{inquiry.ECMAVersion:X2})");
.Add(
$"Device claims to comply with unknown SCSI ECMA standard value 0x{inquiry.ECMAVersion:X2})");
break;
}
switch((ISOVersions)inquiry.ISOVersion)
switch ((ISOVersions) inquiry.ISOVersion)
{
case ISOVersions.ISONoVersion:
scsiOneValue.Add("Device does not claim to comply with any SCSI ISO/IEC standard");
@@ -199,38 +201,39 @@ namespace DiscImageChef.Server
break;
default:
scsiOneValue
.Add($"Device claims to comply with unknown SCSI ISO/IEC standard value 0x{inquiry.ISOVersion:X2})");
.Add(
$"Device claims to comply with unknown SCSI ISO/IEC standard value 0x{inquiry.ISOVersion:X2})");
break;
}
if(inquiry.RMB) scsiOneValue.Add("Device is removable");
if(inquiry.AERC) scsiOneValue.Add("Device supports Asynchronous Event Reporting Capability");
if(inquiry.TrmTsk) scsiOneValue.Add("Device supports TERMINATE TASK command");
if(inquiry.NormACA) scsiOneValue.Add("Device supports setting Normal ACA");
if(inquiry.HiSup) scsiOneValue.Add("Device supports LUN hierarchical addressing");
if(inquiry.SCCS) scsiOneValue.Add("Device contains an embedded storage array controller");
if(inquiry.ACC) scsiOneValue.Add("Device contains an Access Control Coordinator");
if(inquiry.ThreePC) scsiOneValue.Add("Device supports third-party copy commands");
if(inquiry.Protect) scsiOneValue.Add("Device supports protection information");
if(inquiry.BQue) scsiOneValue.Add("Device supports basic queueing");
if(inquiry.EncServ) scsiOneValue.Add("Device contains an embedded enclosure services component");
if(inquiry.MultiP) scsiOneValue.Add("Multi-port device");
if(inquiry.MChngr) scsiOneValue.Add("Device contains or is attached to a medium changer");
if(inquiry.ACKREQQ) scsiOneValue.Add("Device supports request and acknowledge handshakes");
if(inquiry.Addr32) scsiOneValue.Add("Device supports 32-bit wide SCSI addresses");
if(inquiry.Addr16) scsiOneValue.Add("Device supports 16-bit wide SCSI addresses");
if(inquiry.RelAddr) scsiOneValue.Add("Device supports relative addressing");
if(inquiry.WBus32) scsiOneValue.Add("Device supports 32-bit wide data transfers");
if(inquiry.WBus16) scsiOneValue.Add("Device supports 16-bit wide data transfers");
if(inquiry.Sync) scsiOneValue.Add("Device supports synchronous data transfer");
if(inquiry.Linked) scsiOneValue.Add("Device supports linked commands");
if(inquiry.TranDis) scsiOneValue.Add("Device supports CONTINUE TASK and TARGET TRANSFER DISABLE commands");
if(inquiry.QAS) scsiOneValue.Add("Device supports Quick Arbitration and Selection");
if(inquiry.CmdQue) scsiOneValue.Add("Device supports TCQ queue");
if(inquiry.IUS) scsiOneValue.Add("Device supports information unit transfers");
if(inquiry.SftRe) scsiOneValue.Add("Device implements RESET as a soft reset");
if (inquiry.RMB) scsiOneValue.Add("Device is removable");
if (inquiry.AERC) scsiOneValue.Add("Device supports Asynchronous Event Reporting Capability");
if (inquiry.TrmTsk) scsiOneValue.Add("Device supports TERMINATE TASK command");
if (inquiry.NormACA) scsiOneValue.Add("Device supports setting Normal ACA");
if (inquiry.HiSup) scsiOneValue.Add("Device supports LUN hierarchical addressing");
if (inquiry.SCCS) scsiOneValue.Add("Device contains an embedded storage array controller");
if (inquiry.ACC) scsiOneValue.Add("Device contains an Access Control Coordinator");
if (inquiry.ThreePC) scsiOneValue.Add("Device supports third-party copy commands");
if (inquiry.Protect) scsiOneValue.Add("Device supports protection information");
if (inquiry.BQue) scsiOneValue.Add("Device supports basic queueing");
if (inquiry.EncServ) scsiOneValue.Add("Device contains an embedded enclosure services component");
if (inquiry.MultiP) scsiOneValue.Add("Multi-port device");
if (inquiry.MChngr) scsiOneValue.Add("Device contains or is attached to a medium changer");
if (inquiry.ACKREQQ) scsiOneValue.Add("Device supports request and acknowledge handshakes");
if (inquiry.Addr32) scsiOneValue.Add("Device supports 32-bit wide SCSI addresses");
if (inquiry.Addr16) scsiOneValue.Add("Device supports 16-bit wide SCSI addresses");
if (inquiry.RelAddr) scsiOneValue.Add("Device supports relative addressing");
if (inquiry.WBus32) scsiOneValue.Add("Device supports 32-bit wide data transfers");
if (inquiry.WBus16) scsiOneValue.Add("Device supports 16-bit wide data transfers");
if (inquiry.Sync) scsiOneValue.Add("Device supports synchronous data transfer");
if (inquiry.Linked) scsiOneValue.Add("Device supports linked commands");
if (inquiry.TranDis) scsiOneValue.Add("Device supports CONTINUE TASK and TARGET TRANSFER DISABLE commands");
if (inquiry.QAS) scsiOneValue.Add("Device supports Quick Arbitration and Selection");
if (inquiry.CmdQue) scsiOneValue.Add("Device supports TCQ queue");
if (inquiry.IUS) scsiOneValue.Add("Device supports information unit transfers");
if (inquiry.SftRe) scsiOneValue.Add("Device implements RESET as a soft reset");
switch((TGPSValues)inquiry.TPGS)
switch ((TGPSValues) inquiry.TPGS)
{
case TGPSValues.NotSupported:
scsiOneValue.Add("Device does not support assymetrical access");
@@ -249,7 +252,7 @@ namespace DiscImageChef.Server
break;
}
switch((SPIClocking)inquiry.Clocking)
switch ((SPIClocking) inquiry.Clocking)
{
case SPIClocking.ST:
scsiOneValue.Add("Device supports only ST clocking");
@@ -268,10 +271,10 @@ namespace DiscImageChef.Server
break;
}
if(inquiry.VersionDescriptors == null) return scsiOneValue;
if (inquiry.VersionDescriptors == null) return scsiOneValue;
foreach(ushort versionDescriptor in inquiry.VersionDescriptors)
switch(versionDescriptor)
foreach (var versionDescriptor in inquiry.VersionDescriptors)
switch (versionDescriptor)
{
case 0xFFFF:
case 0x0000: break;
@@ -403,11 +406,12 @@ namespace DiscImageChef.Server
break;
case 0x01DD:
scsiOneValue
.Add("Device complies with SES T10/1212 revision 08b w/ Amendment ANSI INCITS.305/AM1-2000");
.Add(
"Device complies with SES T10/1212 revision 08b w/ Amendment ANSI INCITS.305/AM1-2000");
break;
case 0x01DE:
scsiOneValue
.Add("Device complies with SES ANSI INCITS 305-1998 w/ Amendment ANSI INCITS.305/AM1-2000");
.Add("Device complies with SES ANSI INCITS 305-1998 w/ Amendment ANSI INCITS.305/AM1-2000");
break;
case 0x01E0:
scsiOneValue.Add("Device complies with SCC-2 (no version claimed)");
@@ -744,7 +748,8 @@ namespace DiscImageChef.Server
break;
case 0x04E7:
scsiOneValue
.Add("Device complies with MMC-6 ANSI INCITS 468-2010 + MMC-6/AM1 ANSI INCITS 468-2010/AM 1");
.Add(
"Device complies with MMC-6 ANSI INCITS 468-2010 + MMC-6/AM1 ANSI INCITS 468-2010/AM 1");
break;
case 0x0500:
scsiOneValue.Add("Device complies with ADC-3 (no version claimed)");
@@ -1033,7 +1038,8 @@ namespace DiscImageChef.Server
break;
case 0x0ABC:
scsiOneValue
.Add("Device complies with SPI ANSI INCITS 253-1995 with SPI Amnd ANSI INCITS 253/AM1-1998");
.Add(
"Device complies with SPI ANSI INCITS 253-1995 with SPI Amnd ANSI INCITS 253/AM1-1998");
break;
case 0x0AC0:
scsiOneValue.Add("Device complies with Fast-20 (no version claimed)");
@@ -1175,7 +1181,8 @@ namespace DiscImageChef.Server
break;
case 0x0C4F:
scsiOneValue
.Add("Device complies with SAS-2.1 ANSI INCITS 478-2011 w/ Amnd 1 ANSI INCITS 478/AM1-2014");
.Add(
"Device complies with SAS-2.1 ANSI INCITS 478-2011 w/ Amnd 1 ANSI INCITS 478/AM1-2014");
break;
case 0x0C52:
scsiOneValue.Add("Device complies with SAS-2.1 ISO/IEC 14776-153");
@@ -1203,7 +1210,8 @@ namespace DiscImageChef.Server
break;
case 0x0D3C:
scsiOneValue
.Add("Device complies with FC-PH ANSI INCITS 230-1994 with Amnd 1 ANSI INCITS 230/AM1-1996");
.Add(
"Device complies with FC-PH ANSI INCITS 230-1994 with Amnd 1 ANSI INCITS 230/AM1-1996");
break;
case 0x0D40:
scsiOneValue.Add("Device complies with FC-AL (no version claimed)");
@@ -1276,7 +1284,7 @@ namespace DiscImageChef.Server
break;
case 0x0E03:
scsiOneValue
.Add("Device complies with FC-FS-2 ANSI INCITS 242-2007 with AM1 ANSI INCITS 242/AM1-2007");
.Add("Device complies with FC-FS-2 ANSI INCITS 242-2007 with AM1 ANSI INCITS 242/AM1-2007");
break;
case 0x0E20:
scsiOneValue.Add("Device complies with FC-LS (no version claimed)");
@@ -1334,7 +1342,8 @@ namespace DiscImageChef.Server
break;
case 0x0EA6:
scsiOneValue
.Add("Device complies with FC 10GFC ANSI INCITS 364-2003 with AM1 ANSI INCITS 364/AM1-2007");
.Add(
"Device complies with FC 10GFC ANSI INCITS 364-2003 with AM1 ANSI INCITS 364/AM1-2007");
break;
case 0x0EC0:
scsiOneValue.Add("Device complies with FC-SP-2 (no version claimed)");
@@ -1515,22 +1524,23 @@ namespace DiscImageChef.Server
break;
case 0x1621:
scsiOneValue
.Add("Device complies with ATA/ATAPI-8 ATA8-APT Parallel Transport (no version claimed)");
.Add("Device complies with ATA/ATAPI-8 ATA8-APT Parallel Transport (no version claimed)");
break;
case 0x1622:
scsiOneValue
.Add("Device complies with ATA/ATAPI-8 ATA8-AST Serial Transport (no version claimed)");
.Add("Device complies with ATA/ATAPI-8 ATA8-AST Serial Transport (no version claimed)");
break;
case 0x1623:
scsiOneValue
.Add("Device complies with ATA/ATAPI-8 ATA8-ACS ATA/ATAPI Command Set (no version claimed)");
.Add(
"Device complies with ATA/ATAPI-8 ATA8-ACS ATA/ATAPI Command Set (no version claimed)");
break;
case 0x1628:
scsiOneValue.Add("Device complies with ATA/ATAPI-8 ATA8-AAM ANSI INCITS 451-2008");
break;
case 0x162A:
scsiOneValue
.Add("Device complies with ATA/ATAPI-8 ATA8-ACS ANSI INCITS 452-2009 w/ Amendment 1");
.Add("Device complies with ATA/ATAPI-8 ATA8-ACS ANSI INCITS 452-2009 w/ Amendment 1");
break;
case 0x1728:
scsiOneValue.Add("Device complies with Universal Serial Bus Specification, Revision 1.1");
@@ -1540,7 +1550,7 @@ namespace DiscImageChef.Server
break;
case 0x1730:
scsiOneValue
.Add("Device complies with USB Mass Storage Class Bulk-Only Transport, Revision 1.0");
.Add("Device complies with USB Mass Storage Class Bulk-Only Transport, Revision 1.0");
break;
case 0x1740:
scsiOneValue.Add("Device complies with UAS (no version claimed)");

267
DiscImageChef.Server/App_Start/ScsiMmcFeatures.cs
View File

@@ -46,93 +46,96 @@ namespace DiscImageChef.Server
/// <param name="mmcOneValue">List to put the values on</param>
public static void Report(MmcFeatures ftr, ref List<string> mmcOneValue)
{
if(ftr.SupportsAACS && ftr.AACSVersion.HasValue)
if (ftr.SupportsAACS && ftr.AACSVersion.HasValue)
mmcOneValue.Add($"Drive supports AACS version {ftr.AACSVersion}");
else if(ftr.SupportsAACS) mmcOneValue.Add("Drive supports AACS");
if(ftr.AGIDs.HasValue) mmcOneValue.Add($"Drive supports {ftr.AGIDs} AGIDs concurrently");
if(ftr.CanGenerateBindingNonce)
else if (ftr.SupportsAACS) mmcOneValue.Add("Drive supports AACS");
if (ftr.AGIDs.HasValue) mmcOneValue.Add($"Drive supports {ftr.AGIDs} AGIDs concurrently");
if (ftr.CanGenerateBindingNonce)
{
mmcOneValue.Add("Drive supports generating the binding nonce");
if(ftr.BindingNonceBlocks.HasValue)
if (ftr.BindingNonceBlocks.HasValue)
mmcOneValue.Add($"{ftr.BindingNonceBlocks} media blocks are required for the binding nonce");
}
if(ftr.BlocksPerReadableUnit > 1)
if (ftr.BlocksPerReadableUnit > 1)
mmcOneValue.Add($"{ftr.BlocksPerReadableUnit} logical blocks per media writable unit");
if(ftr.BufferUnderrunFreeInDVD) mmcOneValue.Add("Drive supports zero loss linking writing DVDs");
if(ftr.BufferUnderrunFreeInSAO) mmcOneValue.Add("Drive supports zero loss linking in Session at Once Mode");
if(ftr.BufferUnderrunFreeInTAO) mmcOneValue.Add("Drive supports zero loss linking in Track at Once Mode");
if(ftr.CanAudioScan) mmcOneValue.Add("Drive supports the SCAN command");
if(ftr.CanEject) mmcOneValue.Add("Drive can eject media");
if(ftr.CanEraseSector) mmcOneValue.Add("Drive supports media that require erasing before writing");
if(ftr.CanExpandBDRESpareArea) mmcOneValue.Add("Drive can expand the spare area on a formatted BD-RE disc");
if(ftr.CanFormat) mmcOneValue.Add("Drive can format media into logical blocks");
if(ftr.CanFormatBDREWithoutSpare) mmcOneValue.Add("Drive can format BD-RE with no spares allocated");
if(ftr.CanFormatQCert) mmcOneValue.Add("Drive can format BD-RE discs with quick certification");
if(ftr.CanFormatCert) mmcOneValue.Add("Drive can format BD-RE discs with full certification");
if(ftr.CanFormatFRF) mmcOneValue.Add("Drive can fast re-format BD-RE discs");
if(ftr.CanFormatRRM) mmcOneValue.Add("Drive can format BD-R discs with RRM format");
if(ftr.CanLoad) mmcOneValue.Add("Drive can load media");
if(ftr.CanMuteSeparateChannels) mmcOneValue.Add("Drive is able to mute channels separately");
if(ftr.CanOverwriteSAOTrack) mmcOneValue.Add("Drive can overwrite a SAO track with another in CD-RWs");
if(ftr.CanOverwriteTAOTrack) mmcOneValue.Add("Drive can overwrite a TAO track with another in CD-RWs");
if(ftr.CanPlayCDAudio) mmcOneValue.Add("Drive has an analogue audio output");
if(ftr.CanPseudoOverwriteBDR) mmcOneValue.Add("Drive can write BD-R on Pseudo-OVerwrite SRM mode");
if(ftr.CanReadAllDualR) mmcOneValue.Add("Drive can read DVD-R DL from all recording modes");
if(ftr.CanReadAllDualRW) mmcOneValue.Add("Drive can read DVD-RW DL from all recording modes");
if(ftr.CanReadBD) mmcOneValue.Add("Drive can read BD-ROM");
if(ftr.CanReadBDR) mmcOneValue.Add("Drive can read BD-R Ver.1");
if(ftr.CanReadBDRE1) mmcOneValue.Add("Drive can read BD-RE Ver.1");
if(ftr.CanReadBDRE2) mmcOneValue.Add("Drive can read BD-RE Ver.2");
if(ftr.CanReadBDROM) mmcOneValue.Add("Drive can read BD-ROM Ver.1");
if(ftr.CanReadBluBCA) mmcOneValue.Add("Drive can read BD's Burst Cutting Area");
if(ftr.CanReadCD) mmcOneValue.Add("Drive can read CD-ROM");
if(ftr.CanWriteCDMRW && ftr.CanReadDVDPlusMRW && ftr.CanWriteDVDPlusMRW)
if (ftr.BufferUnderrunFreeInDVD) mmcOneValue.Add("Drive supports zero loss linking writing DVDs");
if (ftr.BufferUnderrunFreeInSAO)
mmcOneValue.Add("Drive supports zero loss linking in Session at Once Mode");
if (ftr.BufferUnderrunFreeInTAO) mmcOneValue.Add("Drive supports zero loss linking in Track at Once Mode");
if (ftr.CanAudioScan) mmcOneValue.Add("Drive supports the SCAN command");
if (ftr.CanEject) mmcOneValue.Add("Drive can eject media");
if (ftr.CanEraseSector) mmcOneValue.Add("Drive supports media that require erasing before writing");
if (ftr.CanExpandBDRESpareArea)
mmcOneValue.Add("Drive can expand the spare area on a formatted BD-RE disc");
if (ftr.CanFormat) mmcOneValue.Add("Drive can format media into logical blocks");
if (ftr.CanFormatBDREWithoutSpare) mmcOneValue.Add("Drive can format BD-RE with no spares allocated");
if (ftr.CanFormatQCert) mmcOneValue.Add("Drive can format BD-RE discs with quick certification");
if (ftr.CanFormatCert) mmcOneValue.Add("Drive can format BD-RE discs with full certification");
if (ftr.CanFormatFRF) mmcOneValue.Add("Drive can fast re-format BD-RE discs");
if (ftr.CanFormatRRM) mmcOneValue.Add("Drive can format BD-R discs with RRM format");
if (ftr.CanLoad) mmcOneValue.Add("Drive can load media");
if (ftr.CanMuteSeparateChannels) mmcOneValue.Add("Drive is able to mute channels separately");
if (ftr.CanOverwriteSAOTrack) mmcOneValue.Add("Drive can overwrite a SAO track with another in CD-RWs");
if (ftr.CanOverwriteTAOTrack) mmcOneValue.Add("Drive can overwrite a TAO track with another in CD-RWs");
if (ftr.CanPlayCDAudio) mmcOneValue.Add("Drive has an analogue audio output");
if (ftr.CanPseudoOverwriteBDR) mmcOneValue.Add("Drive can write BD-R on Pseudo-OVerwrite SRM mode");
if (ftr.CanReadAllDualR) mmcOneValue.Add("Drive can read DVD-R DL from all recording modes");
if (ftr.CanReadAllDualRW) mmcOneValue.Add("Drive can read DVD-RW DL from all recording modes");
if (ftr.CanReadBD) mmcOneValue.Add("Drive can read BD-ROM");
if (ftr.CanReadBDR) mmcOneValue.Add("Drive can read BD-R Ver.1");
if (ftr.CanReadBDRE1) mmcOneValue.Add("Drive can read BD-RE Ver.1");
if (ftr.CanReadBDRE2) mmcOneValue.Add("Drive can read BD-RE Ver.2");
if (ftr.CanReadBDROM) mmcOneValue.Add("Drive can read BD-ROM Ver.1");
if (ftr.CanReadBluBCA) mmcOneValue.Add("Drive can read BD's Burst Cutting Area");
if (ftr.CanReadCD) mmcOneValue.Add("Drive can read CD-ROM");
if (ftr.CanWriteCDMRW && ftr.CanReadDVDPlusMRW && ftr.CanWriteDVDPlusMRW)
mmcOneValue.Add("Drive can read and write CD-MRW and DVD+MRW");
else if(ftr.CanReadDVDPlusMRW && ftr.CanWriteDVDPlusMRW)
else if (ftr.CanReadDVDPlusMRW && ftr.CanWriteDVDPlusMRW)
mmcOneValue.Add("Drive can read and write DVD+MRW");
else if(ftr.CanWriteCDMRW && ftr.CanReadDVDPlusMRW)
else if (ftr.CanWriteCDMRW && ftr.CanReadDVDPlusMRW)
mmcOneValue.Add("Drive and read DVD+MRW and read and write CD-MRW");
else if(ftr.CanWriteCDMRW) mmcOneValue.Add("Drive can read and write CD-MRW");
else if(ftr.CanReadDVDPlusMRW) mmcOneValue.Add("Drive can read CD-MRW and DVD+MRW");
else if(ftr.CanReadCDMRW) mmcOneValue.Add("Drive can read CD-MRW");
if(ftr.CanReadCPRM_MKB) mmcOneValue.Add("Drive supports reading Media Key Block of CPRM");
if(ftr.CanReadDDCD) mmcOneValue.Add("Drive can read DDCDs");
if(ftr.CanReadDVD) mmcOneValue.Add("Drive can read DVD");
if(ftr.CanWriteDVDPlusRW) mmcOneValue.Add("Drive can read and write DVD+RW");
else if(ftr.CanReadDVDPlusRW) mmcOneValue.Add("Drive can read DVD+RW");
if(ftr.CanWriteDVDPlusR) mmcOneValue.Add("Drive can read and write DVD+R");
else if(ftr.CanReadDVDPlusR) mmcOneValue.Add("Drive can read DVD+R");
if(ftr.CanWriteDVDPlusRDL) mmcOneValue.Add("Drive can read and write DVD+R DL");
else if(ftr.CanReadDVDPlusRDL) mmcOneValue.Add("Drive can read DVD+R DL");
if(ftr.CanReadDriveAACSCertificate) mmcOneValue.Add("Drive supports reading the Drive Certificate");
if(ftr.CanReadHDDVD && ftr.CanReadHDDVDR && ftr.CanReadHDDVDRAM)
else if (ftr.CanWriteCDMRW) mmcOneValue.Add("Drive can read and write CD-MRW");
else if (ftr.CanReadDVDPlusMRW) mmcOneValue.Add("Drive can read CD-MRW and DVD+MRW");
else if (ftr.CanReadCDMRW) mmcOneValue.Add("Drive can read CD-MRW");
if (ftr.CanReadCPRM_MKB) mmcOneValue.Add("Drive supports reading Media Key Block of CPRM");
if (ftr.CanReadDDCD) mmcOneValue.Add("Drive can read DDCDs");
if (ftr.CanReadDVD) mmcOneValue.Add("Drive can read DVD");
if (ftr.CanWriteDVDPlusRW) mmcOneValue.Add("Drive can read and write DVD+RW");
else if (ftr.CanReadDVDPlusRW) mmcOneValue.Add("Drive can read DVD+RW");
if (ftr.CanWriteDVDPlusR) mmcOneValue.Add("Drive can read and write DVD+R");
else if (ftr.CanReadDVDPlusR) mmcOneValue.Add("Drive can read DVD+R");
if (ftr.CanWriteDVDPlusRDL) mmcOneValue.Add("Drive can read and write DVD+R DL");
else if (ftr.CanReadDVDPlusRDL) mmcOneValue.Add("Drive can read DVD+R DL");
if (ftr.CanReadDriveAACSCertificate) mmcOneValue.Add("Drive supports reading the Drive Certificate");
if (ftr.CanReadHDDVD && ftr.CanReadHDDVDR && ftr.CanReadHDDVDRAM)
mmcOneValue.Add("Drive can read HD DVD-ROM, HD DVD-RW, HD DVD-R and HD DVD-RAM");
else if(ftr.CanReadHDDVD && ftr.CanReadHDDVDR)
else if (ftr.CanReadHDDVD && ftr.CanReadHDDVDR)
mmcOneValue.Add("Drive can read HD DVD-ROM, HD DVD-RW and HD DVD-R");
else if(ftr.CanReadHDDVD && ftr.CanReadHDDVDRAM)
else if (ftr.CanReadHDDVD && ftr.CanReadHDDVDRAM)
mmcOneValue.Add("Drive can read HD DVD-ROM, HD DVD-RW and HD DVD-RAM");
else if(ftr.CanReadHDDVD) mmcOneValue.Add("Drive can read HD DVD-ROM and HD DVD-RW");
if(ftr.CanReadLeadInCDText) mmcOneValue.Add("Drive can return CD-Text from Lead-In");
if(ftr.CanReadOldBDR) mmcOneValue.Add("Drive can read BD-R pre-1.0");
if(ftr.CanReadOldBDRE) mmcOneValue.Add("Drive can read BD-RE pre-1.0");
if(ftr.CanReadOldBDROM) mmcOneValue.Add("Drive can read BD-ROM pre-1.0");
if(ftr.CanReadSpareAreaInformation) mmcOneValue.Add("Drive can return Spare Area Information");
if(ftr.CanReportDriveSerial) mmcOneValue.Add("Drive is to report drive serial number");
if(ftr.CanReportMediaSerial) mmcOneValue.Add("Drive is to read media serial number");
if(ftr.CanTestWriteDDCDR) mmcOneValue.Add("Drive can do a test writing with DDCD-R");
if(ftr.CanTestWriteDVD) mmcOneValue.Add("Drive can do a test writing with DVDs");
if(ftr.CanTestWriteInSAO) mmcOneValue.Add("Drive can do a test writing in Session at Once Mode");
if(ftr.CanTestWriteInTAO) mmcOneValue.Add("Drive can do a test writing in Track at Once Mode");
if(ftr.CanUpgradeFirmware) mmcOneValue.Add("Drive supports Microcode Upgrade");
if(ftr.ErrorRecoveryPage) mmcOneValue.Add("Drive shall report Read/Write Error Recovery mode page");
if(ftr.Locked) mmcOneValue.Add("Drive can lock media");
if(ftr.LogicalBlockSize > 0) mmcOneValue.Add($"{ftr.LogicalBlockSize} bytes per logical block");
if(ftr.MultiRead)
mmcOneValue.Add("Drive claims capability to read all CD formats according to OSTA Multi-Read Specification");
else if (ftr.CanReadHDDVD) mmcOneValue.Add("Drive can read HD DVD-ROM and HD DVD-RW");
if (ftr.CanReadLeadInCDText) mmcOneValue.Add("Drive can return CD-Text from Lead-In");
if (ftr.CanReadOldBDR) mmcOneValue.Add("Drive can read BD-R pre-1.0");
if (ftr.CanReadOldBDRE) mmcOneValue.Add("Drive can read BD-RE pre-1.0");
if (ftr.CanReadOldBDROM) mmcOneValue.Add("Drive can read BD-ROM pre-1.0");
if (ftr.CanReadSpareAreaInformation) mmcOneValue.Add("Drive can return Spare Area Information");
if (ftr.CanReportDriveSerial) mmcOneValue.Add("Drive is to report drive serial number");
if (ftr.CanReportMediaSerial) mmcOneValue.Add("Drive is to read media serial number");
if (ftr.CanTestWriteDDCDR) mmcOneValue.Add("Drive can do a test writing with DDCD-R");
if (ftr.CanTestWriteDVD) mmcOneValue.Add("Drive can do a test writing with DVDs");
if (ftr.CanTestWriteInSAO) mmcOneValue.Add("Drive can do a test writing in Session at Once Mode");
if (ftr.CanTestWriteInTAO) mmcOneValue.Add("Drive can do a test writing in Track at Once Mode");
if (ftr.CanUpgradeFirmware) mmcOneValue.Add("Drive supports Microcode Upgrade");
if (ftr.ErrorRecoveryPage) mmcOneValue.Add("Drive shall report Read/Write Error Recovery mode page");
if (ftr.Locked) mmcOneValue.Add("Drive can lock media");
if (ftr.LogicalBlockSize > 0) mmcOneValue.Add($"{ftr.LogicalBlockSize} bytes per logical block");
if (ftr.MultiRead)
mmcOneValue.Add(
"Drive claims capability to read all CD formats according to OSTA Multi-Read Specification");
if(ftr.PhysicalInterfaceStandard.HasValue)
switch(ftr.PhysicalInterfaceStandard)
if (ftr.PhysicalInterfaceStandard.HasValue)
switch (ftr.PhysicalInterfaceStandard)
{
case PhysicalInterfaces.Unspecified:
mmcOneValue.Add("Drive uses an unspecified physical interface");
@@ -166,86 +169,86 @@ namespace DiscImageChef.Server
break;
default:
mmcOneValue
.Add($"Drive uses an unknown interface with code {(uint)ftr.PhysicalInterfaceStandard}");
.Add($"Drive uses an unknown interface with code {(uint) ftr.PhysicalInterfaceStandard}");
break;
}
if(ftr.PreventJumper) mmcOneValue.Add("Drive power ups locked");
if(ftr.SupportsBusEncryption) mmcOneValue.Add("Drive supports bus encryption");
if(ftr.CanWriteBD) mmcOneValue.Add("Drive can write BD-R or BD-RE");
if(ftr.CanWriteBDR) mmcOneValue.Add("Drive can write BD-R Ver.1");
if(ftr.CanWriteBDRE1) mmcOneValue.Add("Drive can write BD-RE Ver.1");
if(ftr.CanWriteBDRE2) mmcOneValue.Add("Drive can write BD-RE Ver.2");
if(ftr.CanWriteBusEncryptedBlocks) mmcOneValue.Add("Drive supports writing with bus encryption");
if(ftr.CanWriteCDRW) mmcOneValue.Add("Drive can write CD-RW");
if(ftr.CanWriteCDRWCAV) mmcOneValue.Add("Drive can write High-Speed CD-RW");
if(ftr.CanWriteCDSAO && !ftr.CanWriteRaw)
if (ftr.PreventJumper) mmcOneValue.Add("Drive power ups locked");
if (ftr.SupportsBusEncryption) mmcOneValue.Add("Drive supports bus encryption");
if (ftr.CanWriteBD) mmcOneValue.Add("Drive can write BD-R or BD-RE");
if (ftr.CanWriteBDR) mmcOneValue.Add("Drive can write BD-R Ver.1");
if (ftr.CanWriteBDRE1) mmcOneValue.Add("Drive can write BD-RE Ver.1");
if (ftr.CanWriteBDRE2) mmcOneValue.Add("Drive can write BD-RE Ver.2");
if (ftr.CanWriteBusEncryptedBlocks) mmcOneValue.Add("Drive supports writing with bus encryption");
if (ftr.CanWriteCDRW) mmcOneValue.Add("Drive can write CD-RW");
if (ftr.CanWriteCDRWCAV) mmcOneValue.Add("Drive can write High-Speed CD-RW");
if (ftr.CanWriteCDSAO && !ftr.CanWriteRaw)
mmcOneValue.Add("Drive can write CDs in Session at Once Mode:");
else if(!ftr.CanWriteCDSAO && ftr.CanWriteRaw) mmcOneValue.Add("Drive can write CDs in raw Mode:");
else if(ftr.CanWriteCDSAO && ftr.CanWriteRaw)
else if (!ftr.CanWriteCDSAO && ftr.CanWriteRaw) mmcOneValue.Add("Drive can write CDs in raw Mode:");
else if (ftr.CanWriteCDSAO && ftr.CanWriteRaw)
mmcOneValue.Add("Drive can write CDs in Session at Once and in Raw Modes:");
if(ftr.CanWriteCDTAO) mmcOneValue.Add("Drive can write CDs in Track at Once Mode:");
if(ftr.CanWriteCSSManagedDVD) mmcOneValue.Add("Drive can write CSS managed DVDs");
if(ftr.CanWriteDDCDR) mmcOneValue.Add("Drive supports writing DDCD-R");
if(ftr.CanWriteDDCDRW) mmcOneValue.Add("Drive supports writing DDCD-RW");
if(ftr.CanWriteDVDPlusRWDL) mmcOneValue.Add("Drive can read and write DVD+RW DL");
else if(ftr.CanReadDVDPlusRWDL) mmcOneValue.Add("Drive can read DVD+RW DL");
if(ftr.CanWriteDVDR && ftr.CanWriteDVDRW && ftr.CanWriteDVDRDL)
if (ftr.CanWriteCDTAO) mmcOneValue.Add("Drive can write CDs in Track at Once Mode:");
if (ftr.CanWriteCSSManagedDVD) mmcOneValue.Add("Drive can write CSS managed DVDs");
if (ftr.CanWriteDDCDR) mmcOneValue.Add("Drive supports writing DDCD-R");
if (ftr.CanWriteDDCDRW) mmcOneValue.Add("Drive supports writing DDCD-RW");
if (ftr.CanWriteDVDPlusRWDL) mmcOneValue.Add("Drive can read and write DVD+RW DL");
else if (ftr.CanReadDVDPlusRWDL) mmcOneValue.Add("Drive can read DVD+RW DL");
if (ftr.CanWriteDVDR && ftr.CanWriteDVDRW && ftr.CanWriteDVDRDL)
mmcOneValue.Add("Drive supports writing DVD-R, DVD-RW and DVD-R DL");
else if(ftr.CanWriteDVDR && ftr.CanWriteDVDRDL)
else if (ftr.CanWriteDVDR && ftr.CanWriteDVDRDL)
mmcOneValue.Add("Drive supports writing DVD-R and DVD-R DL");
else if(ftr.CanWriteDVDR && ftr.CanWriteDVDRW) mmcOneValue.Add("Drive supports writing DVD-R and DVD-RW");
else if(ftr.CanWriteDVDR) mmcOneValue.Add("Drive supports writing DVD-R");
if(ftr.CanWriteHDDVDR && ftr.CanWriteHDDVDRAM)
else if (ftr.CanWriteDVDR && ftr.CanWriteDVDRW) mmcOneValue.Add("Drive supports writing DVD-R and DVD-RW");
else if (ftr.CanWriteDVDR) mmcOneValue.Add("Drive supports writing DVD-R");
if (ftr.CanWriteHDDVDR && ftr.CanWriteHDDVDRAM)
mmcOneValue.Add("Drive can write HD DVD-RW, HD DVD-R and HD DVD-RAM");
else if(ftr.CanWriteHDDVDR) mmcOneValue.Add("Drive can write HD DVD-RW and HD DVD-R");
else if(ftr.CanWriteHDDVDRAM) mmcOneValue.Add("Drive can write HD DVD-RW and HD DVD-RAM");
else if (ftr.CanWriteHDDVDR) mmcOneValue.Add("Drive can write HD DVD-RW and HD DVD-R");
else if (ftr.CanWriteHDDVDRAM) mmcOneValue.Add("Drive can write HD DVD-RW and HD DVD-RAM");
// TODO: Write HD DVD-RW
/*
else
mmcOneValue.Add("Drive can write HD DVD-RW");
*/
if(ftr.CanWriteOldBDR) mmcOneValue.Add("Drive can write BD-R pre-1.0");
if(ftr.CanWriteOldBDRE) mmcOneValue.Add("Drive can write BD-RE pre-1.0");
if(ftr.CanWriteRWSubchannelInTAO)
if (ftr.CanWriteOldBDR) mmcOneValue.Add("Drive can write BD-R pre-1.0");
if (ftr.CanWriteOldBDRE) mmcOneValue.Add("Drive can write BD-RE pre-1.0");
if (ftr.CanWriteRWSubchannelInTAO)
{
mmcOneValue.Add("Drive can write user provided data in the R-W subchannels in Track at Once Mode");
if(ftr.CanWriteRawSubchannelInTAO)
if (ftr.CanWriteRawSubchannelInTAO)
mmcOneValue.Add("Drive accepts RAW R-W subchannel data in Track at Once Mode");
if(ftr.CanWritePackedSubchannelInTAO)
if (ftr.CanWritePackedSubchannelInTAO)
mmcOneValue.Add("Drive accepts Packed R-W subchannel data in Track at Once Mode");
}
if(ftr.CanWriteRWSubchannelInSAO)
if (ftr.CanWriteRWSubchannelInSAO)
mmcOneValue.Add("Drive can write user provided data in the R-W subchannels in Session at Once Mode");
if(ftr.CanWriteRaw && ftr.CanWriteRawMultiSession)
if (ftr.CanWriteRaw && ftr.CanWriteRawMultiSession)
mmcOneValue.Add("Drive can write multi-session CDs in raw mode");
if(ftr.EmbeddedChanger)
if (ftr.EmbeddedChanger)
{
mmcOneValue.Add("Drive contains an embedded changer");
if(ftr.ChangerIsSideChangeCapable) mmcOneValue.Add("Drive can change disc side");
if(ftr.ChangerSupportsDiscPresent)
if (ftr.ChangerIsSideChangeCapable) mmcOneValue.Add("Drive can change disc side");
if (ftr.ChangerSupportsDiscPresent)
mmcOneValue.Add("Drive is able to report slots contents after a reset or change");
mmcOneValue.Add($"Drive has {ftr.ChangerSlots + 1} slots");
}
if(ftr.SupportsCSS && ftr.CSSVersion.HasValue)
if (ftr.SupportsCSS && ftr.CSSVersion.HasValue)
mmcOneValue.Add($"Drive supports DVD CSS/CPPM version {ftr.CSSVersion}");
else if(ftr.SupportsCSS) mmcOneValue.Add("Drive supports DVD CSS/CPRM");
if(ftr.SupportsCPRM && ftr.CPRMVersion.HasValue)
else if (ftr.SupportsCSS) mmcOneValue.Add("Drive supports DVD CSS/CPRM");
if (ftr.SupportsCPRM && ftr.CPRMVersion.HasValue)
mmcOneValue.Add($"Drive supports DVD CPPM version {ftr.CPRMVersion}");
else if(ftr.SupportsCPRM) mmcOneValue.Add("Drive supports DVD CPRM");
if(ftr.DBML) mmcOneValue.Add("Drive reports Device Busy Class events during medium loading/unloading");
if(ftr.DVDMultiRead) mmcOneValue.Add("Drive conforms to DVD Multi Drive Read-only Specifications");
if(ftr.FirmwareDate.HasValue) mmcOneValue.Add($"Drive firmware is dated {ftr.FirmwareDate}");
if(ftr.SupportsC2) mmcOneValue.Add("Drive supports C2 Error Pointers");
if(ftr.SupportsDAP) mmcOneValue.Add("Drive supports the DAP bit in the READ CD and READ CD MSF commands");
if(ftr.SupportsDeviceBusyEvent) mmcOneValue.Add("Drive supports Device Busy events");
else if (ftr.SupportsCPRM) mmcOneValue.Add("Drive supports DVD CPRM");
if (ftr.DBML) mmcOneValue.Add("Drive reports Device Busy Class events during medium loading/unloading");
if (ftr.DVDMultiRead) mmcOneValue.Add("Drive conforms to DVD Multi Drive Read-only Specifications");
if (ftr.FirmwareDate.HasValue) mmcOneValue.Add($"Drive firmware is dated {ftr.FirmwareDate}");
if (ftr.SupportsC2) mmcOneValue.Add("Drive supports C2 Error Pointers");
if (ftr.SupportsDAP) mmcOneValue.Add("Drive supports the DAP bit in the READ CD and READ CD MSF commands");
if (ftr.SupportsDeviceBusyEvent) mmcOneValue.Add("Drive supports Device Busy events");
if(ftr.LoadingMechanismType.HasValue)
switch(ftr.LoadingMechanismType)
if (ftr.LoadingMechanismType.HasValue)
switch (ftr.LoadingMechanismType)
{
case 0:
mmcOneValue.Add("Drive uses media caddy");
@@ -267,20 +270,20 @@ namespace DiscImageChef.Server
break;
}
if(ftr.SupportsHybridDiscs) mmcOneValue.Add("Drive is able to access Hybrid discs");
if(ftr.SupportsModePage1Ch)
if (ftr.SupportsHybridDiscs) mmcOneValue.Add("Drive is able to access Hybrid discs");
if (ftr.SupportsModePage1Ch)
mmcOneValue.Add("Drive supports the Informational Exceptions Control mode page 1Ch");
if(ftr.SupportsOSSC)
if (ftr.SupportsOSSC)
mmcOneValue.Add("Drive supports the Trusted Computing Group Optical Security Subsystem Class");
if(ftr.SupportsPWP) mmcOneValue.Add("Drive supports set/release of PWP status");
if(ftr.SupportsSWPP) mmcOneValue.Add("Drive supports the SWPP bit of the Timeout and Protect mode page");
if(ftr.SupportsSecurDisc) mmcOneValue.Add("Drive supports SecurDisc");
if(ftr.SupportsSeparateVolume) mmcOneValue.Add("Drive supports separate volume per channel");
if(ftr.SupportsVCPS) mmcOneValue.Add("Drive supports VCPS");
if(ftr.VolumeLevels.HasValue) mmcOneValue.Add($"Drive has {ftr.VolumeLevels + 1} volume levels");
if(ftr.SupportsWriteProtectPAC)
if (ftr.SupportsPWP) mmcOneValue.Add("Drive supports set/release of PWP status");
if (ftr.SupportsSWPP) mmcOneValue.Add("Drive supports the SWPP bit of the Timeout and Protect mode page");
if (ftr.SupportsSecurDisc) mmcOneValue.Add("Drive supports SecurDisc");
if (ftr.SupportsSeparateVolume) mmcOneValue.Add("Drive supports separate volume per channel");
if (ftr.SupportsVCPS) mmcOneValue.Add("Drive supports VCPS");
if (ftr.VolumeLevels.HasValue) mmcOneValue.Add($"Drive has {ftr.VolumeLevels + 1} volume levels");
if (ftr.SupportsWriteProtectPAC)
mmcOneValue.Add("Drive supports reading/writing the Disc Write Protect PAC on BD-R/-RE media");
if(ftr.SupportsWriteInhibitDCB)
if (ftr.SupportsWriteInhibitDCB)
mmcOneValue.Add("Drive supports writing the Write Inhibit DCB on DVD+RW media");
mmcOneValue.Sort();

110
DiscImageChef.Server/App_Start/ScsiMmcMode.cs
View File

@@ -46,20 +46,20 @@ namespace DiscImageChef.Server
/// <param name="mmcOneValue">List to put the values on</param>
public static void Report(Modes.ModePage_2A mode, ref List<string> mmcOneValue)
{
if(mode.AudioPlay) mmcOneValue.Add("Drive can play audio");
if(mode.Mode2Form1) mmcOneValue.Add("Drive can read sectors in Mode 2 Form 1 format");
if(mode.Mode2Form2) mmcOneValue.Add("Drive can read sectors in Mode 2 Form 2 format");
if(mode.MultiSession) mmcOneValue.Add("Drive supports multi-session discs and/or Photo-CD");
if (mode.AudioPlay) mmcOneValue.Add("Drive can play audio");
if (mode.Mode2Form1) mmcOneValue.Add("Drive can read sectors in Mode 2 Form 1 format");
if (mode.Mode2Form2) mmcOneValue.Add("Drive can read sectors in Mode 2 Form 2 format");
if (mode.MultiSession) mmcOneValue.Add("Drive supports multi-session discs and/or Photo-CD");
if(mode.CDDACommand) mmcOneValue.Add("Drive can read digital audio");
if(mode.AccurateCDDA) mmcOneValue.Add("Drive can continue from streaming loss");
if(mode.Subchannel) mmcOneValue.Add("Drive can read uncorrected and interleaved R-W subchannels");
if(mode.DeinterlaveSubchannel) mmcOneValue.Add("Drive can read, deinterleave and correct R-W subchannels");
if(mode.C2Pointer) mmcOneValue.Add("Drive supports C2 pointers");
if(mode.UPC) mmcOneValue.Add("Drive can read Media Catalogue Number");
if(mode.ISRC) mmcOneValue.Add("Drive can read ISRC");
if (mode.CDDACommand) mmcOneValue.Add("Drive can read digital audio");
if (mode.AccurateCDDA) mmcOneValue.Add("Drive can continue from streaming loss");
if (mode.Subchannel) mmcOneValue.Add("Drive can read uncorrected and interleaved R-W subchannels");
if (mode.DeinterlaveSubchannel) mmcOneValue.Add("Drive can read, deinterleave and correct R-W subchannels");
if (mode.C2Pointer) mmcOneValue.Add("Drive supports C2 pointers");
if (mode.UPC) mmcOneValue.Add("Drive can read Media Catalogue Number");
if (mode.ISRC) mmcOneValue.Add("Drive can read ISRC");
switch(mode.LoadingMechanism)
switch (mode.LoadingMechanism)
{
case 0:
mmcOneValue.Add("Drive uses media caddy");
@@ -81,89 +81,93 @@ namespace DiscImageChef.Server
break;
}
if(mode.Lock) mmcOneValue.Add("Drive can lock media");
if(mode.PreventJumper)
if (mode.Lock) mmcOneValue.Add("Drive can lock media");
if (mode.PreventJumper)
{
mmcOneValue.Add("Drive power ups locked");
mmcOneValue.Add(mode.LockState
? "Drive is locked, media cannot be ejected or inserted"
: "Drive is not locked, media can be ejected and inserted");
? "Drive is locked, media cannot be ejected or inserted"
: "Drive is not locked, media can be ejected and inserted");
}
else
{
mmcOneValue.Add(mode.LockState
? "Drive is locked, media cannot be ejected, but if empty, can be inserted"
: "Drive is not locked, media can be ejected and inserted");
? "Drive is locked, media cannot be ejected, but if empty, can be inserted"
: "Drive is not locked, media can be ejected and inserted");
}
if(mode.Eject) mmcOneValue.Add("Drive can eject media");
if (mode.Eject) mmcOneValue.Add("Drive can eject media");
if(mode.SeparateChannelMute) mmcOneValue.Add("Each channel can be muted independently");
if(mode.SeparateChannelVolume) mmcOneValue.Add("Each channel's volume can be controlled independently");
if (mode.SeparateChannelMute) mmcOneValue.Add("Each channel can be muted independently");
if (mode.SeparateChannelVolume) mmcOneValue.Add("Each channel's volume can be controlled independently");
if(mode.SupportedVolumeLevels > 0)
if (mode.SupportedVolumeLevels > 0)
mmcOneValue.Add($"Drive supports {mode.SupportedVolumeLevels} volume levels");
if(mode.BufferSize > 0) mmcOneValue.Add($"Drive has {mode.BufferSize} Kbyte of buffer");
if(mode.MaximumSpeed > 0)
if (mode.BufferSize > 0) mmcOneValue.Add($"Drive has {mode.BufferSize} Kbyte of buffer");
if (mode.MaximumSpeed > 0)
mmcOneValue.Add($"Drive's maximum reading speed is {mode.MaximumSpeed} Kbyte/sec.");
if(mode.CurrentSpeed > 0)
if (mode.CurrentSpeed > 0)
mmcOneValue.Add($"Drive's current reading speed is {mode.CurrentSpeed} Kbyte/sec.");
if(mode.ReadCDR)
if (mode.ReadCDR)
{
mmcOneValue.Add(mode.WriteCDR ? "Drive can read and write CD-R" : "Drive can read CD-R");
if(mode.Method2) mmcOneValue.Add("Drive supports reading CD-R packet media");
if (mode.Method2) mmcOneValue.Add("Drive supports reading CD-R packet media");
}
if(mode.ReadCDRW)
if (mode.ReadCDRW)
mmcOneValue.Add(mode.WriteCDRW ? "Drive can read and write CD-RW" : "Drive can read CD-RW");
if(mode.ReadDVDROM) mmcOneValue.Add("Drive can read DVD-ROM");
if(mode.ReadDVDR)
if (mode.ReadDVDROM) mmcOneValue.Add("Drive can read DVD-ROM");
if (mode.ReadDVDR)
mmcOneValue.Add(mode.WriteDVDR ? "Drive can read and write DVD-R" : "Drive can read DVD-R");
if(mode.ReadDVDRAM)
if (mode.ReadDVDRAM)
mmcOneValue.Add(mode.WriteDVDRAM ? "Drive can read and write DVD-RAM" : "Drive can read DVD-RAM");
if(mode.Composite) mmcOneValue.Add("Drive can deliver a composite audio and video data stream");
if(mode.DigitalPort1) mmcOneValue.Add("Drive supports IEC-958 digital output on port 1");
if(mode.DigitalPort2) mmcOneValue.Add("Drive supports IEC-958 digital output on port 2");
if (mode.Composite) mmcOneValue.Add("Drive can deliver a composite audio and video data stream");
if (mode.DigitalPort1) mmcOneValue.Add("Drive supports IEC-958 digital output on port 1");
if (mode.DigitalPort2) mmcOneValue.Add("Drive supports IEC-958 digital output on port 2");
if(mode.SDP) mmcOneValue.Add("Drive contains a changer that can report the exact contents of the slots");
if(mode.CurrentWriteSpeedSelected > 0)
if (mode.SDP) mmcOneValue.Add("Drive contains a changer that can report the exact contents of the slots");
if (mode.CurrentWriteSpeedSelected > 0)
{
if(mode.RotationControlSelected == 0)
if (mode.RotationControlSelected == 0)
mmcOneValue
.Add($"Drive's current writing speed is {mode.CurrentWriteSpeedSelected} Kbyte/sec. in CLV mode");
else if(mode.RotationControlSelected == 1)
.Add(
$"Drive's current writing speed is {mode.CurrentWriteSpeedSelected} Kbyte/sec. in CLV mode");
else if (mode.RotationControlSelected == 1)
mmcOneValue
.Add($"Drive's current writing speed is {mode.CurrentWriteSpeedSelected} Kbyte/sec. in pure CAV mode");
.Add(
$"Drive's current writing speed is {mode.CurrentWriteSpeedSelected} Kbyte/sec. in pure CAV mode");
}
else
{
if(mode.MaxWriteSpeed > 0)
if (mode.MaxWriteSpeed > 0)
mmcOneValue.Add($"Drive's maximum writing speed is {mode.MaxWriteSpeed} Kbyte/sec.");
if(mode.CurrentWriteSpeed > 0)
if (mode.CurrentWriteSpeed > 0)
mmcOneValue.Add($"Drive's current writing speed is {mode.CurrentWriteSpeed} Kbyte/sec.");
}
if(mode.WriteSpeedPerformanceDescriptors != null)
foreach(Modes.ModePage_2A_WriteDescriptor descriptor in
if (mode.WriteSpeedPerformanceDescriptors != null)
foreach (var descriptor in
mode.WriteSpeedPerformanceDescriptors.Where(descriptor => descriptor.WriteSpeed > 0))
if(descriptor.RotationControl == 0)
if (descriptor.RotationControl == 0)
mmcOneValue.Add($"Drive supports writing at {descriptor.WriteSpeed} Kbyte/sec. in CLV mode");
else if(descriptor.RotationControl == 1)
else if (descriptor.RotationControl == 1)
mmcOneValue
.Add($"Drive supports writing at is {descriptor.WriteSpeed} Kbyte/sec. in pure CAV mode");
.Add($"Drive supports writing at is {descriptor.WriteSpeed} Kbyte/sec. in pure CAV mode");
if(mode.TestWrite) mmcOneValue.Add("Drive supports test writing");
if (mode.TestWrite) mmcOneValue.Add("Drive supports test writing");
if(mode.ReadBarcode) mmcOneValue.Add("Drive can read barcode");
if (mode.ReadBarcode) mmcOneValue.Add("Drive can read barcode");
if(mode.SCC) mmcOneValue.Add("Drive can read both sides of a disc");
if(mode.LeadInPW) mmcOneValue.Add("Drive an read raw R-W subchannel from the Lead-In");
if (mode.SCC) mmcOneValue.Add("Drive can read both sides of a disc");
if (mode.LeadInPW) mmcOneValue.Add("Drive an read raw R-W subchannel from the Lead-In");
if(mode.CMRSupported == 1) mmcOneValue.Add("Drive supports DVD CSS and/or DVD CPPM");
if (mode.CMRSupported == 1) mmcOneValue.Add("Drive supports DVD CSS and/or DVD CPPM");
if(mode.BUF) mmcOneValue.Add("Drive supports buffer under-run free recording");
if (mode.BUF) mmcOneValue.Add("Drive supports buffer under-run free recording");
mmcOneValue.Sort();
mmcOneValue.Add("");

153
DiscImageChef.Server/App_Start/ScsiModeSense.cs
View File

@@ -47,24 +47,25 @@ namespace DiscImageChef.Server
/// <param name="deviceType">SCSI peripheral device type</param>
/// <param name="scsiOneValue">List to put values on</param>
/// <param name="modePages">List to put key=value pairs on</param>
public static void Report(ScsiMode modeSense, string vendor,
PeripheralDeviceTypes deviceType,
ref List<string> scsiOneValue, ref Dictionary<string, string> modePages)
public static void Report(ScsiMode modeSense, string vendor,
PeripheralDeviceTypes deviceType,
ref List<string> scsiOneValue, ref Dictionary<string, string> modePages)
{
if(modeSense.MediumType.HasValue) scsiOneValue.Add($"Medium type is {modeSense.MediumType:X2}h");
if(modeSense.WriteProtected) scsiOneValue.Add("Device is write protected.");
if(modeSense.BlockDescriptors != null)
foreach(BlockDescriptor descriptor in modeSense.BlockDescriptors)
if(descriptor.Blocks.HasValue && descriptor.BlockLength.HasValue)
if (modeSense.MediumType.HasValue) scsiOneValue.Add($"Medium type is {modeSense.MediumType:X2}h");
if (modeSense.WriteProtected) scsiOneValue.Add("Device is write protected.");
if (modeSense.BlockDescriptors != null)
foreach (var descriptor in modeSense.BlockDescriptors)
if (descriptor.Blocks.HasValue && descriptor.BlockLength.HasValue)
scsiOneValue
.Add($"Density code {descriptor.Density:X2}h has {descriptor.Blocks} blocks of {descriptor.BlockLength} bytes each");
.Add(
$"Density code {descriptor.Density:X2}h has {descriptor.Blocks} blocks of {descriptor.BlockLength} bytes each");
else
scsiOneValue.Add($"Density code {descriptor.Density:X2}h");
if(modeSense.DPOandFUA) scsiOneValue.Add("Drive supports DPO and FUA bits");
if(modeSense.BlankCheckEnabled) scsiOneValue.Add("Blank checking during write is enabled");
if(modeSense.BufferedMode.HasValue)
switch(modeSense.BufferedMode)
if (modeSense.DPOandFUA) scsiOneValue.Add("Drive supports DPO and FUA bits");
if (modeSense.BlankCheckEnabled) scsiOneValue.Add("Blank checking during write is enabled");
if (modeSense.BufferedMode.HasValue)
switch (modeSense.BufferedMode)
{
case 0:
scsiOneValue.Add("Device writes directly to media");
@@ -80,35 +81,38 @@ namespace DiscImageChef.Server
break;
}
if(modeSense.ModePages == null) return;
if (modeSense.ModePages == null) return;
foreach(ScsiPage page in modeSense.ModePages)
switch(page.page)
foreach (var page in modeSense.ModePages)
switch (page.page)
{
case 0x00:
{
if(deviceType == PeripheralDeviceTypes.MultiMediaDevice && page.subpage == 0)
if (deviceType == PeripheralDeviceTypes.MultiMediaDevice && page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_00_SFF(page.value));
else
modePages
.Add(page.subpage != 0 ? $"MODE page {page.page:X2}h subpage {page.subpage:X2}h" : $"MODE page {page.page:X2}h",
.Add(
page.subpage != 0
? $"MODE page {page.page:X2}h subpage {page.subpage:X2}h"
: $"MODE page {page.page:X2}h",
"Unknown vendor mode page");
break;
}
case 0x01:
{
if(page.subpage == 0)
if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h",
deviceType == PeripheralDeviceTypes.MultiMediaDevice
? Modes.PrettifyModePage_01_MMC(page.value)
: Modes.PrettifyModePage_01(page.value));
deviceType == PeripheralDeviceTypes.MultiMediaDevice
? Modes.PrettifyModePage_01_MMC(page.value)
: Modes.PrettifyModePage_01(page.value));
else goto default;
break;
}
case 0x02:
{
if(page.subpage == 0)
if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_02(page.value));
else goto default;
@@ -116,7 +120,7 @@ namespace DiscImageChef.Server
}
case 0x03:
{
if(page.subpage == 0)
if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_03(page.value));
else goto default;
@@ -124,7 +128,7 @@ namespace DiscImageChef.Server
}
case 0x04:
{
if(page.subpage == 0)
if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_04(page.value));
else goto default;
@@ -132,7 +136,7 @@ namespace DiscImageChef.Server
}
case 0x05:
{
if(page.subpage == 0)
if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_05(page.value));
else goto default;
@@ -140,7 +144,7 @@ namespace DiscImageChef.Server
}
case 0x06:
{
if(page.subpage == 0)
if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_06(page.value));
else goto default;
@@ -148,18 +152,18 @@ namespace DiscImageChef.Server
}
case 0x07:
{
if(page.subpage == 0)
if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h",
deviceType == PeripheralDeviceTypes.MultiMediaDevice
? Modes.PrettifyModePage_07_MMC(page.value)
: Modes.PrettifyModePage_07(page.value));
deviceType == PeripheralDeviceTypes.MultiMediaDevice
? Modes.PrettifyModePage_07_MMC(page.value)
: Modes.PrettifyModePage_07(page.value));
else goto default;
break;
}
case 0x08:
{
if(page.subpage == 0)
if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_08(page.value));
else goto default;
@@ -167,18 +171,18 @@ namespace DiscImageChef.Server
}
case 0x0A:
{
if(page.subpage == 0)
if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_0A(page.value));
else if(page.subpage == 1)
else if (page.subpage == 1)
modePages.Add($"MODE page {page.page:X2}h subpage {page.subpage:X2}h",
Modes.PrettifyModePage_0A_S01(page.value));
Modes.PrettifyModePage_0A_S01(page.value));
else goto default;
break;
}
case 0x0B:
{
if(page.subpage == 0)
if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_0B(page.value));
else goto default;
@@ -186,7 +190,7 @@ namespace DiscImageChef.Server
}
case 0x0D:
{
if(page.subpage == 0)
if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_0D(page.value));
else goto default;
@@ -194,7 +198,7 @@ namespace DiscImageChef.Server
}
case 0x0E:
{
if(page.subpage == 0)
if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_0E(page.value));
else goto default;
@@ -202,7 +206,7 @@ namespace DiscImageChef.Server
}
case 0x0F:
{
if(page.subpage == 0)
if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_0F(page.value));
else goto default;
@@ -210,18 +214,18 @@ namespace DiscImageChef.Server
}
case 0x10:
{
if(page.subpage == 0)
if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h",
deviceType == PeripheralDeviceTypes.SequentialAccess
? Modes.PrettifyModePage_10_SSC(page.value)
: Modes.PrettifyModePage_10(page.value));
deviceType == PeripheralDeviceTypes.SequentialAccess
? Modes.PrettifyModePage_10_SSC(page.value)
: Modes.PrettifyModePage_10(page.value));
else goto default;
break;
}
case 0x11:
{
if(page.subpage == 0)
if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_11(page.value));
else goto default;
@@ -231,7 +235,7 @@ namespace DiscImageChef.Server
case 0x13:
case 0x14:
{
if(page.subpage == 0)
if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_12_13_14(page.value));
else goto default;
@@ -239,18 +243,18 @@ namespace DiscImageChef.Server
}
case 0x1A:
{
if(page.subpage == 0)
if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_1A(page.value));
else if(page.subpage == 1)
else if (page.subpage == 1)
modePages.Add($"MODE page {page.page:X2}h subpage {page.subpage:X2}h",
Modes.PrettifyModePage_1A_S01(page.value));
Modes.PrettifyModePage_1A_S01(page.value));
else goto default;
break;
}
case 0x1B:
{
if(page.subpage == 0)
if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_1B(page.value));
else goto default;
@@ -258,21 +262,21 @@ namespace DiscImageChef.Server
}
case 0x1C:
{
if(page.subpage == 0)
if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h",
deviceType == PeripheralDeviceTypes.MultiMediaDevice
? Modes.PrettifyModePage_1C_SFF(page.value)
: Modes.PrettifyModePage_1C(page.value));
else if(page.subpage == 1)
deviceType == PeripheralDeviceTypes.MultiMediaDevice
? Modes.PrettifyModePage_1C_SFF(page.value)
: Modes.PrettifyModePage_1C(page.value));
else if (page.subpage == 1)
modePages.Add($"MODE page {page.page:X2}h subpage {page.subpage:X2}h",
Modes.PrettifyModePage_1C_S01(page.value));
Modes.PrettifyModePage_1C_S01(page.value));
else goto default;
break;
}
case 0x1D:
{
if(page.subpage == 0)
if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_1D(page.value));
else goto default;
@@ -280,7 +284,7 @@ namespace DiscImageChef.Server
}
case 0x21:
{
if(vendor == "CERTANCE")
if (vendor == "CERTANCE")
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyCertanceModePage_21(page.value));
else goto default;
@@ -288,7 +292,7 @@ namespace DiscImageChef.Server
}
case 0x22:
{
if(vendor == "CERTANCE")
if (vendor == "CERTANCE")
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyCertanceModePage_22(page.value));
else goto default;
@@ -296,7 +300,7 @@ namespace DiscImageChef.Server
}
case 0x24:
{
if(vendor == "IBM")
if (vendor == "IBM")
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyIBMModePage_24(page.value));
else goto default;
@@ -304,7 +308,7 @@ namespace DiscImageChef.Server
}
case 0x2A:
{
if(page.subpage == 0)
if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_2A(page.value));
else goto default;
@@ -312,7 +316,7 @@ namespace DiscImageChef.Server
}
case 0x2F:
{
if(vendor == "IBM")
if (vendor == "IBM")
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyIBMModePage_2F(page.value));
else goto default;
@@ -320,7 +324,7 @@ namespace DiscImageChef.Server
}
case 0x30:
{
if(Modes.IsAppleModePage_30(page.value))
if (Modes.IsAppleModePage_30(page.value))
modePages.Add("MODE page 30h", "Drive identifies as an Apple OEM drive");
else goto default;
@@ -328,7 +332,7 @@ namespace DiscImageChef.Server
}
case 0x3B:
{
if(vendor == "HP")
if (vendor == "HP")
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyHPModePage_3B(page.value));
else goto default;
@@ -336,7 +340,7 @@ namespace DiscImageChef.Server
}
case 0x3C:
{
if(vendor == "HP")
if (vendor == "HP")
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyHPModePage_3C(page.value));
else goto default;
@@ -344,9 +348,9 @@ namespace DiscImageChef.Server
}
case 0x3D:
{
if(vendor == "IBM")
if (vendor == "IBM")
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyIBMModePage_3D(page.value));
else if(vendor == "HP")
else if (vendor == "HP")
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyHPModePage_3D(page.value));
else goto default;
@@ -354,9 +358,9 @@ namespace DiscImageChef.Server
}
case 0x3E:
{
if(vendor == "FUJITSU")
if (vendor == "FUJITSU")
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyFujitsuModePage_3E(page.value));
else if(vendor == "HP")
else if (vendor == "HP")
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyHPModePage_3E(page.value));
else goto default;
@@ -364,16 +368,19 @@ namespace DiscImageChef.Server
}
default:
{
modePages.Add(page.subpage != 0 ? $"MODE page {page.page:X2}h subpage {page.subpage:X2}h" : $"MODE page {page.page:X2}h",
"Unknown mode page");
modePages.Add(
page.subpage != 0
? $"MODE page {page.page:X2}h subpage {page.subpage:X2}h"
: $"MODE page {page.page:X2}h",
"Unknown mode page");
}
break;
}
Dictionary<string, string> newModePages = new Dictionary<string, string>();
foreach(KeyValuePair<string, string> kvp in modePages)
var newModePages = new Dictionary<string, string>();
foreach (var kvp in modePages)
newModePages.Add(kvp.Key,
string.IsNullOrWhiteSpace(kvp.Value) ? "Undecoded" : kvp.Value.Replace("\n", "<br/>"));
string.IsNullOrWhiteSpace(kvp.Value) ? "Undecoded" : kvp.Value.Replace("\n", "<br/>"));
modePages = newModePages;
}

25
DiscImageChef.Server/App_Start/SscTestedMedia.cs
View File

@@ -44,24 +44,29 @@ namespace DiscImageChef.Server
/// <param name="testedMedia">List of tested media</param>
public static void Report(IEnumerable<TestedSequentialMedia> testedMedia, ref List<string> mediaOneValue)
{
foreach(TestedSequentialMedia media in testedMedia)
foreach (var media in testedMedia)
{
if(!string.IsNullOrWhiteSpace(media.MediumTypeName))
if (!string.IsNullOrWhiteSpace(media.MediumTypeName))
{
mediaOneValue.Add($"<i>Information for medium named \"{media.MediumTypeName}\"</i>");
if(media.MediumType.HasValue) mediaOneValue.Add($"Medium type code: {media.MediumType:X2}h");
if (media.MediumType.HasValue) mediaOneValue.Add($"Medium type code: {media.MediumType:X2}h");
}
else if(media.MediumType.HasValue)
else if (media.MediumType.HasValue)
{
mediaOneValue.Add($"<i>Information for medium type {media.MediumType:X2}h</i>");
else mediaOneValue.Add("<i>Information for unknown medium type</i>");
}
else
{
mediaOneValue.Add("<i>Information for unknown medium type</i>");
}
if(!string.IsNullOrWhiteSpace(media.Manufacturer))
if (!string.IsNullOrWhiteSpace(media.Manufacturer))
mediaOneValue.Add($"Medium manufactured by: {media.Manufacturer}");
if(!string.IsNullOrWhiteSpace(media.Model)) mediaOneValue.Add($"Medium model: {media.Model}");
if (!string.IsNullOrWhiteSpace(media.Model)) mediaOneValue.Add($"Medium model: {media.Model}");
if(media.Density.HasValue) mediaOneValue.Add($"Medium has density code {media.Density:X2}h");
if(media.CanReadMediaSerial == true) mediaOneValue.Add("Drive can read medium serial number.");
if(media.MediaIsRecognized) mediaOneValue.Add("Drive recognizes this medium.");
if (media.Density.HasValue) mediaOneValue.Add($"Medium has density code {media.Density:X2}h");
if (media.CanReadMediaSerial == true) mediaOneValue.Add("Drive can read medium serial number.");
if (media.MediaIsRecognized) mediaOneValue.Add("Drive recognizes this medium.");
mediaOneValue.Add("");
}

236
DiscImageChef.Server/App_Start/StatsConverter.cs
View File

@@ -41,51 +41,51 @@ namespace DiscImageChef.Server
{
public static void Convert(Stats newStats)
{
DicServerContext ctx = new DicServerContext();
var ctx = new DicServerContext();
if(newStats.Commands != null)
if (newStats.Commands != null)
{
if(newStats.Commands.Analyze > 0)
if (newStats.Commands.Analyze > 0)
{
Command existing = ctx.Commands.FirstOrDefault(c => c.Name == "analyze");
var existing = ctx.Commands.FirstOrDefault(c => c.Name == "analyze");
if(existing == null)
if (existing == null)
ctx.Commands.Add(new Command {Count = newStats.Commands.Analyze, Name = "analyze"});
else existing.Count += newStats.Commands.Analyze;
}
if(newStats.Commands.Benchmark > 0)
if (newStats.Commands.Benchmark > 0)
{
Command existing = ctx.Commands.FirstOrDefault(c => c.Name == "benchmark");
var existing = ctx.Commands.FirstOrDefault(c => c.Name == "benchmark");
if(existing == null)
if (existing == null)
ctx.Commands.Add(new Command {Count = newStats.Commands.Benchmark, Name = "benchmark"});
else existing.Count += newStats.Commands.Benchmark;
}
if(newStats.Commands.Checksum > 0)
if (newStats.Commands.Checksum > 0)
{
Command existing = ctx.Commands.FirstOrDefault(c => c.Name == "checksum");
var existing = ctx.Commands.FirstOrDefault(c => c.Name == "checksum");
if(existing == null)
if (existing == null)
ctx.Commands.Add(new Command {Count = newStats.Commands.Checksum, Name = "checksum"});
else existing.Count += newStats.Commands.Checksum;
}
if(newStats.Commands.Compare > 0)
if (newStats.Commands.Compare > 0)
{
Command existing = ctx.Commands.FirstOrDefault(c => c.Name == "compare");
var existing = ctx.Commands.FirstOrDefault(c => c.Name == "compare");
if(existing == null)
if (existing == null)
ctx.Commands.Add(new Command {Count = newStats.Commands.Compare, Name = "compare"});
else existing.Count += newStats.Commands.Compare;
}
if(newStats.Commands.CreateSidecar > 0)
if (newStats.Commands.CreateSidecar > 0)
{
Command existing = ctx.Commands.FirstOrDefault(c => c.Name == "create-sidecar");
var existing = ctx.Commands.FirstOrDefault(c => c.Name == "create-sidecar");
if(existing == null)
if (existing == null)
ctx.Commands.Add(new Command
{
Count = newStats.Commands.CreateSidecar, Name = "create-sidecar"
@@ -93,127 +93,127 @@ namespace DiscImageChef.Server
else existing.Count += newStats.Commands.CreateSidecar;
}
if(newStats.Commands.Decode > 0)
if (newStats.Commands.Decode > 0)
{
Command existing = ctx.Commands.FirstOrDefault(c => c.Name == "decode");
var existing = ctx.Commands.FirstOrDefault(c => c.Name == "decode");
if(existing == null)
if (existing == null)
ctx.Commands.Add(new Command {Count = newStats.Commands.Decode, Name = "decode"});
else existing.Count += newStats.Commands.Decode;
}
if(newStats.Commands.DeviceInfo > 0)
if (newStats.Commands.DeviceInfo > 0)
{
Command existing = ctx.Commands.FirstOrDefault(c => c.Name == "device-info");
var existing = ctx.Commands.FirstOrDefault(c => c.Name == "device-info");
if(existing == null)
if (existing == null)
ctx.Commands.Add(new Command {Count = newStats.Commands.DeviceInfo, Name = "device-info"});
else existing.Count += newStats.Commands.DeviceInfo;
}
if(newStats.Commands.DeviceReport > 0)
if (newStats.Commands.DeviceReport > 0)
{
Command existing = ctx.Commands.FirstOrDefault(c => c.Name == "device-report");
var existing = ctx.Commands.FirstOrDefault(c => c.Name == "device-report");
if(existing == null)
if (existing == null)
ctx.Commands.Add(new Command {Count = newStats.Commands.DeviceReport, Name = "device-report"});
else existing.Count += newStats.Commands.DeviceReport;
}
if(newStats.Commands.DumpMedia > 0)
if (newStats.Commands.DumpMedia > 0)
{
Command existing = ctx.Commands.FirstOrDefault(c => c.Name == "dump-media");
var existing = ctx.Commands.FirstOrDefault(c => c.Name == "dump-media");
if(existing == null)
if (existing == null)
ctx.Commands.Add(new Command {Count = newStats.Commands.DumpMedia, Name = "dump-media"});
else existing.Count += newStats.Commands.DumpMedia;
}
if(newStats.Commands.Entropy > 0)
if (newStats.Commands.Entropy > 0)
{
Command existing = ctx.Commands.FirstOrDefault(c => c.Name == "entropy");
var existing = ctx.Commands.FirstOrDefault(c => c.Name == "entropy");
if(existing == null)
if (existing == null)
ctx.Commands.Add(new Command {Count = newStats.Commands.Entropy, Name = "entropy"});
else existing.Count += newStats.Commands.Entropy;
}
if(newStats.Commands.Formats > 0)
if (newStats.Commands.Formats > 0)
{
Command existing = ctx.Commands.FirstOrDefault(c => c.Name == "formats");
var existing = ctx.Commands.FirstOrDefault(c => c.Name == "formats");
if(existing == null)
if (existing == null)
ctx.Commands.Add(new Command {Count = newStats.Commands.Formats, Name = "formats"});
else existing.Count += newStats.Commands.Formats;
}
if(newStats.Commands.MediaInfo > 0)
if (newStats.Commands.MediaInfo > 0)
{
Command existing = ctx.Commands.FirstOrDefault(c => c.Name == "media-info");
var existing = ctx.Commands.FirstOrDefault(c => c.Name == "media-info");
if(existing == null)
if (existing == null)
ctx.Commands.Add(new Command {Count = newStats.Commands.MediaInfo, Name = "media-info"});
else existing.Count += newStats.Commands.MediaInfo;
}
if(newStats.Commands.MediaScan > 0)
if (newStats.Commands.MediaScan > 0)
{
Command existing = ctx.Commands.FirstOrDefault(c => c.Name == "media-scan");
var existing = ctx.Commands.FirstOrDefault(c => c.Name == "media-scan");
if(existing == null)
if (existing == null)
ctx.Commands.Add(new Command {Count = newStats.Commands.MediaScan, Name = "media-scan"});
else existing.Count += newStats.Commands.MediaScan;
}
if(newStats.Commands.PrintHex > 0)
if (newStats.Commands.PrintHex > 0)
{
Command existing = ctx.Commands.FirstOrDefault(c => c.Name == "printhex");
var existing = ctx.Commands.FirstOrDefault(c => c.Name == "printhex");
if(existing == null)
if (existing == null)
ctx.Commands.Add(new Command {Count = newStats.Commands.PrintHex, Name = "printhex"});
else existing.Count += newStats.Commands.PrintHex;
}
if(newStats.Commands.Verify > 0)
if (newStats.Commands.Verify > 0)
{
Command existing = ctx.Commands.FirstOrDefault(c => c.Name == "verify");
var existing = ctx.Commands.FirstOrDefault(c => c.Name == "verify");
if(existing == null)
if (existing == null)
ctx.Commands.Add(new Command {Count = newStats.Commands.Verify, Name = "verify"});
else existing.Count += newStats.Commands.Verify;
}
if(newStats.Commands.Ls > 0)
if (newStats.Commands.Ls > 0)
{
Command existing = ctx.Commands.FirstOrDefault(c => c.Name == "ls");
var existing = ctx.Commands.FirstOrDefault(c => c.Name == "ls");
if(existing == null) ctx.Commands.Add(new Command {Count = newStats.Commands.Ls, Name = "ls"});
if (existing == null) ctx.Commands.Add(new Command {Count = newStats.Commands.Ls, Name = "ls"});
else existing.Count += newStats.Commands.Ls;
}
if(newStats.Commands.ExtractFiles > 0)
if (newStats.Commands.ExtractFiles > 0)
{
Command existing = ctx.Commands.FirstOrDefault(c => c.Name == "extract-files");
var existing = ctx.Commands.FirstOrDefault(c => c.Name == "extract-files");
if(existing == null)
if (existing == null)
ctx.Commands.Add(new Command {Count = newStats.Commands.ExtractFiles, Name = "extract-files"});
else existing.Count += newStats.Commands.ExtractFiles;
}
if(newStats.Commands.ListDevices > 0)
if (newStats.Commands.ListDevices > 0)
{
Command existing = ctx.Commands.FirstOrDefault(c => c.Name == "list-devices");
var existing = ctx.Commands.FirstOrDefault(c => c.Name == "list-devices");
if(existing == null)
if (existing == null)
ctx.Commands.Add(new Command {Count = newStats.Commands.ListDevices, Name = "list-devices"});
else existing.Count += newStats.Commands.ListDevices;
}
if(newStats.Commands.ListEncodings > 0)
if (newStats.Commands.ListEncodings > 0)
{
Command existing = ctx.Commands.FirstOrDefault(c => c.Name == "list-encodings");
var existing = ctx.Commands.FirstOrDefault(c => c.Name == "list-encodings");
if(existing == null)
if (existing == null)
ctx.Commands.Add(new Command
{
Count = newStats.Commands.ListEncodings, Name = "list-encodings"
@@ -221,139 +221,143 @@ namespace DiscImageChef.Server
else existing.Count += newStats.Commands.ListEncodings;
}
if(newStats.Commands.ConvertImage > 0)
if (newStats.Commands.ConvertImage > 0)
{
Command existing = ctx.Commands.FirstOrDefault(c => c.Name == "convert-image");
var existing = ctx.Commands.FirstOrDefault(c => c.Name == "convert-image");
if(existing == null)
if (existing == null)
ctx.Commands.Add(new Command {Count = newStats.Commands.ConvertImage, Name = "convert-image"});
else existing.Count += newStats.Commands.ConvertImage;
}
if(newStats.Commands.ImageInfo > 0)
if (newStats.Commands.ImageInfo > 0)
{
Command existing = ctx.Commands.FirstOrDefault(c => c.Name == "image-info");
var existing = ctx.Commands.FirstOrDefault(c => c.Name == "image-info");
if(existing == null)
if (existing == null)
ctx.Commands.Add(new Command {Count = newStats.Commands.ImageInfo, Name = "image-info"});
else existing.Count += newStats.Commands.ImageInfo;
}
}
if(newStats.OperatingSystems != null)
foreach(OsStats operatingSystem in newStats.OperatingSystems)
if (newStats.OperatingSystems != null)
{
foreach (var operatingSystem in newStats.OperatingSystems)
{
if(string.IsNullOrWhiteSpace(operatingSystem.name) ||
string.IsNullOrWhiteSpace(operatingSystem.version)) continue;
if (string.IsNullOrWhiteSpace(operatingSystem.name) ||
string.IsNullOrWhiteSpace(operatingSystem.version)) continue;
OperatingSystem existing =
ctx.OperatingSystems.FirstOrDefault(c => c.Name == operatingSystem.name &&
var existing =
ctx.OperatingSystems.FirstOrDefault(c => c.Name == operatingSystem.name &&
c.Version == operatingSystem.version);
if(existing == null)
if (existing == null)
ctx.OperatingSystems.Add(new OperatingSystem
{
Count = operatingSystem.Value,
Name = operatingSystem.name,
Count = operatingSystem.Value,
Name = operatingSystem.name,
Version = operatingSystem.version
});
else existing.Count += operatingSystem.Value;
}
}
else
{
OperatingSystem existing =
var existing =
ctx.OperatingSystems.FirstOrDefault(c => c.Name == "Linux" && c.Version == null);
if(existing == null) ctx.OperatingSystems.Add(new OperatingSystem {Count = 1, Name = "Linux"});
if (existing == null) ctx.OperatingSystems.Add(new OperatingSystem {Count = 1, Name = "Linux"});
else existing.Count++;
}
if(newStats.Versions != null)
foreach(NameValueStats nvs in newStats.Versions)
if (newStats.Versions != null)
{
foreach (var nvs in newStats.Versions)
{
if(string.IsNullOrWhiteSpace(nvs.name)) continue;
if (string.IsNullOrWhiteSpace(nvs.name)) continue;
Version existing = ctx.Versions.FirstOrDefault(c => c.Value == nvs.name);
var existing = ctx.Versions.FirstOrDefault(c => c.Value == nvs.name);
if(existing == null) ctx.Versions.Add(new Version {Count = nvs.Value, Value = nvs.name});
if (existing == null) ctx.Versions.Add(new Version {Count = nvs.Value, Value = nvs.name});
else existing.Count += nvs.Value;
}
}
else
{
Version existing = ctx.Versions.FirstOrDefault(c => c.Value == "previous");
var existing = ctx.Versions.FirstOrDefault(c => c.Value == "previous");
if(existing == null) ctx.Versions.Add(new Version {Count = 1, Value = "previous"});
if (existing == null) ctx.Versions.Add(new Version {Count = 1, Value = "previous"});
else existing.Count++;
}
if(newStats.Filesystems != null)
foreach(NameValueStats nvs in newStats.Filesystems)
if (newStats.Filesystems != null)
foreach (var nvs in newStats.Filesystems)
{
if(string.IsNullOrWhiteSpace(nvs.name)) continue;
if (string.IsNullOrWhiteSpace(nvs.name)) continue;
Filesystem existing = ctx.Filesystems.FirstOrDefault(c => c.Name == nvs.name);
var existing = ctx.Filesystems.FirstOrDefault(c => c.Name == nvs.name);
if(existing == null) ctx.Filesystems.Add(new Filesystem {Count = nvs.Value, Name = nvs.name});
if (existing == null) ctx.Filesystems.Add(new Filesystem {Count = nvs.Value, Name = nvs.name});
else existing.Count += nvs.Value;
}
if(newStats.Partitions != null)
foreach(NameValueStats nvs in newStats.Partitions)
if (newStats.Partitions != null)
foreach (var nvs in newStats.Partitions)
{
if(string.IsNullOrWhiteSpace(nvs.name)) continue;
if (string.IsNullOrWhiteSpace(nvs.name)) continue;
Partition existing = ctx.Partitions.FirstOrDefault(c => c.Name == nvs.name);
var existing = ctx.Partitions.FirstOrDefault(c => c.Name == nvs.name);
if(existing == null) ctx.Partitions.Add(new Partition {Count = nvs.Value, Name = nvs.name});
if (existing == null) ctx.Partitions.Add(new Partition {Count = nvs.Value, Name = nvs.name});
else existing.Count += nvs.Value;
}
if(newStats.MediaImages != null)
foreach(NameValueStats nvs in newStats.MediaImages)
if (newStats.MediaImages != null)
foreach (var nvs in newStats.MediaImages)
{
if(string.IsNullOrWhiteSpace(nvs.name)) continue;
if (string.IsNullOrWhiteSpace(nvs.name)) continue;
MediaFormat existing = ctx.MediaFormats.FirstOrDefault(c => c.Name == nvs.name);
var existing = ctx.MediaFormats.FirstOrDefault(c => c.Name == nvs.name);
if(existing == null) ctx.MediaFormats.Add(new MediaFormat {Count = nvs.Value, Name = nvs.name});
if (existing == null) ctx.MediaFormats.Add(new MediaFormat {Count = nvs.Value, Name = nvs.name});
else existing.Count += nvs.Value;
}
if(newStats.Filters != null)
foreach(NameValueStats nvs in newStats.Filters)
if (newStats.Filters != null)
foreach (var nvs in newStats.Filters)
{
if(string.IsNullOrWhiteSpace(nvs.name)) continue;
if (string.IsNullOrWhiteSpace(nvs.name)) continue;
Filter existing = ctx.Filters.FirstOrDefault(c => c.Name == nvs.name);
var existing = ctx.Filters.FirstOrDefault(c => c.Name == nvs.name);
if(existing == null) ctx.Filters.Add(new Filter {Count = nvs.Value, Name = nvs.name});
if (existing == null) ctx.Filters.Add(new Filter {Count = nvs.Value, Name = nvs.name});
else existing.Count += nvs.Value;
}
if(newStats.Devices != null)
foreach(DeviceStats device in newStats.Devices)
if (newStats.Devices != null)
foreach (var device in newStats.Devices)
{
if(string.IsNullOrWhiteSpace(device.Model)) continue;
if (string.IsNullOrWhiteSpace(device.Model)) continue;
if(!ctx.DeviceStats.Any(c => c.Bus == device.Bus && c.Manufacturer == device.Manufacturer &&
c.Model == device.Model && c.Revision == device.Revision))
if (!ctx.DeviceStats.Any(c => c.Bus == device.Bus && c.Manufacturer == device.Manufacturer &&
c.Model == device.Model && c.Revision == device.Revision))
ctx.DeviceStats.Add(new DeviceStat
{
Bus = device.Bus,
Bus = device.Bus,
Manufacturer = device.Manufacturer,
Model = device.Model,
Revision = device.Revision
Model = device.Model,
Revision = device.Revision
});
}
if(newStats.Medias != null)
foreach(MediaStats media in newStats.Medias)
if (newStats.Medias != null)
foreach (var media in newStats.Medias)
{
if(string.IsNullOrWhiteSpace(media.type)) continue;
if (string.IsNullOrWhiteSpace(media.type)) continue;
Media existing = ctx.Medias.FirstOrDefault(c => c.Type == media.type && c.Real == media.real);
var existing = ctx.Medias.FirstOrDefault(c => c.Type == media.type && c.Real == media.real);
if(existing == null)
if (existing == null)
ctx.Medias.Add(new Media {Count = media.Value, Real = media.real, Type = media.type});
else existing.Count += media.Value;
}

265
DiscImageChef.Server/App_Start/TestedMedia.cs
View File

@@ -44,259 +44,282 @@ namespace DiscImageChef.Server.App_Start
/// <param name="testedMedias">List of tested media</param>
public static void Report(List<CommonTypes.Metadata.TestedMedia> testedMedias, ref List<string> mediaOneValue)
{
foreach(CommonTypes.Metadata.TestedMedia testedMedia in testedMedias)
foreach (var testedMedia in testedMedias)
{
if(!string.IsNullOrWhiteSpace(testedMedia.MediumTypeName))
if (!string.IsNullOrWhiteSpace(testedMedia.MediumTypeName))
{
mediaOneValue.Add($"<i>Information for medium named \"{testedMedia.MediumTypeName}\"</i>");
if(testedMedia.MediumType != null)
if (testedMedia.MediumType != null)
mediaOneValue.Add($"Medium type code: {testedMedia.MediumType:X2}h");
}
else if(testedMedia.MediumType != null)
else if (testedMedia.MediumType != null)
{
mediaOneValue.Add($"<i>Information for medium type {testedMedia.MediumType:X2}h</i>");
else mediaOneValue.Add("<i>Information for unknown medium type</i>");
}
else
{
mediaOneValue.Add("<i>Information for unknown medium type</i>");
}
mediaOneValue.Add(testedMedia.MediaIsRecognized
? "Drive recognizes this medium."
: "Drive does not recognize this medium.");
? "Drive recognizes this medium."
: "Drive does not recognize this medium.");
if(!string.IsNullOrWhiteSpace(testedMedia.Manufacturer))
if (!string.IsNullOrWhiteSpace(testedMedia.Manufacturer))
mediaOneValue.Add($"Medium manufactured by: {testedMedia.Manufacturer}");
if(!string.IsNullOrWhiteSpace(testedMedia.Model))
if (!string.IsNullOrWhiteSpace(testedMedia.Model))
mediaOneValue.Add($"Medium model: {testedMedia.Model}");
if(testedMedia.Density != null) mediaOneValue.Add($"Density code: {testedMedia.Density:X2}h");
if (testedMedia.Density != null) mediaOneValue.Add($"Density code: {testedMedia.Density:X2}h");
if(testedMedia.BlockSize != null)
if (testedMedia.BlockSize != null)
mediaOneValue.Add($"Logical sector size: {testedMedia.BlockSize} bytes");
if(testedMedia.PhysicalBlockSize != null)
if (testedMedia.PhysicalBlockSize != null)
mediaOneValue.Add($"Physical sector size: {testedMedia.PhysicalBlockSize} bytes");
if(testedMedia.LongBlockSize != null)
if (testedMedia.LongBlockSize != null)
mediaOneValue.Add($"READ LONG sector size: {testedMedia.LongBlockSize} bytes");
if(testedMedia.Blocks != null && testedMedia.BlockSize != null)
if (testedMedia.Blocks != null && testedMedia.BlockSize != null)
{
mediaOneValue.Add($"Medium has {testedMedia.Blocks} blocks of {testedMedia.BlockSize} bytes each");
if(testedMedia.Blocks * testedMedia.BlockSize / 1024 / 1024 > 1000000)
if (testedMedia.Blocks * testedMedia.BlockSize / 1024 / 1024 > 1000000)
mediaOneValue
.Add($"Medium size: {testedMedia.Blocks * testedMedia.BlockSize} bytes, {testedMedia.Blocks * testedMedia.BlockSize / 1000 / 1000 / 1000 / 1000} Tb, {(double)(testedMedia.Blocks * testedMedia.BlockSize) / 1024 / 1024 / 1024 / 1024:F2} TiB");
else if(testedMedia.Blocks * testedMedia.BlockSize / 1024 / 1024 > 1000)
.Add(
$"Medium size: {testedMedia.Blocks * testedMedia.BlockSize} bytes, {testedMedia.Blocks * testedMedia.BlockSize / 1000 / 1000 / 1000 / 1000} Tb, {(double) (testedMedia.Blocks * testedMedia.BlockSize) / 1024 / 1024 / 1024 / 1024:F2} TiB");
else if (testedMedia.Blocks * testedMedia.BlockSize / 1024 / 1024 > 1000)
mediaOneValue
.Add($"Medium size: {testedMedia.Blocks * testedMedia.BlockSize} bytes, {testedMedia.Blocks * testedMedia.BlockSize / 1000 / 1000 / 1000} Gb, {(double)(testedMedia.Blocks * testedMedia.BlockSize) / 1024 / 1024 / 1024:F2} GiB");
.Add(
$"Medium size: {testedMedia.Blocks * testedMedia.BlockSize} bytes, {testedMedia.Blocks * testedMedia.BlockSize / 1000 / 1000 / 1000} Gb, {(double) (testedMedia.Blocks * testedMedia.BlockSize) / 1024 / 1024 / 1024:F2} GiB");
else
mediaOneValue
.Add($"Medium size: {testedMedia.Blocks * testedMedia.BlockSize} bytes, {testedMedia.Blocks * testedMedia.BlockSize / 1000 / 1000} Mb, {(double)(testedMedia.Blocks * testedMedia.BlockSize) / 1024 / 1024:F2} MiB");
.Add(
$"Medium size: {testedMedia.Blocks * testedMedia.BlockSize} bytes, {testedMedia.Blocks * testedMedia.BlockSize / 1000 / 1000} Mb, {(double) (testedMedia.Blocks * testedMedia.BlockSize) / 1024 / 1024:F2} MiB");
}
if(testedMedia.CHS != null && testedMedia.CurrentCHS != null)
if (testedMedia.CHS != null && testedMedia.CurrentCHS != null)
{
int currentSectors = testedMedia.CurrentCHS.Cylinders * testedMedia.CurrentCHS.Heads *
var currentSectors = testedMedia.CurrentCHS.Cylinders * testedMedia.CurrentCHS.Heads *
testedMedia.CurrentCHS.Sectors;
mediaOneValue
.Add($"Cylinders: {testedMedia.CHS.Cylinders} max., {testedMedia.CurrentCHS.Cylinders} current");
.Add(
$"Cylinders: {testedMedia.CHS.Cylinders} max., {testedMedia.CurrentCHS.Cylinders} current");
mediaOneValue.Add($"Heads: {testedMedia.CHS.Heads} max., {testedMedia.CurrentCHS.Heads} current");
mediaOneValue
.Add($"Sectors per track: {testedMedia.CHS.Sectors} max., {testedMedia.CurrentCHS.Sectors} current");
.Add(
$"Sectors per track: {testedMedia.CHS.Sectors} max., {testedMedia.CurrentCHS.Sectors} current");
mediaOneValue
.Add($"Sectors addressable in CHS mode: {testedMedia.CHS.Cylinders * testedMedia.CHS.Heads * testedMedia.CHS.Sectors} max., {currentSectors} current");
.Add(
$"Sectors addressable in CHS mode: {testedMedia.CHS.Cylinders * testedMedia.CHS.Heads * testedMedia.CHS.Sectors} max., {currentSectors} current");
mediaOneValue
.Add($"Medium size in CHS mode: {(ulong)currentSectors * testedMedia.BlockSize} bytes, {(ulong)currentSectors * testedMedia.BlockSize / 1000 / 1000} Mb, {(double)((ulong)currentSectors * testedMedia.BlockSize) / 1024 / 1024:F2} MiB");
.Add(
$"Medium size in CHS mode: {(ulong) currentSectors * testedMedia.BlockSize} bytes, {(ulong) currentSectors * testedMedia.BlockSize / 1000 / 1000} Mb, {(double) ((ulong) currentSectors * testedMedia.BlockSize) / 1024 / 1024:F2} MiB");
}
else if(testedMedia.CHS != null)
else if (testedMedia.CHS != null)
{
int currentSectors = testedMedia.CHS.Cylinders * testedMedia.CHS.Heads * testedMedia.CHS.Sectors;
var currentSectors = testedMedia.CHS.Cylinders * testedMedia.CHS.Heads * testedMedia.CHS.Sectors;
mediaOneValue.Add($"Cylinders: {testedMedia.CHS.Cylinders}");
mediaOneValue.Add($"Heads: {testedMedia.CHS.Heads}");
mediaOneValue.Add($"Sectors per track: {testedMedia.CHS.Sectors}");
mediaOneValue.Add($"Sectors addressable in CHS mode: {currentSectors}");
mediaOneValue
.Add($"Medium size in CHS mode: {(ulong)currentSectors * testedMedia.BlockSize} bytes, {(ulong)currentSectors * testedMedia.BlockSize / 1000 / 1000} Mb, {(double)((ulong)currentSectors * testedMedia.BlockSize) / 1024 / 1024:F2} MiB");
.Add(
$"Medium size in CHS mode: {(ulong) currentSectors * testedMedia.BlockSize} bytes, {(ulong) currentSectors * testedMedia.BlockSize / 1000 / 1000} Mb, {(double) ((ulong) currentSectors * testedMedia.BlockSize) / 1024 / 1024:F2} MiB");
}
if(testedMedia.LBASectors != null)
if (testedMedia.LBASectors != null)
{
mediaOneValue.Add($"Sectors addressable in sectors in 28-bit LBA mode: {testedMedia.LBASectors}");
if((ulong)testedMedia.LBASectors * testedMedia.BlockSize / 1024 / 1024 > 1000000)
if ((ulong) testedMedia.LBASectors * testedMedia.BlockSize / 1024 / 1024 > 1000000)
mediaOneValue
.Add($"Medium size in 28-bit LBA mode: {(ulong)testedMedia.LBASectors * testedMedia.BlockSize} bytes, {(ulong)testedMedia.LBASectors * testedMedia.BlockSize / 1000 / 1000 / 1000 / 1000} Tb, {(double)((ulong)testedMedia.LBASectors * testedMedia.BlockSize) / 1024 / 1024 / 1024 / 1024:F2} TiB");
else if((ulong)testedMedia.LBASectors * testedMedia.BlockSize / 1024 / 1024 > 1000)
.Add(
$"Medium size in 28-bit LBA mode: {(ulong) testedMedia.LBASectors * testedMedia.BlockSize} bytes, {(ulong) testedMedia.LBASectors * testedMedia.BlockSize / 1000 / 1000 / 1000 / 1000} Tb, {(double) ((ulong) testedMedia.LBASectors * testedMedia.BlockSize) / 1024 / 1024 / 1024 / 1024:F2} TiB");
else if ((ulong) testedMedia.LBASectors * testedMedia.BlockSize / 1024 / 1024 > 1000)
mediaOneValue
.Add($"Medium size in 28-bit LBA mode: {(ulong)testedMedia.LBASectors * testedMedia.BlockSize} bytes, {(ulong)testedMedia.LBASectors * testedMedia.BlockSize / 1000 / 1000 / 1000} Gb, {(double)((ulong)testedMedia.LBASectors * testedMedia.BlockSize) / 1024 / 1024 / 1024:F2} GiB");
.Add(
$"Medium size in 28-bit LBA mode: {(ulong) testedMedia.LBASectors * testedMedia.BlockSize} bytes, {(ulong) testedMedia.LBASectors * testedMedia.BlockSize / 1000 / 1000 / 1000} Gb, {(double) ((ulong) testedMedia.LBASectors * testedMedia.BlockSize) / 1024 / 1024 / 1024:F2} GiB");
else
mediaOneValue
.Add($"Medium size in 28-bit LBA mode: {(ulong)testedMedia.LBASectors * testedMedia.BlockSize} bytes, {(ulong)testedMedia.LBASectors * testedMedia.BlockSize / 1000 / 1000} Mb, {(double)((ulong)testedMedia.LBASectors * testedMedia.BlockSize) / 1024 / 1024:F2} MiB");
.Add(
$"Medium size in 28-bit LBA mode: {(ulong) testedMedia.LBASectors * testedMedia.BlockSize} bytes, {(ulong) testedMedia.LBASectors * testedMedia.BlockSize / 1000 / 1000} Mb, {(double) ((ulong) testedMedia.LBASectors * testedMedia.BlockSize) / 1024 / 1024:F2} MiB");
}
if(testedMedia.LBA48Sectors != null)
if (testedMedia.LBA48Sectors != null)
{
mediaOneValue.Add($"Sectors addressable in sectors in 48-bit LBA mode: {testedMedia.LBA48Sectors}");
if(testedMedia.LBA48Sectors * testedMedia.BlockSize / 1024 / 1024 > 1000000)
if (testedMedia.LBA48Sectors * testedMedia.BlockSize / 1024 / 1024 > 1000000)
mediaOneValue
.Add($"Medium size in 48-bit LBA mode: {testedMedia.LBA48Sectors * testedMedia.BlockSize} bytes, {testedMedia.LBA48Sectors * testedMedia.BlockSize / 1000 / 1000 / 1000 / 1000} Tb, {(double)(testedMedia.LBA48Sectors * testedMedia.BlockSize) / 1024 / 1024 / 1024 / 1024:F2} TiB");
else if(testedMedia.LBA48Sectors * testedMedia.BlockSize / 1024 / 1024 > 1000)
.Add(
$"Medium size in 48-bit LBA mode: {testedMedia.LBA48Sectors * testedMedia.BlockSize} bytes, {testedMedia.LBA48Sectors * testedMedia.BlockSize / 1000 / 1000 / 1000 / 1000} Tb, {(double) (testedMedia.LBA48Sectors * testedMedia.BlockSize) / 1024 / 1024 / 1024 / 1024:F2} TiB");
else if (testedMedia.LBA48Sectors * testedMedia.BlockSize / 1024 / 1024 > 1000)
mediaOneValue
.Add($"Medium size in 48-bit LBA mode: {testedMedia.LBA48Sectors * testedMedia.BlockSize} bytes, {testedMedia.LBA48Sectors * testedMedia.BlockSize / 1000 / 1000 / 1000} Gb, {(double)(testedMedia.LBA48Sectors * testedMedia.BlockSize) / 1024 / 1024 / 1024:F2} GiB");
.Add(
$"Medium size in 48-bit LBA mode: {testedMedia.LBA48Sectors * testedMedia.BlockSize} bytes, {testedMedia.LBA48Sectors * testedMedia.BlockSize / 1000 / 1000 / 1000} Gb, {(double) (testedMedia.LBA48Sectors * testedMedia.BlockSize) / 1024 / 1024 / 1024:F2} GiB");
else
mediaOneValue
.Add($"Medium size in 48-bit LBA mode: {testedMedia.LBA48Sectors * testedMedia.BlockSize} bytes, {testedMedia.LBA48Sectors * testedMedia.BlockSize / 1000 / 1000} Mb, {(double)(testedMedia.LBA48Sectors * testedMedia.BlockSize) / 1024 / 1024:F2} MiB");
.Add(
$"Medium size in 48-bit LBA mode: {testedMedia.LBA48Sectors * testedMedia.BlockSize} bytes, {testedMedia.LBA48Sectors * testedMedia.BlockSize / 1000 / 1000} Mb, {(double) (testedMedia.LBA48Sectors * testedMedia.BlockSize) / 1024 / 1024:F2} MiB");
}
if(testedMedia.NominalRotationRate != null && testedMedia.NominalRotationRate != 0x0000 &&
testedMedia.NominalRotationRate != 0xFFFF)
if (testedMedia.NominalRotationRate != null && testedMedia.NominalRotationRate != 0x0000 &&
testedMedia.NominalRotationRate != 0xFFFF)
mediaOneValue.Add(testedMedia.NominalRotationRate == 0x0001
? "Medium does not rotate."
: $"Medium rotates at {testedMedia.NominalRotationRate} rpm");
? "Medium does not rotate."
: $"Medium rotates at {testedMedia.NominalRotationRate} rpm");
if(testedMedia.BlockSize != null &&
testedMedia.PhysicalBlockSize != null &&
testedMedia.BlockSize.Value != testedMedia.PhysicalBlockSize.Value &&
(testedMedia.LogicalAlignment & 0x8000) == 0x0000 &&
(testedMedia.LogicalAlignment & 0x4000) == 0x4000)
if (testedMedia.BlockSize != null &&
testedMedia.PhysicalBlockSize != null &&
testedMedia.BlockSize.Value != testedMedia.PhysicalBlockSize.Value &&
(testedMedia.LogicalAlignment & 0x8000) == 0x0000 &&
(testedMedia.LogicalAlignment & 0x4000) == 0x4000)
mediaOneValue
.Add($"Logical sector starts at offset {testedMedia.LogicalAlignment & 0x3FFF} from physical sector");
.Add(
$"Logical sector starts at offset {testedMedia.LogicalAlignment & 0x3FFF} from physical sector");
if(testedMedia.SupportsReadSectors == true)
if (testedMedia.SupportsReadSectors == true)
mediaOneValue.Add("Device can use the READ SECTOR(S) command in CHS mode with this medium");
if(testedMedia.SupportsReadRetry == true)
if (testedMedia.SupportsReadRetry == true)
mediaOneValue.Add("Device can use the READ SECTOR(S) RETRY command in CHS mode with this medium");
if(testedMedia.SupportsReadDma == true)
if (testedMedia.SupportsReadDma == true)
mediaOneValue.Add("Device can use the READ DMA command in CHS mode with this medium");
if(testedMedia.SupportsReadDmaRetry == true)
if (testedMedia.SupportsReadDmaRetry == true)
mediaOneValue.Add("Device can use the READ DMA RETRY command in CHS mode with this medium");
if(testedMedia.SupportsReadLong == true)
if (testedMedia.SupportsReadLong == true)
mediaOneValue.Add("Device can use the READ LONG command in CHS mode with this medium");
if(testedMedia.SupportsReadLongRetry == true)
if (testedMedia.SupportsReadLongRetry == true)
mediaOneValue.Add("Device can use the READ LONG RETRY command in CHS mode with this medium");
if(testedMedia.SupportsReadLba == true)
if (testedMedia.SupportsReadLba == true)
mediaOneValue.Add("Device can use the READ SECTOR(S) command in 28-bit LBA mode with this medium");
if(testedMedia.SupportsReadRetryLba == true)
if (testedMedia.SupportsReadRetryLba == true)
mediaOneValue
.Add("Device can use the READ SECTOR(S) RETRY command in 28-bit LBA mode with this medium");
if(testedMedia.SupportsReadDmaLba == true)
.Add("Device can use the READ SECTOR(S) RETRY command in 28-bit LBA mode with this medium");
if (testedMedia.SupportsReadDmaLba == true)
mediaOneValue.Add("Device can use the READ DMA command in 28-bit LBA mode with this medium");
if(testedMedia.SupportsReadDmaRetryLba == true)
if (testedMedia.SupportsReadDmaRetryLba == true)
mediaOneValue.Add("Device can use the READ DMA RETRY command in 28-bit LBA mode with this medium");
if(testedMedia.SupportsReadLongLba == true)
if (testedMedia.SupportsReadLongLba == true)
mediaOneValue.Add("Device can use the READ LONG command in 28-bit LBA mode with this medium");
if(testedMedia.SupportsReadLongRetryLba == true)
if (testedMedia.SupportsReadLongRetryLba == true)
mediaOneValue.Add("Device can use the READ LONG RETRY command in 28-bit LBA mode with this medium");
if(testedMedia.SupportsReadLba48 == true)
if (testedMedia.SupportsReadLba48 == true)
mediaOneValue.Add("Device can use the READ SECTOR(S) command in 48-bit LBA mode with this medium");
if(testedMedia.SupportsReadDmaLba48 == true)
if (testedMedia.SupportsReadDmaLba48 == true)
mediaOneValue.Add("Device can use the READ DMA command in 48-bit LBA mode with this medium");
if(testedMedia.SupportsSeek == true)
if (testedMedia.SupportsSeek == true)
mediaOneValue.Add("Device can use the SEEK command in CHS mode with this medium");
if(testedMedia.SupportsSeekLba == true)
if (testedMedia.SupportsSeekLba == true)
mediaOneValue.Add("Device can use the SEEK command in 28-bit LBA mode with this medium");
if(testedMedia.SupportsReadCapacity == true)
if (testedMedia.SupportsReadCapacity == true)
mediaOneValue.Add("Device can use the READ CAPACITY (10) command with this medium");
if(testedMedia.SupportsReadCapacity16 == true)
if (testedMedia.SupportsReadCapacity16 == true)
mediaOneValue.Add("Device can use the READ CAPACITY (16) command with this medium");
if(testedMedia.SupportsRead6 == true)
if (testedMedia.SupportsRead6 == true)
mediaOneValue.Add("Device can use the READ (6) command with this medium");
if(testedMedia.SupportsRead10 == true)
if (testedMedia.SupportsRead10 == true)
mediaOneValue.Add("Device can use the READ (10) command with this medium");
if(testedMedia.SupportsRead12 == true)
if (testedMedia.SupportsRead12 == true)
mediaOneValue.Add("Device can use the READ (12) command with this medium");
if(testedMedia.SupportsRead16 == true)
if (testedMedia.SupportsRead16 == true)
mediaOneValue.Add("Device can use the READ (16) command with this medium");
if(testedMedia.SupportsReadLong == true)
if (testedMedia.SupportsReadLong == true)
mediaOneValue.Add("Device can use the READ LONG (10) command with this medium");
if(testedMedia.SupportsReadLong16 == true)
if (testedMedia.SupportsReadLong16 == true)
mediaOneValue.Add("Device can use the READ LONG (16) command with this medium");
if(testedMedia.SupportsReadCd == true)
if (testedMedia.SupportsReadCd == true)
mediaOneValue.Add("Device can use the READ CD command with LBA addressing with this medium");
if(testedMedia.SupportsReadCdMsf == true)
if (testedMedia.SupportsReadCdMsf == true)
mediaOneValue.Add("Device can use the READ CD command with MM:SS:FF addressing with this medium");
if(testedMedia.SupportsReadCdRaw == true)
if (testedMedia.SupportsReadCdRaw == true)
mediaOneValue
.Add("Device can use the READ CD command with LBA addressing with this medium to read raw sector");
if(testedMedia.SupportsReadCdMsfRaw == true)
.Add(
"Device can use the READ CD command with LBA addressing with this medium to read raw sector");
if (testedMedia.SupportsReadCdMsfRaw == true)
mediaOneValue
.Add("Device can use the READ CD command with MM:SS:FF addressing with this medium read raw sector");
.Add(
"Device can use the READ CD command with MM:SS:FF addressing with this medium read raw sector");
if(testedMedia.SupportsHLDTSTReadRawDVD == true)
if (testedMedia.SupportsHLDTSTReadRawDVD == true)
mediaOneValue.Add("Device can use the HL-DT-ST vendor READ DVD (RAW) command with this medium");
if(testedMedia.SupportsNECReadCDDA == true)
if (testedMedia.SupportsNECReadCDDA == true)
mediaOneValue.Add("Device can use the NEC vendor READ CD-DA command with this medium");
if(testedMedia.SupportsPioneerReadCDDA == true)
if (testedMedia.SupportsPioneerReadCDDA == true)
mediaOneValue.Add("Device can use the PIONEER vendor READ CD-DA command with this medium");
if(testedMedia.SupportsPioneerReadCDDAMSF == true)
if (testedMedia.SupportsPioneerReadCDDAMSF == true)
mediaOneValue.Add("Device can use the PIONEER vendor READ CD-DA MSF command with this medium");
if(testedMedia.SupportsPlextorReadCDDA == true)
if (testedMedia.SupportsPlextorReadCDDA == true)
mediaOneValue.Add("Device can use the PLEXTOR vendor READ CD-DA command with this medium");
if(testedMedia.SupportsPlextorReadRawDVD == true)
if (testedMedia.SupportsPlextorReadRawDVD == true)
mediaOneValue.Add("Device can use the PLEXOR vendor READ DVD (RAW) command with this medium");
if(testedMedia.CanReadAACS == true)
if (testedMedia.CanReadAACS == true)
mediaOneValue.Add("Device can read the Advanced Access Content System from this medium");
if(testedMedia.CanReadADIP == true)
if (testedMedia.CanReadADIP == true)
mediaOneValue.Add("Device can read the DVD ADress-In-Pregroove from this medium");
if(testedMedia.CanReadATIP == true)
if (testedMedia.CanReadATIP == true)
mediaOneValue.Add("Device can read the CD Absolute-Time-In-Pregroove from this medium");
if(testedMedia.CanReadBCA == true)
if (testedMedia.CanReadBCA == true)
mediaOneValue.Add("Device can read the Burst Cutting Area from this medium");
if(testedMedia.CanReadC2Pointers == true)
if (testedMedia.CanReadC2Pointers == true)
mediaOneValue.Add("Device can report the C2 pointers when reading from this medium");
if(testedMedia.CanReadCMI == true)
if (testedMedia.CanReadCMI == true)
mediaOneValue.Add("Device can read the Copyright Management Information from this medium");
if(testedMedia.CanReadCorrectedSubchannel == true)
if (testedMedia.CanReadCorrectedSubchannel == true)
mediaOneValue.Add("Device can correct subchannels when reading from this medium");
if(testedMedia.CanReadCorrectedSubchannelWithC2 == true)
if (testedMedia.CanReadCorrectedSubchannelWithC2 == true)
mediaOneValue
.Add("Device can correct subchannels and report the C2 pointers when reading from this medium");
if(testedMedia.CanReadDCB == true)
.Add("Device can correct subchannels and report the C2 pointers when reading from this medium");
if (testedMedia.CanReadDCB == true)
mediaOneValue.Add("Device can read the Disc Control Blocks from this medium");
if(testedMedia.CanReadDDS == true)
if (testedMedia.CanReadDDS == true)
mediaOneValue.Add("Device can read the Disc Definition Structure from this medium");
if(testedMedia.CanReadDMI == true)
if (testedMedia.CanReadDMI == true)
mediaOneValue.Add("Device can read the Disc Manufacurer Information from this medium");
if(testedMedia.CanReadDiscInformation == true)
if (testedMedia.CanReadDiscInformation == true)
mediaOneValue.Add("Device can read the Disc Information from this medium");
if(testedMedia.CanReadFullTOC == true)
if (testedMedia.CanReadFullTOC == true)
mediaOneValue.Add("Device can read the Table of Contents from this medium, without processing it");
if(testedMedia.CanReadHDCMI == true)
if (testedMedia.CanReadHDCMI == true)
mediaOneValue.Add("Device can read the HD DVD Copyright Management Information from this medium");
if(testedMedia.CanReadLayerCapacity == true)
if (testedMedia.CanReadLayerCapacity == true)
mediaOneValue.Add("Device can read the layer capacity from this medium");
if(testedMedia.CanReadFirstTrackPreGap == true)
if (testedMedia.CanReadFirstTrackPreGap == true)
mediaOneValue.Add("Device can read the first track's pregap data");
if(testedMedia.CanReadLeadIn == true) mediaOneValue.Add("Device can read the Lead-In from this medium");
if(testedMedia.CanReadLeadOut == true)
if (testedMedia.CanReadLeadIn == true)
mediaOneValue.Add("Device can read the Lead-In from this medium");
if (testedMedia.CanReadLeadOut == true)
mediaOneValue.Add("Device can read the Lead-Out from this medium");
if(testedMedia.CanReadMediaID == true)
if (testedMedia.CanReadMediaID == true)
mediaOneValue.Add("Device can read the Media ID from this medium");
if(testedMedia.CanReadMediaSerial == true)
if (testedMedia.CanReadMediaSerial == true)
mediaOneValue.Add("Device can read the Media Serial Number from this medium");
if(testedMedia.CanReadPAC == true) mediaOneValue.Add("Device can read the PAC from this medium");
if(testedMedia.CanReadPFI == true)
if (testedMedia.CanReadPAC == true) mediaOneValue.Add("Device can read the PAC from this medium");
if (testedMedia.CanReadPFI == true)
mediaOneValue.Add("Device can read the Physical Format Information from this medium");
if(testedMedia.CanReadPMA == true)
if (testedMedia.CanReadPMA == true)
mediaOneValue.Add("Device can read the Power Management Area from this medium");
if(testedMedia.CanReadPQSubchannel == true)
if (testedMedia.CanReadPQSubchannel == true)
mediaOneValue.Add("Device can read the P to Q subchannels from this medium");
if(testedMedia.CanReadPQSubchannelWithC2 == true)
if (testedMedia.CanReadPQSubchannelWithC2 == true)
mediaOneValue
.Add("Device can read the P to Q subchannels from this medium reporting the C2 pointers");
if(testedMedia.CanReadPRI == true)
.Add("Device can read the P to Q subchannels from this medium reporting the C2 pointers");
if (testedMedia.CanReadPRI == true)
mediaOneValue.Add("Device can read the Pre-Recorded Information from this medium");
if(testedMedia.CanReadRWSubchannel == true)
if (testedMedia.CanReadRWSubchannel == true)
mediaOneValue.Add("Device can read the R to W subchannels from this medium");
if(testedMedia.CanReadRWSubchannelWithC2 == true)
if (testedMedia.CanReadRWSubchannelWithC2 == true)
mediaOneValue
.Add("Device can read the R to W subchannels from this medium reporting the C2 pointers");
if(testedMedia.CanReadRecordablePFI == true)
.Add("Device can read the R to W subchannels from this medium reporting the C2 pointers");
if (testedMedia.CanReadRecordablePFI == true)
mediaOneValue.Add("Device can read the Physical Format Information from Lead-In from this medium");
if(testedMedia.CanReadSpareAreaInformation == true)
if (testedMedia.CanReadSpareAreaInformation == true)
mediaOneValue.Add("Device can read the Spare Area Information from this medium");
if(testedMedia.CanReadTOC == true)
if (testedMedia.CanReadTOC == true)
mediaOneValue.Add("Device can read the Table of Contents from this medium");
mediaOneValue.Add("");

50
DiscImageChef.Server/Controllers/HomeController.cs
View File

@@ -41,7 +41,7 @@ namespace DiscImageChef.Server.Controllers
{
public class HomeController : Controller
{
private IWebHostEnvironment _environment;
private readonly IWebHostEnvironment _environment;
public HomeController(IWebHostEnvironment environment)
{
@@ -52,10 +52,10 @@ namespace DiscImageChef.Server.Controllers
[Route("README")]
public ActionResult Index()
{
StreamReader sr =
var sr =
new StreamReader(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"docs", "README.md"));
string mdcontent = sr.ReadToEnd();
"docs", "README.md"));
var mdcontent = sr.ReadToEnd();
sr.Close();
mdcontent = mdcontent.Replace(".md)", ")");
@@ -70,10 +70,10 @@ namespace DiscImageChef.Server.Controllers
[Route("Changelog")]
public ActionResult Changelog()
{
StreamReader sr =
var sr =
new StreamReader(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"docs", "Changelog.md"));
string mdcontent = sr.ReadToEnd();
"docs", "Changelog.md"));
var mdcontent = sr.ReadToEnd();
sr.Close();
mdcontent = mdcontent.Replace(".md)", ")");
@@ -88,10 +88,10 @@ namespace DiscImageChef.Server.Controllers
[Route("CODE_OF_CONDUCT")]
public ActionResult CODE_OF_CONDUCT()
{
StreamReader sr =
var sr =
new StreamReader(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"docs", "CODE_OF_CONDUCT.md"));
string mdcontent = sr.ReadToEnd();
"docs", "CODE_OF_CONDUCT.md"));
var mdcontent = sr.ReadToEnd();
sr.Close();
mdcontent = mdcontent.Replace(".md)", ")").Replace("(.github/", "(");
@@ -106,10 +106,10 @@ namespace DiscImageChef.Server.Controllers
[Route("PULL_REQUEST_TEMPLATE")]
public ActionResult PULL_REQUEST_TEMPLATE()
{
StreamReader sr =
var sr =
new StreamReader(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"docs", "PULL_REQUEST_TEMPLATE.md"));
string mdcontent = sr.ReadToEnd();
"docs", "PULL_REQUEST_TEMPLATE.md"));
var mdcontent = sr.ReadToEnd();
sr.Close();
mdcontent = mdcontent.Replace(".md)", ")").Replace("(.github/", "(");
@@ -124,10 +124,10 @@ namespace DiscImageChef.Server.Controllers
[Route("ISSUE_TEMPLATE")]
public ActionResult ISSUE_TEMPLATE()
{
StreamReader sr =
var sr =
new StreamReader(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"docs", "ISSUE_TEMPLATE.md"));
string mdcontent = sr.ReadToEnd();
"docs", "ISSUE_TEMPLATE.md"));
var mdcontent = sr.ReadToEnd();
sr.Close();
mdcontent = mdcontent.Replace(".md)", ")").Replace("(.github/", "(");
@@ -142,10 +142,10 @@ namespace DiscImageChef.Server.Controllers
[Route("CONTRIBUTING")]
public ActionResult CONTRIBUTING()
{
StreamReader sr =
var sr =
new StreamReader(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"docs", "CONTRIBUTING.md"));
string mdcontent = sr.ReadToEnd();
"docs", "CONTRIBUTING.md"));
var mdcontent = sr.ReadToEnd();
sr.Close();
mdcontent = mdcontent.Replace(".md)", ")").Replace("(.github/", "(");
@@ -160,10 +160,10 @@ namespace DiscImageChef.Server.Controllers
[Route("DONATING")]
public ActionResult DONATING()
{
StreamReader sr =
var sr =
new StreamReader(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"docs", "DONATING.md"));
string mdcontent = sr.ReadToEnd();
"docs", "DONATING.md"));
var mdcontent = sr.ReadToEnd();
sr.Close();
mdcontent = mdcontent.Replace(".md)", ")");
@@ -178,10 +178,10 @@ namespace DiscImageChef.Server.Controllers
[Route("TODO")]
public ActionResult TODO()
{
StreamReader sr =
var sr =
new StreamReader(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"docs", "TODO.md"));
string mdcontent = sr.ReadToEnd();
"docs", "TODO.md"));
var mdcontent = sr.ReadToEnd();
sr.Close();
mdcontent = mdcontent.Replace(".md)", ")");

303
DiscImageChef.Server/Controllers/ReportController.cs
View File

@@ -39,97 +39,99 @@ using DiscImageChef.Decoders.SCSI;
using DiscImageChef.Server.Models;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Routing;
using Tuple = DiscImageChef.Decoders.PCMCIA.Tuple;
namespace DiscImageChef.Server.Controllers
{
public class ReportController : Controller
{
private DicServerContext _ctx;
private readonly DicServerContext _ctx;
public ReportController(DicServerContext context)
{
_ctx = context;
}
public ActionResult Index() => RedirectToAction("View", "Report", new RouteValueDictionary {{"id", 1}});
public ActionResult Index()
{
return RedirectToAction("View", "Report", new RouteValueDictionary {{"id", 1}});
}
public ActionResult View(int? id)
{
if(id == null || id <= 0) return Content("Incorrect device report request");
if (id == null || id <= 0) return Content("Incorrect device report request");
try
{
Device report = _ctx.Devices.FirstOrDefault(d => d.Id == id);
var report = _ctx.Devices.FirstOrDefault(d => d.Id == id);
if(report is null) return Content("Cannot find requested report");
if (report is null) return Content("Cannot find requested report");
ViewBag.lblManufacturer = report.Manufacturer;
ViewBag.lblModel = report.Model;
ViewBag.lblRevision = report.Revision;
ViewBag.lblModel = report.Model;
ViewBag.lblRevision = report.Revision;
if(report.USB != null)
if (report.USB != null)
{
string usbVendorDescription = null;
string usbVendorDescription = null;
string usbProductDescription = null;
UsbProduct dbProduct =
_ctx.UsbProducts.FirstOrDefault(p => p.ProductId == report.USB.ProductID &&
p.Vendor != null &&
p.Vendor.VendorId == report.USB.VendorID);
var dbProduct =
_ctx.UsbProducts.FirstOrDefault(p => p.ProductId == report.USB.ProductID &&
p.Vendor != null &&
p.Vendor.VendorId == report.USB.VendorID);
if(dbProduct is null)
if (dbProduct is null)
{
UsbVendor dbVendor = _ctx.UsbVendors.FirstOrDefault(v => v.VendorId == report.USB.VendorID);
var dbVendor = _ctx.UsbVendors.FirstOrDefault(v => v.VendorId == report.USB.VendorID);
if(!(dbVendor is null)) usbVendorDescription = dbVendor.Vendor;
if (!(dbVendor is null)) usbVendorDescription = dbVendor.Vendor;
}
else
{
usbProductDescription = dbProduct.Product;
usbVendorDescription = dbProduct.Vendor.Vendor;
usbVendorDescription = dbProduct.Vendor.Vendor;
}
ViewBag.UsbItem = new Item
{
Manufacturer = report.USB.Manufacturer,
Product = report.USB.Product,
Product = report.USB.Product,
VendorDescription =
usbVendorDescription != null
? $"0x{report.USB.VendorID:x4} ({usbVendorDescription})"
: $"0x{report.USB.VendorID:x4}",
ProductDescription = usbProductDescription != null
? $"0x{report.USB.ProductID:x4} ({usbProductDescription})"
: $"0x{report.USB.ProductID:x4}"
? $"0x{report.USB.ProductID:x4} ({usbProductDescription})"
: $"0x{report.USB.ProductID:x4}"
};
}
if(report.FireWire != null)
if (report.FireWire != null)
ViewBag.FireWireItem = new Item
{
Manufacturer = report.FireWire.Manufacturer,
Product = report.FireWire.Product,
VendorDescription = $"0x{report.FireWire.VendorID:x8}",
Manufacturer = report.FireWire.Manufacturer,
Product = report.FireWire.Product,
VendorDescription = $"0x{report.FireWire.VendorID:x8}",
ProductDescription = $"0x{report.FireWire.ProductID:x8}"
};
if(report.PCMCIA != null)
if (report.PCMCIA != null)
{
ViewBag.PcmciaItem = new PcmciaItem
{
Manufacturer = report.PCMCIA.Manufacturer,
Product = report.PCMCIA.ProductName,
VendorDescription = $"0x{report.PCMCIA.ManufacturerCode:x4}",
Manufacturer = report.PCMCIA.Manufacturer,
Product = report.PCMCIA.ProductName,
VendorDescription = $"0x{report.PCMCIA.ManufacturerCode:x4}",
ProductDescription = $"0x{report.PCMCIA.CardCode:x4}",
Compliance = report.PCMCIA.Compliance
Compliance = report.PCMCIA.Compliance
};
Tuple[] tuples = CIS.GetTuples(report.PCMCIA.CIS);
if(tuples != null)
var tuples = CIS.GetTuples(report.PCMCIA.CIS);
if (tuples != null)
{
Dictionary<string, string> decodedTuples = new Dictionary<string, string>();
foreach(Tuple tuple in tuples)
switch(tuple.Code)
var decodedTuples = new Dictionary<string, string>();
foreach (var tuple in tuples)
switch (tuple.Code)
{
case TupleCodes.CISTPL_NULL:
case TupleCodes.CISTPL_END:
@@ -137,20 +139,20 @@ namespace DiscImageChef.Server.Controllers
case TupleCodes.CISTPL_VERS_1: break;
case TupleCodes.CISTPL_DEVICEGEO:
case TupleCodes.CISTPL_DEVICEGEO_A:
DeviceGeometryTuple geom = CIS.DecodeDeviceGeometryTuple(tuple.Data);
if(geom?.Geometries != null)
foreach(DeviceGeometry geometry in geom.Geometries)
var geom = CIS.DecodeDeviceGeometryTuple(tuple.Data);
if (geom?.Geometries != null)
foreach (var geometry in geom.Geometries)
{
decodedTuples.Add("Device width",
$"{(1 << (geometry.CardInterface - 1)) * 8} bits");
$"{(1 << (geometry.CardInterface - 1)) * 8} bits");
decodedTuples.Add("Erase block",
$"{(1 << (geometry.EraseBlockSize - 1)) * (1 << (geometry.Interleaving - 1))} bytes");
$"{(1 << (geometry.EraseBlockSize - 1)) * (1 << (geometry.Interleaving - 1))} bytes");
decodedTuples.Add("Read block",
$"{(1 << (geometry.ReadBlockSize - 1)) * (1 << (geometry.Interleaving - 1))} bytes");
$"{(1 << (geometry.ReadBlockSize - 1)) * (1 << (geometry.Interleaving - 1))} bytes");
decodedTuples.Add("Write block",
$"{(1 << (geometry.WriteBlockSize - 1)) * (1 << (geometry.Interleaving - 1))} bytes");
$"{(1 << (geometry.WriteBlockSize - 1)) * (1 << (geometry.Interleaving - 1))} bytes");
decodedTuples.Add("Partition alignment",
$"{(1 << (geometry.EraseBlockSize - 1)) * (1 << (geometry.Interleaving - 1)) * (1 << (geometry.Partitions - 1))} bytes");
$"{(1 << (geometry.EraseBlockSize - 1)) * (1 << (geometry.Interleaving - 1)) * (1 << (geometry.Partitions - 1))} bytes");
}
break;
@@ -191,44 +193,44 @@ namespace DiscImageChef.Server.Controllers
decodedTuples.Add("Undecoded tuple ID", tuple.Code.ToString());
break;
default:
decodedTuples.Add("Unknown tuple ID", $"0x{(byte)tuple.Code:X2}");
decodedTuples.Add("Unknown tuple ID", $"0x{(byte) tuple.Code:X2}");
break;
}
if(decodedTuples.Count > 0) ViewBag.repPcmciaTuples = decodedTuples;
if (decodedTuples.Count > 0) ViewBag.repPcmciaTuples = decodedTuples;
}
}
bool removable = true;
var removable = true;
List<TestedMedia> testedMedia = null;
bool ata = false;
bool atapi = false;
bool sscMedia = false;
var ata = false;
var atapi = false;
var sscMedia = false;
if(report.ATA != null || report.ATAPI != null)
if (report.ATA != null || report.ATAPI != null)
{
ata = true;
List<string> ataOneValue = new List<string>();
Dictionary<string, string> ataTwoValue = new Dictionary<string, string>();
CommonTypes.Metadata.Ata ataReport;
var ataOneValue = new List<string>();
var ataTwoValue = new Dictionary<string, string>();
CommonTypes.Metadata.Ata ataReport;
if(report.ATAPI != null)
if (report.ATAPI != null)
{
ViewBag.AtaItem = "ATAPI";
ataReport = report.ATAPI;
atapi = true;
ataReport = report.ATAPI;
atapi = true;
}
else
{
ViewBag.AtaItem = "ATA";
ataReport = report.ATA;
ataReport = report.ATA;
}
bool cfa = report.CompactFlash;
var cfa = report.CompactFlash;
if(atapi && !cfa) ViewBag.lblAtaDeviceType = "ATAPI device";
else if(!atapi && cfa) ViewBag.lblAtaDeviceType = "CompactFlash device";
else ViewBag.lblAtaDeviceType = "ATA device";
if (atapi && !cfa) ViewBag.lblAtaDeviceType = "ATAPI device";
else if (!atapi && cfa) ViewBag.lblAtaDeviceType = "CompactFlash device";
else ViewBag.lblAtaDeviceType = "ATA device";
Ata.Report(ataReport, cfa, atapi, ref removable, ref ataOneValue, ref ataTwoValue, ref testedMedia);
@@ -236,62 +238,62 @@ namespace DiscImageChef.Server.Controllers
ViewBag.repAtaTwo = ataTwoValue;
}
if(report.SCSI != null)
if (report.SCSI != null)
{
List<string> scsiOneValue = new List<string>();
Dictionary<string, string> modePages = new Dictionary<string, string>();
Dictionary<string, string> evpdPages = new Dictionary<string, string>();
var scsiOneValue = new List<string>();
var modePages = new Dictionary<string, string>();
var evpdPages = new Dictionary<string, string>();
string vendorId = StringHandlers.CToString(report.SCSI.Inquiry?.VendorIdentification);
if(report.SCSI.Inquiry != null)
var vendorId = StringHandlers.CToString(report.SCSI.Inquiry?.VendorIdentification);
if (report.SCSI.Inquiry != null)
{
Inquiry.SCSIInquiry inq = report.SCSI.Inquiry.Value;
var inq = report.SCSI.Inquiry.Value;
ViewBag.lblScsiVendor = VendorString.Prettify(vendorId) != vendorId
? $"{vendorId} ({VendorString.Prettify(vendorId)})"
: vendorId;
ViewBag.lblScsiProduct = StringHandlers.CToString(inq.ProductIdentification);
? $"{vendorId} ({VendorString.Prettify(vendorId)})"
: vendorId;
ViewBag.lblScsiProduct = StringHandlers.CToString(inq.ProductIdentification);
ViewBag.lblScsiRevision = StringHandlers.CToString(inq.ProductRevisionLevel);
}
scsiOneValue.AddRange(ScsiInquiry.Report(report.SCSI.Inquiry));
if(report.SCSI.SupportsModeSense6) scsiOneValue.Add("Device supports MODE SENSE (6)");
if(report.SCSI.SupportsModeSense10) scsiOneValue.Add("Device supports MODE SENSE (10)");
if(report.SCSI.SupportsModeSubpages) scsiOneValue.Add("Device supports MODE SENSE subpages");
if (report.SCSI.SupportsModeSense6) scsiOneValue.Add("Device supports MODE SENSE (6)");
if (report.SCSI.SupportsModeSense10) scsiOneValue.Add("Device supports MODE SENSE (10)");
if (report.SCSI.SupportsModeSubpages) scsiOneValue.Add("Device supports MODE SENSE subpages");
if(report.SCSI.ModeSense != null)
if (report.SCSI.ModeSense != null)
{
PeripheralDeviceTypes devType = PeripheralDeviceTypes.DirectAccess;
if(report.SCSI.Inquiry != null)
devType = (PeripheralDeviceTypes)report.SCSI.Inquiry.Value.PeripheralDeviceType;
var devType = PeripheralDeviceTypes.DirectAccess;
if (report.SCSI.Inquiry != null)
devType = (PeripheralDeviceTypes) report.SCSI.Inquiry.Value.PeripheralDeviceType;
ScsiModeSense.Report(report.SCSI.ModeSense, vendorId, devType, ref scsiOneValue, ref modePages);
}
if(modePages.Count > 0) ViewBag.repModeSense = modePages;
if (modePages.Count > 0) ViewBag.repModeSense = modePages;
if(report.SCSI.EVPDPages != null) ScsiEvpd.Report(report.SCSI.EVPDPages, vendorId, ref evpdPages);
if (report.SCSI.EVPDPages != null) ScsiEvpd.Report(report.SCSI.EVPDPages, vendorId, ref evpdPages);
if(evpdPages.Count > 0) ViewBag.repEvpd = evpdPages;
if (evpdPages.Count > 0) ViewBag.repEvpd = evpdPages;
if(report.SCSI.MultiMediaDevice != null)
if (report.SCSI.MultiMediaDevice != null)
{
testedMedia = report.SCSI.MultiMediaDevice.TestedMedia;
if(report.SCSI.MultiMediaDevice.ModeSense2A != null)
if (report.SCSI.MultiMediaDevice.ModeSense2A != null)
{
List<string> mmcModeOneValue = new List<string>();
var mmcModeOneValue = new List<string>();
ScsiMmcMode.Report(report.SCSI.MultiMediaDevice.ModeSense2A, ref mmcModeOneValue);
if(mmcModeOneValue.Count > 0) ViewBag.repScsiMmcMode = mmcModeOneValue;
if (mmcModeOneValue.Count > 0) ViewBag.repScsiMmcMode = mmcModeOneValue;
}
if(report.SCSI.MultiMediaDevice.Features != null)
if (report.SCSI.MultiMediaDevice.Features != null)
{
List<string> mmcFeaturesOneValue = new List<string>();
var mmcFeaturesOneValue = new List<string>();
ScsiMmcFeatures.Report(report.SCSI.MultiMediaDevice.Features, ref mmcFeaturesOneValue);
if(mmcFeaturesOneValue.Count > 0) ViewBag.repScsiMmcFeatures = mmcFeaturesOneValue;
if (mmcFeaturesOneValue.Count > 0) ViewBag.repScsiMmcFeatures = mmcFeaturesOneValue;
}
}
else if(report.SCSI.SequentialDevice != null)
else if (report.SCSI.SequentialDevice != null)
{
ViewBag.divScsiSscVisible = true;
@@ -304,160 +306,167 @@ namespace DiscImageChef.Server.Controllers
ViewBag.lblScsiSscMinBlock =
report.SCSI.SequentialDevice.MinBlockLength?.ToString() ?? "Unspecified";
if(report.SCSI.SequentialDevice.SupportedDensities != null)
if (report.SCSI.SequentialDevice.SupportedDensities != null)
ViewBag.repScsiSscDensities = report.SCSI.SequentialDevice.SupportedDensities;
if(report.SCSI.SequentialDevice.SupportedMediaTypes != null)
if (report.SCSI.SequentialDevice.SupportedMediaTypes != null)
ViewBag.repScsiSscMedias = report.SCSI.SequentialDevice.SupportedMediaTypes;
if(report.SCSI.SequentialDevice.TestedMedia != null)
if (report.SCSI.SequentialDevice.TestedMedia != null)
{
List<string> mediaOneValue = new List<string>();
var mediaOneValue = new List<string>();
SscTestedMedia.Report(report.SCSI.SequentialDevice.TestedMedia, ref mediaOneValue);
if(mediaOneValue.Count > 0)
if (mediaOneValue.Count > 0)
{
sscMedia = true;
sscMedia = true;
ViewBag.repTestedMedia = mediaOneValue;
}
}
}
else if(report.SCSI.ReadCapabilities != null)
else if (report.SCSI.ReadCapabilities != null)
{
removable = false;
scsiOneValue.Add("");
if(report.SCSI.ReadCapabilities.Blocks.HasValue &&
report.SCSI.ReadCapabilities.BlockSize.HasValue)
if (report.SCSI.ReadCapabilities.Blocks.HasValue &&
report.SCSI.ReadCapabilities.BlockSize.HasValue)
{
scsiOneValue
.Add($"Device has {report.SCSI.ReadCapabilities.Blocks} blocks of {report.SCSI.ReadCapabilities.BlockSize} bytes each");
.Add(
$"Device has {report.SCSI.ReadCapabilities.Blocks} blocks of {report.SCSI.ReadCapabilities.BlockSize} bytes each");
if(report.SCSI.ReadCapabilities.Blocks * report.SCSI.ReadCapabilities.BlockSize / 1024 /
1024 > 1000000)
if (report.SCSI.ReadCapabilities.Blocks * report.SCSI.ReadCapabilities.BlockSize / 1024 /
1024 > 1000000)
scsiOneValue
.Add($"Device size: {report.SCSI.ReadCapabilities.Blocks * report.SCSI.ReadCapabilities.BlockSize} bytes, {report.SCSI.ReadCapabilities.Blocks * report.SCSI.ReadCapabilities.BlockSize / 1000 / 1000 / 1000 / 1000} Tb, {(double)(report.SCSI.ReadCapabilities.Blocks * report.SCSI.ReadCapabilities.BlockSize) / 1024 / 1024 / 1024 / 1024:F2} TiB");
else if(report.SCSI.ReadCapabilities.Blocks * report.SCSI.ReadCapabilities.BlockSize /
1024 /
1024 > 1000)
.Add(
$"Device size: {report.SCSI.ReadCapabilities.Blocks * report.SCSI.ReadCapabilities.BlockSize} bytes, {report.SCSI.ReadCapabilities.Blocks * report.SCSI.ReadCapabilities.BlockSize / 1000 / 1000 / 1000 / 1000} Tb, {(double) (report.SCSI.ReadCapabilities.Blocks * report.SCSI.ReadCapabilities.BlockSize) / 1024 / 1024 / 1024 / 1024:F2} TiB");
else if (report.SCSI.ReadCapabilities.Blocks * report.SCSI.ReadCapabilities.BlockSize /
1024 /
1024 > 1000)
scsiOneValue
.Add($"Device size: {report.SCSI.ReadCapabilities.Blocks * report.SCSI.ReadCapabilities.BlockSize} bytes, {report.SCSI.ReadCapabilities.Blocks * report.SCSI.ReadCapabilities.BlockSize / 1000 / 1000 / 1000} Gb, {(double)(report.SCSI.ReadCapabilities.Blocks * report.SCSI.ReadCapabilities.BlockSize) / 1024 / 1024 / 1024:F2} GiB");
.Add(
$"Device size: {report.SCSI.ReadCapabilities.Blocks * report.SCSI.ReadCapabilities.BlockSize} bytes, {report.SCSI.ReadCapabilities.Blocks * report.SCSI.ReadCapabilities.BlockSize / 1000 / 1000 / 1000} Gb, {(double) (report.SCSI.ReadCapabilities.Blocks * report.SCSI.ReadCapabilities.BlockSize) / 1024 / 1024 / 1024:F2} GiB");
else
scsiOneValue
.Add($"Device size: {report.SCSI.ReadCapabilities.Blocks * report.SCSI.ReadCapabilities.BlockSize} bytes, {report.SCSI.ReadCapabilities.Blocks * report.SCSI.ReadCapabilities.BlockSize / 1000 / 1000} Mb, {(double)(report.SCSI.ReadCapabilities.Blocks * report.SCSI.ReadCapabilities.BlockSize) / 1024 / 1024:F2} MiB");
.Add(
$"Device size: {report.SCSI.ReadCapabilities.Blocks * report.SCSI.ReadCapabilities.BlockSize} bytes, {report.SCSI.ReadCapabilities.Blocks * report.SCSI.ReadCapabilities.BlockSize / 1000 / 1000} Mb, {(double) (report.SCSI.ReadCapabilities.Blocks * report.SCSI.ReadCapabilities.BlockSize) / 1024 / 1024:F2} MiB");
}
if(report.SCSI.ReadCapabilities.MediumType.HasValue)
if (report.SCSI.ReadCapabilities.MediumType.HasValue)
scsiOneValue.Add($"Medium type code: {report.SCSI.ReadCapabilities.MediumType:X2}h");
if(report.SCSI.ReadCapabilities.Density.HasValue)
if (report.SCSI.ReadCapabilities.Density.HasValue)
scsiOneValue.Add($"Density code: {report.SCSI.ReadCapabilities.Density:X2}h");
if((report.SCSI.ReadCapabilities.SupportsReadLong == true ||
report.SCSI.ReadCapabilities.SupportsReadLong16 == true) &&
report.SCSI.ReadCapabilities.LongBlockSize.HasValue)
if ((report.SCSI.ReadCapabilities.SupportsReadLong == true ||
report.SCSI.ReadCapabilities.SupportsReadLong16 == true) &&
report.SCSI.ReadCapabilities.LongBlockSize.HasValue)
scsiOneValue.Add($"Long block size: {report.SCSI.ReadCapabilities.LongBlockSize} bytes");
if(report.SCSI.ReadCapabilities.SupportsReadCapacity == true)
if (report.SCSI.ReadCapabilities.SupportsReadCapacity == true)
scsiOneValue.Add("Device supports READ CAPACITY (10) command.");
if(report.SCSI.ReadCapabilities.SupportsReadCapacity16 == true)
if (report.SCSI.ReadCapabilities.SupportsReadCapacity16 == true)
scsiOneValue.Add("Device supports READ CAPACITY (16) command.");
if(report.SCSI.ReadCapabilities.SupportsRead6 == true)
if (report.SCSI.ReadCapabilities.SupportsRead6 == true)
scsiOneValue.Add("Device supports READ (6) command.");
if(report.SCSI.ReadCapabilities.SupportsRead10 == true)
if (report.SCSI.ReadCapabilities.SupportsRead10 == true)
scsiOneValue.Add("Device supports READ (10) command.");
if(report.SCSI.ReadCapabilities.SupportsRead12 == true)
if (report.SCSI.ReadCapabilities.SupportsRead12 == true)
scsiOneValue.Add("Device supports READ (12) command.");
if(report.SCSI.ReadCapabilities.SupportsRead16 == true)
if (report.SCSI.ReadCapabilities.SupportsRead16 == true)
scsiOneValue.Add("Device supports READ (16) command.");
if(report.SCSI.ReadCapabilities.SupportsReadLong == true)
if (report.SCSI.ReadCapabilities.SupportsReadLong == true)
scsiOneValue.Add("Device supports READ LONG (10) command.");
if(report.SCSI.ReadCapabilities.SupportsReadLong16 == true)
if (report.SCSI.ReadCapabilities.SupportsReadLong16 == true)
scsiOneValue.Add("Device supports READ LONG (16) command.");
}
else testedMedia = report.SCSI.RemovableMedias;
else
{
testedMedia = report.SCSI.RemovableMedias;
}
ViewBag.repScsi = scsiOneValue;
}
if(report.MultiMediaCard != null)
if (report.MultiMediaCard != null)
{
List<string> mmcOneValue = new List<string>();
var mmcOneValue = new List<string>();
if(report.MultiMediaCard.CID != null)
if (report.MultiMediaCard.CID != null)
{
mmcOneValue.Add(Decoders.MMC.Decoders.PrettifyCID(report.MultiMediaCard.CID)
.Replace("\n", "<br/>"));
.Replace("\n", "<br/>"));
mmcOneValue.Add("");
}
if(report.MultiMediaCard.CSD != null)
if (report.MultiMediaCard.CSD != null)
{
mmcOneValue.Add(Decoders.MMC.Decoders.PrettifyCSD(report.MultiMediaCard.CSD)
.Replace("\n", "<br/>"));
.Replace("\n", "<br/>"));
mmcOneValue.Add("");
}
if(report.MultiMediaCard.ExtendedCSD != null)
if (report.MultiMediaCard.ExtendedCSD != null)
{
mmcOneValue.Add(Decoders.MMC.Decoders.PrettifyExtendedCSD(report.MultiMediaCard.ExtendedCSD)
.Replace("\n", "<br/>"));
.Replace("\n", "<br/>"));
mmcOneValue.Add("");
}
if(report.MultiMediaCard.OCR != null)
if (report.MultiMediaCard.OCR != null)
{
mmcOneValue.Add(Decoders.MMC.Decoders.PrettifyCSD(report.MultiMediaCard.OCR)
.Replace("\n", "<br/>"));
.Replace("\n", "<br/>"));
mmcOneValue.Add("");
}
ViewBag.repMMC = mmcOneValue;
}
if(report.SecureDigital != null)
if (report.SecureDigital != null)
{
List<string> sdOneValue = new List<string>();
var sdOneValue = new List<string>();
if(report.SecureDigital.CID != null)
if (report.SecureDigital.CID != null)
{
sdOneValue.Add(Decoders.SecureDigital.Decoders.PrettifyCID(report.SecureDigital.CID)
.Replace("\n", "<br/>"));
.Replace("\n", "<br/>"));
sdOneValue.Add("");
}
if(report.SecureDigital.CSD != null)
if (report.SecureDigital.CSD != null)
{
sdOneValue.Add(Decoders.SecureDigital.Decoders.PrettifyCSD(report.SecureDigital.CSD)
.Replace("\n", "<br/>"));
.Replace("\n", "<br/>"));
sdOneValue.Add("");
}
if(report.SecureDigital.SCR != null)
if (report.SecureDigital.SCR != null)
{
sdOneValue.Add(Decoders.SecureDigital.Decoders.PrettifySCR(report.SecureDigital.SCR)
.Replace("\n", "<br/>"));
.Replace("\n", "<br/>"));
sdOneValue.Add("");
}
if(report.SecureDigital.OCR != null)
if (report.SecureDigital.OCR != null)
{
sdOneValue.Add(Decoders.SecureDigital.Decoders.PrettifyCSD(report.SecureDigital.OCR)
.Replace("\n", "<br/>"));
.Replace("\n", "<br/>"));
sdOneValue.Add("");
}
ViewBag.repSD = sdOneValue;
}
if(removable && !sscMedia && testedMedia != null)
if (removable && !sscMedia && testedMedia != null)
{
List<string> mediaOneValue = new List<string>();
var mediaOneValue = new List<string>();
App_Start.TestedMedia.Report(testedMedia, ref mediaOneValue);
if(mediaOneValue.Count > 0) ViewBag.repTestedMedia = mediaOneValue;
if (mediaOneValue.Count > 0) ViewBag.repTestedMedia = mediaOneValue;
}
}
catch(Exception)
catch (Exception)
{
#if DEBUG
#if DEBUG
throw;
#endif
#endif
return Content("Could not load device report");
}

314
DiscImageChef.Server/Controllers/StatsController.cs
View File

@@ -44,11 +44,7 @@ using DiscImageChef.Server.Models;
using Highsoft.Web.Mvc.Charts;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Hosting.Internal;
using Filter = DiscImageChef.Server.Models.Filter;
using OperatingSystem = DiscImageChef.Server.Models.OperatingSystem;
using PlatformID = DiscImageChef.CommonTypes.Interop.PlatformID;
using Version = DiscImageChef.Server.Models.Version;
namespace DiscImageChef.Server.Controllers
{
@@ -57,13 +53,13 @@ namespace DiscImageChef.Server.Controllers
/// </summary>
public class StatsController : Controller
{
DicServerContext ctx;
List<DeviceItem> devices;
List<NameValueStats> operatingSystems;
List<MediaItem> realMedia;
List<NameValueStats> versions;
List<MediaItem> virtualMedia;
private IWebHostEnvironment _environment;
private readonly IWebHostEnvironment _environment;
private readonly DicServerContext ctx;
private List<DeviceItem> devices;
private List<NameValueStats> operatingSystems;
private List<MediaItem> realMedia;
private List<NameValueStats> versions;
private List<MediaItem> virtualMedia;
public StatsController(IWebHostEnvironment environment, DicServerContext context)
{
@@ -77,118 +73,120 @@ namespace DiscImageChef.Server.Controllers
try
{
if(
if (
System.IO.File
.Exists(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"Statistics", "Statistics.xml")))
.Exists(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"Statistics", "Statistics.xml")))
try
{
Stats statistics = new Stats();
var statistics = new Stats();
XmlSerializer xs = new XmlSerializer(statistics.GetType());
FileStream fs =
WaitForFile(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(), "Statistics", "Statistics.xml"),
FileMode.Open, FileAccess.Read, FileShare.Read);
statistics = (Stats)xs.Deserialize(fs);
var xs = new XmlSerializer(statistics.GetType());
var fs =
WaitForFile(
Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"Statistics", "Statistics.xml"),
FileMode.Open, FileAccess.Read, FileShare.Read);
statistics = (Stats) xs.Deserialize(fs);
fs.Close();
StatsConverter.Convert(statistics);
System.IO.File
.Delete(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"Statistics", "Statistics.xml"));
.Delete(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"Statistics", "Statistics.xml"));
}
catch(XmlException)
catch (XmlException)
{
// Do nothing
}
if(ctx.OperatingSystems.Any())
if (ctx.OperatingSystems.Any())
{
operatingSystems = new List<NameValueStats>();
foreach(OperatingSystem nvs in ctx.OperatingSystems)
foreach (var nvs in ctx.OperatingSystems)
operatingSystems.Add(new NameValueStats
{
name =
$"{DetectOS.GetPlatformName((PlatformID)Enum.Parse(typeof(PlatformID), nvs.Name), nvs.Version)}{(string.IsNullOrEmpty(nvs.Version) ? "" : " ")}{nvs.Version}",
$"{DetectOS.GetPlatformName((PlatformID) Enum.Parse(typeof(PlatformID), nvs.Name), nvs.Version)}{(string.IsNullOrEmpty(nvs.Version) ? "" : " ")}{nvs.Version}",
Value = nvs.Count
});
ViewBag.repOperatingSystems = operatingSystems.OrderBy(os => os.name).ToList();
List<PieSeriesData> osPieData = new List<PieSeriesData>();
var osPieData = new List<PieSeriesData>();
decimal totalOsCount = ctx.OperatingSystems.Sum(o => o.Count);
foreach(string os in ctx.OperatingSystems.Select(o => o.Name).Distinct().ToList())
foreach (var os in ctx.OperatingSystems.Select(o => o.Name).Distinct().ToList())
{
decimal osCount = ctx.OperatingSystems.Where(o => o.Name == os).Sum(o => o.Count);
osPieData.Add(new PieSeriesData
{
Name =
DetectOS.GetPlatformName((PlatformID)Enum.Parse(typeof(PlatformID),
os)),
Y = (double?)(osCount / totalOsCount),
Sliced = os == "Linux",
DetectOS.GetPlatformName((PlatformID) Enum.Parse(typeof(PlatformID),
os)),
Y = (double?) (osCount / totalOsCount),
Sliced = os == "Linux",
Selected = os == "Linux"
});
}
ViewData["osPieData"] = osPieData;
List<PieSeriesData> linuxPieData = new List<PieSeriesData>();
var linuxPieData = new List<PieSeriesData>();
decimal linuxCount = ctx.OperatingSystems.Where(o => o.Name == PlatformID.Linux.ToString())
.Sum(o => o.Count);
foreach(OperatingSystem version in
.Sum(o => o.Count);
foreach (var version in
ctx.OperatingSystems.Where(o => o.Name == PlatformID.Linux.ToString()))
linuxPieData.Add(new PieSeriesData
{
Name =
$"{DetectOS.GetPlatformName(PlatformID.Linux, version.Version)}{(string.IsNullOrEmpty(version.Version) ? "" : " ")}{version.Version}",
Y = (double?)(version.Count / linuxCount)
Y = (double?) (version.Count / linuxCount)
});
ViewData["linuxPieData"] = linuxPieData;
List<PieSeriesData> macosPieData = new List<PieSeriesData>();
var macosPieData = new List<PieSeriesData>();
decimal macosCount = ctx.OperatingSystems.Where(o => o.Name == PlatformID.MacOSX.ToString())
.Sum(o => o.Count);
foreach(OperatingSystem version in
.Sum(o => o.Count);
foreach (var version in
ctx.OperatingSystems.Where(o => o.Name == PlatformID.MacOSX.ToString()))
macosPieData.Add(new PieSeriesData
{
Name =
$"{DetectOS.GetPlatformName(PlatformID.MacOSX, version.Version)}{(string.IsNullOrEmpty(version.Version) ? "" : " ")}{version.Version}",
Y = (double?)(version.Count / macosCount)
Y = (double?) (version.Count / macosCount)
});
ViewData["macosPieData"] = macosPieData;
List<PieSeriesData> windowsPieData = new List<PieSeriesData>();
var windowsPieData = new List<PieSeriesData>();
decimal windowsCount = ctx.OperatingSystems.Where(o => o.Name == PlatformID.Win32NT.ToString())
.Sum(o => o.Count);
foreach(OperatingSystem version in
.Sum(o => o.Count);
foreach (var version in
ctx.OperatingSystems.Where(o => o.Name == PlatformID.Win32NT.ToString()))
windowsPieData.Add(new PieSeriesData
{
Name =
$"{DetectOS.GetPlatformName(PlatformID.Win32NT, version.Version)}{(string.IsNullOrEmpty(version.Version) ? "" : " ")}{version.Version}",
Y = (double?)(version.Count / windowsCount)
Y = (double?) (version.Count / windowsCount)
});
ViewData["windowsPieData"] = windowsPieData;
}
if(ctx.Versions.Any())
if (ctx.Versions.Any())
{
versions = new List<NameValueStats>();
foreach(Version nvs in ctx.Versions)
foreach (var nvs in ctx.Versions)
versions.Add(new NameValueStats
{
name = nvs.Value == "previous" ? "Previous than 3.4.99.0" : nvs.Value,
name = nvs.Value == "previous" ? "Previous than 3.4.99.0" : nvs.Value,
Value = nvs.Count
});
@@ -202,210 +200,211 @@ namespace DiscImageChef.Server.Controllers
version.Value == "previous"
? "Previous than 3.4.99.0"
: version.Value,
Y = (double?)(version.Count /
totalVersionCount),
Sliced = version.Value == "previous",
Y = (double?) (version.Count /
totalVersionCount),
Sliced = version.Value == "previous",
Selected = version.Value == "previous"
}).ToList();
}
if(ctx.Commands.Any())
if (ctx.Commands.Any())
{
ViewBag.repCommands = ctx.Commands.OrderBy(c => c.Name).ToList();
decimal totalCommandCount = ctx.Commands.Sum(o => o.Count);
ViewData["commandsPieData"] = ctx
.Commands.Select(command => new PieSeriesData
{
Name = command.Name,
Y = (double?)(command.Count /
totalCommandCount),
Sliced = command.Name == "analyze",
Selected = command.Name == "analyze"
}).ToList();
.Commands.Select(command => new PieSeriesData
{
Name = command.Name,
Y = (double?) (command.Count /
totalCommandCount),
Sliced = command.Name == "analyze",
Selected = command.Name == "analyze"
}).ToList();
}
if(ctx.Filters.Any())
if (ctx.Filters.Any())
{
ViewBag.repFilters = ctx.Filters.OrderBy(filter => filter.Name).ToList();
List<PieSeriesData> filtersPieData = new List<PieSeriesData>();
var filtersPieData = new List<PieSeriesData>();
decimal totalFiltersCount = ctx.Filters.Sum(o => o.Count);
foreach(Filter filter in ctx.Filters.ToList())
foreach (var filter in ctx.Filters.ToList())
filtersPieData.Add(new PieSeriesData
{
Name = filter.Name,
Y = (double?)(filter.Count / totalFiltersCount),
Sliced = filter.Name == "No filter",
Name = filter.Name,
Y = (double?) (filter.Count / totalFiltersCount),
Sliced = filter.Name == "No filter",
Selected = filter.Name == "No filter"
});
ViewData["filtersPieData"] = filtersPieData;
}
if(ctx.MediaFormats.Any())
if (ctx.MediaFormats.Any())
{
ViewBag.repMediaImages = ctx.MediaFormats.OrderBy(filter => filter.Name).ToList();
List<PieSeriesData> formatsPieData = new List<PieSeriesData>();
var formatsPieData = new List<PieSeriesData>();
decimal totalFormatsCount = ctx.MediaFormats.Sum(o => o.Count);
decimal top10FormatCount = 0;
decimal top10FormatCount = 0;
foreach(MediaFormat format in ctx.MediaFormats.OrderByDescending(o => o.Count).Take(10))
foreach (var format in ctx.MediaFormats.OrderByDescending(o => o.Count).Take(10))
{
top10FormatCount += format.Count;
formatsPieData.Add(new PieSeriesData
{
Name = format.Name, Y = (double?)(format.Count / totalFormatsCount)
Name = format.Name, Y = (double?) (format.Count / totalFormatsCount)
});
}
formatsPieData.Add(new PieSeriesData
{
Name = "Other",
Y = (double?)((totalFormatsCount - top10FormatCount) /
totalFormatsCount),
Sliced = true,
Y = (double?) ((totalFormatsCount - top10FormatCount) /
totalFormatsCount),
Sliced = true,
Selected = true
});
ViewData["formatsPieData"] = formatsPieData;
}
if(ctx.Partitions.Any())
if (ctx.Partitions.Any())
{
ViewBag.repPartitions = ctx.Partitions.OrderBy(filter => filter.Name).ToList();
List<PieSeriesData> partitionsPieData = new List<PieSeriesData>();
var partitionsPieData = new List<PieSeriesData>();
decimal totalPartitionsCount = ctx.Partitions.Sum(o => o.Count);
decimal top10PartitionCount = 0;
decimal top10PartitionCount = 0;
foreach(Partition partition in ctx.Partitions.OrderByDescending(o => o.Count).Take(10))
foreach (var partition in ctx.Partitions.OrderByDescending(o => o.Count).Take(10))
{
top10PartitionCount += partition.Count;
partitionsPieData.Add(new PieSeriesData
{
Name = partition.Name,
Y = (double?)(partition.Count / totalPartitionsCount)
Y = (double?) (partition.Count / totalPartitionsCount)
});
}
partitionsPieData.Add(new PieSeriesData
{
Name = "Other",
Y = (double?)((totalPartitionsCount - top10PartitionCount) /
totalPartitionsCount),
Sliced = true,
Y = (double?) ((totalPartitionsCount - top10PartitionCount) /
totalPartitionsCount),
Sliced = true,
Selected = true
});
ViewData["partitionsPieData"] = partitionsPieData;
}
if(ctx.Filesystems.Any())
if (ctx.Filesystems.Any())
{
ViewBag.repFilesystems = ctx.Filesystems.OrderBy(filter => filter.Name).ToList();
List<PieSeriesData> filesystemsPieData = new List<PieSeriesData>();
var filesystemsPieData = new List<PieSeriesData>();
decimal totalFilesystemsCount = ctx.Filesystems.Sum(o => o.Count);
decimal top10FilesystemCount = 0;
decimal top10FilesystemCount = 0;
foreach(Filesystem filesystem in ctx.Filesystems.OrderByDescending(o => o.Count).Take(10))
foreach (var filesystem in ctx.Filesystems.OrderByDescending(o => o.Count).Take(10))
{
top10FilesystemCount += filesystem.Count;
filesystemsPieData.Add(new PieSeriesData
{
Name = filesystem.Name,
Y = (double?)(filesystem.Count / totalFilesystemsCount)
Y = (double?) (filesystem.Count / totalFilesystemsCount)
});
}
filesystemsPieData.Add(new PieSeriesData
{
Name = "Other",
Y = (double?)((totalFilesystemsCount - top10FilesystemCount) /
totalFilesystemsCount),
Sliced = true,
Y = (double?) ((totalFilesystemsCount - top10FilesystemCount) /
totalFilesystemsCount),
Sliced = true,
Selected = true
});
ViewData["filesystemsPieData"] = filesystemsPieData;
}
if(ctx.Medias.Any())
if (ctx.Medias.Any())
{
realMedia = new List<MediaItem>();
realMedia = new List<MediaItem>();
virtualMedia = new List<MediaItem>();
foreach(Media nvs in ctx.Medias)
foreach (var nvs in ctx.Medias)
try
{
MediaType
.MediaTypeToString((CommonTypes.MediaType)Enum.Parse(typeof(CommonTypes.MediaType), nvs.Type),
out string type, out string subtype);
.MediaTypeToString(
(CommonTypes.MediaType) Enum.Parse(typeof(CommonTypes.MediaType), nvs.Type),
out var type, out var subtype);
if(nvs.Real)
realMedia.Add(new MediaItem {Type = type, SubType = subtype, Count = nvs.Count});
if (nvs.Real)
realMedia.Add(new MediaItem {Type = type, SubType = subtype, Count = nvs.Count});
else virtualMedia.Add(new MediaItem {Type = type, SubType = subtype, Count = nvs.Count});
}
catch
{
if(nvs.Real)
realMedia.Add(new MediaItem {Type = nvs.Type, SubType = null, Count = nvs.Count});
if (nvs.Real)
realMedia.Add(new MediaItem {Type = nvs.Type, SubType = null, Count = nvs.Count});
else virtualMedia.Add(new MediaItem {Type = nvs.Type, SubType = null, Count = nvs.Count});
}
if(realMedia.Count > 0)
if (realMedia.Count > 0)
{
ViewBag.repRealMedia =
realMedia.OrderBy(media => media.Type).ThenBy(media => media.SubType).ToList();
List<PieSeriesData> realMediaPieData = new List<PieSeriesData>();
var realMediaPieData = new List<PieSeriesData>();
decimal totalRealMediaCount = realMedia.Sum(o => o.Count);
decimal top10RealMediaCount = 0;
foreach(MediaItem realMediaItem in realMedia.OrderByDescending(o => o.Count).Take(10))
foreach (var realMediaItem in realMedia.OrderByDescending(o => o.Count).Take(10))
{
top10RealMediaCount += realMediaItem.Count;
realMediaPieData.Add(new PieSeriesData
{
Name = $"{realMediaItem.Type} ({realMediaItem.SubType})",
Y = (double?)(realMediaItem.Count / totalRealMediaCount)
Y = (double?) (realMediaItem.Count / totalRealMediaCount)
});
}
realMediaPieData.Add(new PieSeriesData
{
Name = "Other",
Y = (double?)((totalRealMediaCount - top10RealMediaCount) /
totalRealMediaCount),
Sliced = true,
Y = (double?) ((totalRealMediaCount - top10RealMediaCount) /
totalRealMediaCount),
Sliced = true,
Selected = true
});
ViewData["realMediaPieData"] = realMediaPieData;
}
if(virtualMedia.Count > 0)
if (virtualMedia.Count > 0)
{
ViewBag.repVirtualMedia =
virtualMedia.OrderBy(media => media.Type).ThenBy(media => media.SubType).ToList();
List<PieSeriesData> virtualMediaPieData = new List<PieSeriesData>();
var virtualMediaPieData = new List<PieSeriesData>();
decimal totalVirtualMediaCount = virtualMedia.Sum(o => o.Count);
decimal top10VirtualMediaCount = 0;
foreach(MediaItem virtualMediaItem in virtualMedia.OrderByDescending(o => o.Count).Take(10))
foreach (var virtualMediaItem in virtualMedia.OrderByDescending(o => o.Count).Take(10))
{
top10VirtualMediaCount += virtualMediaItem.Count;
@@ -413,8 +412,8 @@ namespace DiscImageChef.Server.Controllers
{
Name =
$"{virtualMediaItem.Type} ({virtualMediaItem.SubType})",
Y = (double?)(virtualMediaItem.Count /
totalVirtualMediaCount)
Y = (double?) (virtualMediaItem.Count /
totalVirtualMediaCount)
});
}
@@ -424,7 +423,7 @@ namespace DiscImageChef.Server.Controllers
Y = (double?)
((totalVirtualMediaCount - top10VirtualMediaCount) /
totalVirtualMediaCount),
Sliced = true,
Sliced = true,
Selected = true
});
@@ -432,93 +431,100 @@ namespace DiscImageChef.Server.Controllers
}
}
if(ctx.DeviceStats.Any())
if (ctx.DeviceStats.Any())
{
devices = new List<DeviceItem>();
foreach(DeviceStat device in ctx.DeviceStats.ToList())
foreach (var device in ctx.DeviceStats.ToList())
{
string xmlFile;
if(!string.IsNullOrWhiteSpace(device.Manufacturer) &&
!string.IsNullOrWhiteSpace(device.Model) &&
!string.IsNullOrWhiteSpace(device.Revision))
if (!string.IsNullOrWhiteSpace(device.Manufacturer) &&
!string.IsNullOrWhiteSpace(device.Model) &&
!string.IsNullOrWhiteSpace(device.Revision))
xmlFile = device.Manufacturer + "_" + device.Model + "_" + device.Revision + ".xml";
else if(!string.IsNullOrWhiteSpace(device.Manufacturer) &&
!string.IsNullOrWhiteSpace(device.Model))
else if (!string.IsNullOrWhiteSpace(device.Manufacturer) &&
!string.IsNullOrWhiteSpace(device.Model))
xmlFile = device.Manufacturer + "_" + device.Model + ".xml";
else if(!string.IsNullOrWhiteSpace(device.Model) && !string.IsNullOrWhiteSpace(device.Revision))
xmlFile = device.Model + "_" + device.Revision + ".xml";
else xmlFile = device.Model + ".xml";
else if (!string.IsNullOrWhiteSpace(device.Model) &&
!string.IsNullOrWhiteSpace(device.Revision))
xmlFile = device.Model + "_" + device.Revision + ".xml";
else xmlFile = device.Model + ".xml";
xmlFile = xmlFile.Replace('/', '_').Replace('\\', '_').Replace('?', '_');
if(System.IO.File.Exists(Path.Combine(_environment.ContentRootPath, "Reports", xmlFile)))
if (System.IO.File.Exists(Path.Combine(_environment.ContentRootPath, "Reports", xmlFile)))
{
DeviceReport deviceReport = new DeviceReport();
var deviceReport = new DeviceReport();
XmlSerializer xs = new XmlSerializer(deviceReport.GetType());
FileStream fs =
WaitForFile(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(), "Reports", xmlFile),
FileMode.Open, FileAccess.Read, FileShare.Read);
deviceReport = (DeviceReport)xs.Deserialize(fs);
var xs = new XmlSerializer(deviceReport.GetType());
var fs =
WaitForFile(
Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"Reports", xmlFile),
FileMode.Open, FileAccess.Read, FileShare.Read);
deviceReport = (DeviceReport) xs.Deserialize(fs);
fs.Close();
DeviceReportV2 deviceReportV2 = new DeviceReportV2(deviceReport);
var deviceReportV2 = new DeviceReportV2(deviceReport);
device.Report = ctx.Devices.Add(new Device(deviceReportV2)).Entity;
ctx.SaveChanges();
System.IO.File
.Delete(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"Reports", xmlFile));
.Delete(Path.Combine(
_environment.ContentRootPath ?? throw new InvalidOperationException(),
"Reports", xmlFile));
}
devices.Add(new DeviceItem
{
Manufacturer = device.Manufacturer,
Model = device.Model,
Revision = device.Revision,
Bus = device.Bus,
Model = device.Model,
Revision = device.Revision,
Bus = device.Bus,
ReportId = device.Report != null && device.Report.Id != 0
? device.Report.Id
: 0
? device.Report.Id
: 0
});
}
ViewBag.repDevices = devices.OrderBy(device => device.Manufacturer).ThenBy(device => device.Model)
.ThenBy(device => device.Revision).ThenBy(device => device.Bus)
.ToList();
.ThenBy(device => device.Revision).ThenBy(device => device.Bus)
.ToList();
ViewData["devicesBusPieData"] = (from deviceBus in devices.Select(d => d.Bus).Distinct()
let deviceBusCount = devices.Count(d => d.Bus == deviceBus)
select new PieSeriesData
{
Name = deviceBus,
Y = deviceBusCount / (double)devices.Count
}).ToList();
let deviceBusCount = devices.Count(d => d.Bus == deviceBus)
select new PieSeriesData
{
Name = deviceBus,
Y = deviceBusCount / (double) devices.Count
}).ToList();
ViewData["devicesManufacturerPieData"] =
(from manufacturer in
devices.Where(d => d.Manufacturer != null).Select(d => d.Manufacturer.ToLowerInvariant())
devices.Where(d => d.Manufacturer != null)
.Select(d => d.Manufacturer.ToLowerInvariant())
.Distinct()
let manufacturerCount = devices.Count(d => d.Manufacturer?.ToLowerInvariant() == manufacturer)
select new PieSeriesData {Name = manufacturer, Y = manufacturerCount / (double)devices.Count})
.ToList();
let manufacturerCount =
devices.Count(d => d.Manufacturer?.ToLowerInvariant() == manufacturer)
select new PieSeriesData
{Name = manufacturer, Y = manufacturerCount / (double) devices.Count})
.ToList();
}
}
catch(Exception)
catch (Exception)
{
#if DEBUG
#if DEBUG
throw;
#endif
#endif
return Content("Could not read statistics");
}
return View();
}
static FileStream WaitForFile(string fullPath, FileMode mode, FileAccess access, FileShare share)
private static FileStream WaitForFile(string fullPath, FileMode mode, FileAccess access, FileShare share)
{
for(int numTries = 0; numTries < 100; numTries++)
for (var numTries = 0; numTries < 100; numTries++)
{
FileStream fs = null;
try
@@ -526,7 +532,7 @@ namespace DiscImageChef.Server.Controllers
fs = new FileStream(fullPath, mode, access, share);
return fs;
}
catch(IOException)
catch (IOException)
{
fs?.Dispose();
Thread.Sleep(50);

40
DiscImageChef.Server/Controllers/UpdateController.cs
View File

@@ -30,13 +30,10 @@
// Copyright © 2011-2019 Natalia Portillo
// ****************************************************************************/
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Text;
using DiscImageChef.CommonTypes.Metadata;
using DiscImageChef.Dto;
using DiscImageChef.Server.Models;
@@ -48,7 +45,7 @@ namespace DiscImageChef.Server.Controllers
{
public class UpdateController : Controller
{
private DicServerContext _ctx;
private readonly DicServerContext _ctx;
public UpdateController(DicServerContext ctx)
{
@@ -63,40 +60,43 @@ namespace DiscImageChef.Server.Controllers
[HttpGet]
public ActionResult Update(long timestamp)
{
SyncDto sync = new SyncDto();
DateTime lastSync = DateHandlers.UnixToDateTime(timestamp);
var sync = new SyncDto();
var lastSync = DateHandlers.UnixToDateTime(timestamp);
sync.UsbVendors = new List<UsbVendorDto>();
foreach(UsbVendor vendor in _ctx.UsbVendors.Where(v => v.ModifiedWhen > lastSync))
sync.UsbVendors.Add(new UsbVendorDto {VendorId = (ushort)vendor.VendorId, Vendor = vendor.Vendor});
foreach (var vendor in _ctx.UsbVendors.Where(v => v.ModifiedWhen > lastSync))
sync.UsbVendors.Add(new UsbVendorDto {VendorId = (ushort) vendor.VendorId, Vendor = vendor.Vendor});
sync.UsbProducts = new List<UsbProductDto>();
foreach(UsbProduct product in _ctx.UsbProducts.Include(p => p.Vendor).Where(p => p.ModifiedWhen > lastSync))
foreach (var product in _ctx.UsbProducts.Include(p => p.Vendor).Where(p => p.ModifiedWhen > lastSync))
sync.UsbProducts.Add(new UsbProductDto
{
Id = product.Id,
Product = product.Product,
ProductId = (ushort)product.ProductId,
VendorId = (ushort)product.Vendor.VendorId
Id = product.Id,
Product = product.Product,
ProductId = (ushort) product.ProductId,
VendorId = (ushort) product.Vendor.VendorId
});
sync.Offsets = new List<CdOffsetDto>();
foreach(CompactDiscOffset offset in _ctx.CdOffsets.Where(o => o.ModifiedWhen > lastSync))
foreach (var offset in _ctx.CdOffsets.Where(o => o.ModifiedWhen > lastSync))
sync.Offsets.Add(new CdOffsetDto(offset, offset.Id));
sync.Devices = new List<DeviceDto>();
foreach(Device device in _ctx.Devices.Where(d => d.ModifiedWhen > lastSync).ToList())
foreach (var device in _ctx.Devices.Where(d => d.ModifiedWhen > lastSync).ToList())
sync.Devices.Add(new
DeviceDto(JsonConvert.DeserializeObject<DeviceReportV2>(JsonConvert.SerializeObject(device, Formatting.None, new JsonSerializerSettings {ReferenceLoopHandling = ReferenceLoopHandling.Ignore})),
device.Id, device.OptimalMultipleSectorsRead));
DeviceDto(
JsonConvert.DeserializeObject<DeviceReportV2>(JsonConvert.SerializeObject(device,
Formatting.None,
new JsonSerializerSettings {ReferenceLoopHandling = ReferenceLoopHandling.Ignore})),
device.Id, device.OptimalMultipleSectorsRead));
JsonSerializer js = JsonSerializer.Create();
StringWriter sw = new StringWriter();
var js = JsonSerializer.Create();
var sw = new StringWriter();
js.Serialize(sw, sync);
return new ContentResult
{
StatusCode = (int)HttpStatusCode.OK,
StatusCode = (int) HttpStatusCode.OK,
Content = sw.ToString(),
ContentType = "application/json"
};

99
DiscImageChef.Server/Controllers/UploadReportController.cs
View File

@@ -34,19 +34,15 @@ using System;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using System.Web;
using System.Xml.Serialization;
using Cinchoo.PGP;
using DiscImageChef.CommonTypes.Metadata;
using DiscImageChef.Server.Models;
using MailKit.Net.Smtp;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Hosting.Internal;
using MimeKit;
using Newtonsoft.Json;
@@ -54,8 +50,8 @@ namespace DiscImageChef.Server.Controllers
{
public class UploadReportController : Controller
{
private DicServerContext ctx;
private IWebHostEnvironment _environment;
private readonly IWebHostEnvironment _environment;
private readonly DicServerContext ctx;
public UploadReportController(IWebHostEnvironment environment, DicServerContext _ctx)
{
@@ -71,53 +67,54 @@ namespace DiscImageChef.Server.Controllers
[HttpPost]
public async Task<IActionResult> UploadReport()
{
ContentResult response = new ContentResult {StatusCode = (int)HttpStatusCode.OK, ContentType = "text/plain"};
var response = new ContentResult {StatusCode = (int) HttpStatusCode.OK, ContentType = "text/plain"};
try
{
DeviceReport newReport = new DeviceReport();
HttpRequest request = HttpContext.Request;
var newReport = new DeviceReport();
var request = HttpContext.Request;
XmlSerializer xs = new XmlSerializer(newReport.GetType());
newReport = (DeviceReport) xs.Deserialize(new StringReader(await new StreamReader(request.Body).ReadToEndAsync()));
var xs = new XmlSerializer(newReport.GetType());
newReport = (DeviceReport) xs.Deserialize(
new StringReader(await new StreamReader(request.Body).ReadToEndAsync()));
if(newReport == null)
if (newReport == null)
{
response.Content = "notstats";
return response;
}
DeviceReportV2 reportV2 = new DeviceReportV2(newReport);
StringWriter jsonSw = new StringWriter();
var reportV2 = new DeviceReportV2(newReport);
var jsonSw = new StringWriter();
jsonSw.Write(JsonConvert.SerializeObject(reportV2, Formatting.Indented,
new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
}));
string reportV2String = jsonSw.ToString();
new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
}));
var reportV2String = jsonSw.ToString();
jsonSw.Close();
ctx.Reports.Add(new UploadedReport(reportV2));
ctx.SaveChanges();
MemoryStream pgpIn = new MemoryStream(Encoding.UTF8.GetBytes(reportV2String));
MemoryStream pgpOut = new MemoryStream();
ChoPGPEncryptDecrypt pgp = new ChoPGPEncryptDecrypt();
var pgpIn = new MemoryStream(Encoding.UTF8.GetBytes(reportV2String));
var pgpOut = new MemoryStream();
var pgp = new ChoPGPEncryptDecrypt();
pgp.Encrypt(pgpIn, pgpOut,
Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"public.asc"), true);
Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"public.asc"));
pgpOut.Position = 0;
reportV2String = Encoding.UTF8.GetString(pgpOut.ToArray());
reportV2String = Encoding.UTF8.GetString(pgpOut.ToArray());
MimeMessage message = new MimeMessage
var message = new MimeMessage
{
Subject = "New device report (old version)",
Body = new TextPart("plain") {Text = reportV2String}
Body = new TextPart("plain") {Text = reportV2String}
};
message.From.Add(new MailboxAddress("DiscImageChef", "dic@claunia.com"));
message.From.Add(new MailboxAddress("DiscImageChef", "dic@claunia.com"));
message.To.Add(new MailboxAddress("Natalia Portillo", "claunia@claunia.com"));
using(SmtpClient client = new SmtpClient())
using (var client = new SmtpClient())
{
client.Connect("mail.claunia.com", 25, false);
client.Send(message);
@@ -130,9 +127,9 @@ namespace DiscImageChef.Server.Controllers
// ReSharper disable once RedundantCatchClause
catch
{
#if DEBUG
if(Debugger.IsAttached) throw;
#endif
#if DEBUG
if (Debugger.IsAttached) throw;
#endif
response.Content = "error";
return response;
}
@@ -146,17 +143,17 @@ namespace DiscImageChef.Server.Controllers
[HttpPost]
public async Task<IActionResult> UploadReportV2()
{
ContentResult response = new ContentResult {StatusCode = (int)HttpStatusCode.OK, ContentType = "text/plain"};
var response = new ContentResult {StatusCode = (int) HttpStatusCode.OK, ContentType = "text/plain"};
try
{
HttpRequest request = HttpContext.Request;
var request = HttpContext.Request;
StreamReader sr = new StreamReader(request.Body);
string reportJson = await sr.ReadToEndAsync();
DeviceReportV2 newReport = JsonConvert.DeserializeObject<DeviceReportV2>(reportJson);
var sr = new StreamReader(request.Body);
var reportJson = await sr.ReadToEndAsync();
var newReport = JsonConvert.DeserializeObject<DeviceReportV2>(reportJson);
if(newReport == null)
if (newReport == null)
{
response.Content = "notstats";
return response;
@@ -165,23 +162,23 @@ namespace DiscImageChef.Server.Controllers
ctx.Reports.Add(new UploadedReport(newReport));
ctx.SaveChanges();
MemoryStream pgpIn = new MemoryStream(Encoding.UTF8.GetBytes(reportJson));
MemoryStream pgpOut = new MemoryStream();
ChoPGPEncryptDecrypt pgp = new ChoPGPEncryptDecrypt();
var pgpIn = new MemoryStream(Encoding.UTF8.GetBytes(reportJson));
var pgpOut = new MemoryStream();
var pgp = new ChoPGPEncryptDecrypt();
pgp.Encrypt(pgpIn, pgpOut,
Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"public.asc"), true);
Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"public.asc"));
pgpOut.Position = 0;
reportJson = Encoding.UTF8.GetString(pgpOut.ToArray());
reportJson = Encoding.UTF8.GetString(pgpOut.ToArray());
MimeMessage message = new MimeMessage
var message = new MimeMessage
{
Subject = "New device report", Body = new TextPart("plain") {Text = reportJson}
};
message.From.Add(new MailboxAddress("DiscImageChef", "dic@claunia.com"));
message.From.Add(new MailboxAddress("DiscImageChef", "dic@claunia.com"));
message.To.Add(new MailboxAddress("Natalia Portillo", "claunia@claunia.com"));
using(SmtpClient client = new SmtpClient())
using (var client = new SmtpClient())
{
client.Connect("mail.claunia.com", 25, false);
client.Send(message);
@@ -194,10 +191,10 @@ namespace DiscImageChef.Server.Controllers
// ReSharper disable once RedundantCatchClause
catch
{
#if DEBUG
if(Debugger.IsAttached) throw;
#endif
response.Content ="error";
#if DEBUG
if (Debugger.IsAttached) throw;
#endif
response.Content = "error";
return response;
}
}

147
DiscImageChef.Server/Controllers/UploadStatsController.cs
View File

@@ -35,16 +35,12 @@ using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web;
using System.Xml.Serialization;
using DiscImageChef.CommonTypes.Metadata;
using DiscImageChef.Server.Models;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using OperatingSystem = DiscImageChef.Server.Models.OperatingSystem;
@@ -54,7 +50,7 @@ namespace DiscImageChef.Server.Controllers
{
public class UploadStatsController : Controller
{
DicServerContext _ctx;
private readonly DicServerContext _ctx;
private IWebHostEnvironment _environment;
public UploadStatsController(IWebHostEnvironment environment, DicServerContext ctx)
@@ -62,6 +58,7 @@ namespace DiscImageChef.Server.Controllers
_environment = environment;
_ctx = ctx;
}
/// <summary>
/// Receives statistics from DiscImageChef.Core, processes them and adds them to a server-side global statistics XML
/// </summary>
@@ -70,17 +67,18 @@ namespace DiscImageChef.Server.Controllers
[HttpPost]
public async Task<IActionResult> UploadStats()
{
ContentResult response = new ContentResult {StatusCode = (int)HttpStatusCode.OK, ContentType = "text/plain"};
var response = new ContentResult {StatusCode = (int) HttpStatusCode.OK, ContentType = "text/plain"};
try
{
Stats newStats = new Stats();
HttpRequest request = HttpContext.Request;
var newStats = new Stats();
var request = HttpContext.Request;
XmlSerializer xs = new XmlSerializer(newStats.GetType());
newStats = (Stats) xs.Deserialize(new StringReader(await new StreamReader(request.Body).ReadToEndAsync()));
var xs = new XmlSerializer(newStats.GetType());
newStats = (Stats) xs.Deserialize(
new StringReader(await new StreamReader(request.Body).ReadToEndAsync()));
if(newStats == null)
if (newStats == null)
{
response.Content = "notstats";
return response;
@@ -91,11 +89,11 @@ namespace DiscImageChef.Server.Controllers
response.Content = "ok";
return response;
}
catch(Exception ex)
catch (Exception ex)
{
#if DEBUG
if(Debugger.IsAttached) throw;
#endif
#if DEBUG
if (Debugger.IsAttached) throw;
#endif
response.Content = "error";
return response;
}
@@ -109,119 +107,120 @@ namespace DiscImageChef.Server.Controllers
[HttpPost]
public async Task<IActionResult> UploadStatsV2()
{
ContentResult response = new ContentResult {StatusCode = (int)HttpStatusCode.OK, ContentType = "text/plain"};
var response = new ContentResult {StatusCode = (int) HttpStatusCode.OK, ContentType = "text/plain"};
try
{
HttpRequest request = HttpContext.Request;
var request = HttpContext.Request;
StreamReader sr = new StreamReader(request.Body);
var sr = new StreamReader(request.Body);
var statsString = await sr.ReadToEndAsync();
StatsDto newstats = JsonConvert.DeserializeObject<StatsDto>(statsString);
var newstats = JsonConvert.DeserializeObject<StatsDto>(statsString);
if(newstats == null)
if (newstats == null)
{
response.Content = "notstats";
return response;
}
if(newstats.Commands != null)
foreach(NameValueStats nvs in newstats.Commands)
if (newstats.Commands != null)
foreach (var nvs in newstats.Commands)
{
Command existing = _ctx.Commands.FirstOrDefault(c => c.Name == nvs.name);
var existing = _ctx.Commands.FirstOrDefault(c => c.Name == nvs.name);
if(existing == null) _ctx.Commands.Add(new Command {Name = nvs.name, Count = nvs.Value});
if (existing == null) _ctx.Commands.Add(new Command {Name = nvs.name, Count = nvs.Value});
else existing.Count += nvs.Value;
}
if(newstats.Versions != null)
foreach(NameValueStats nvs in newstats.Versions)
if (newstats.Versions != null)
foreach (var nvs in newstats.Versions)
{
Version existing = _ctx.Versions.FirstOrDefault(c => c.Value == nvs.name);
var existing = _ctx.Versions.FirstOrDefault(c => c.Value == nvs.name);
if(existing == null) _ctx.Versions.Add(new Version {Value = nvs.name, Count = nvs.Value});
if (existing == null) _ctx.Versions.Add(new Version {Value = nvs.name, Count = nvs.Value});
else existing.Count += nvs.Value;
}
if(newstats.Filesystems != null)
foreach(NameValueStats nvs in newstats.Filesystems)
if (newstats.Filesystems != null)
foreach (var nvs in newstats.Filesystems)
{
Filesystem existing = _ctx.Filesystems.FirstOrDefault(c => c.Name == nvs.name);
var existing = _ctx.Filesystems.FirstOrDefault(c => c.Name == nvs.name);
if(existing == null) _ctx.Filesystems.Add(new Filesystem {Name = nvs.name, Count = nvs.Value});
if (existing == null) _ctx.Filesystems.Add(new Filesystem {Name = nvs.name, Count = nvs.Value});
else existing.Count += nvs.Value;
}
if(newstats.Partitions != null)
foreach(NameValueStats nvs in newstats.Partitions)
if (newstats.Partitions != null)
foreach (var nvs in newstats.Partitions)
{
Partition existing = _ctx.Partitions.FirstOrDefault(c => c.Name == nvs.name);
var existing = _ctx.Partitions.FirstOrDefault(c => c.Name == nvs.name);
if(existing == null) _ctx.Partitions.Add(new Partition {Name = nvs.name, Count = nvs.Value});
if (existing == null) _ctx.Partitions.Add(new Partition {Name = nvs.name, Count = nvs.Value});
else existing.Count += nvs.Value;
}
if(newstats.MediaFormats != null)
foreach(NameValueStats nvs in newstats.MediaFormats)
if (newstats.MediaFormats != null)
foreach (var nvs in newstats.MediaFormats)
{
MediaFormat existing = _ctx.MediaFormats.FirstOrDefault(c => c.Name == nvs.name);
var existing = _ctx.MediaFormats.FirstOrDefault(c => c.Name == nvs.name);
if(existing == null) _ctx.MediaFormats.Add(new MediaFormat {Name = nvs.name, Count = nvs.Value});
if (existing == null)
_ctx.MediaFormats.Add(new MediaFormat {Name = nvs.name, Count = nvs.Value});
else existing.Count += nvs.Value;
}
if(newstats.Filters != null)
foreach(NameValueStats nvs in newstats.Filters)
if (newstats.Filters != null)
foreach (var nvs in newstats.Filters)
{
Filter existing = _ctx.Filters.FirstOrDefault(c => c.Name == nvs.name);
var existing = _ctx.Filters.FirstOrDefault(c => c.Name == nvs.name);
if(existing == null) _ctx.Filters.Add(new Filter {Name = nvs.name, Count = nvs.Value});
if (existing == null) _ctx.Filters.Add(new Filter {Name = nvs.name, Count = nvs.Value});
else existing.Count += nvs.Value;
}
if(newstats.OperatingSystems != null)
foreach(OsStats operatingSystem in newstats.OperatingSystems)
if (newstats.OperatingSystems != null)
foreach (var operatingSystem in newstats.OperatingSystems)
{
OperatingSystem existing =
_ctx.OperatingSystems.FirstOrDefault(c => c.Name == operatingSystem.name &&
c.Version == operatingSystem.version);
var existing =
_ctx.OperatingSystems.FirstOrDefault(c => c.Name == operatingSystem.name &&
c.Version == operatingSystem.version);
if(existing == null)
if (existing == null)
_ctx.OperatingSystems.Add(new OperatingSystem
{
Name = operatingSystem.name,
Name = operatingSystem.name,
Version = operatingSystem.version,
Count = operatingSystem.Value
Count = operatingSystem.Value
});
else existing.Count += operatingSystem.Value;
}
if(newstats.Medias != null)
foreach(MediaStats media in newstats.Medias)
if (newstats.Medias != null)
foreach (var media in newstats.Medias)
{
Media existing = _ctx.Medias.FirstOrDefault(c => c.Type == media.type && c.Real == media.real);
var existing = _ctx.Medias.FirstOrDefault(c => c.Type == media.type && c.Real == media.real);
if(existing == null)
if (existing == null)
_ctx.Medias.Add(new Media {Type = media.type, Real = media.real, Count = media.Value});
else existing.Count += media.Value;
}
if(newstats.Devices != null)
foreach(DeviceStats device in newstats.Devices)
if (newstats.Devices != null)
foreach (var device in newstats.Devices)
{
DeviceStat existing =
_ctx.DeviceStats.FirstOrDefault(c => c.Bus == device.Bus &&
c.Manufacturer == device.Manufacturer &&
c.Model == device.Model &&
c.Revision == device.Revision);
var existing =
_ctx.DeviceStats.FirstOrDefault(c => c.Bus == device.Bus &&
c.Manufacturer == device.Manufacturer &&
c.Model == device.Model &&
c.Revision == device.Revision);
if(existing == null)
if (existing == null)
_ctx.DeviceStats.Add(new DeviceStat
{
Bus = device.Bus,
Bus = device.Bus,
Manufacturer = device.Manufacturer,
Model = device.Model,
Revision = device.Revision
Model = device.Model,
Revision = device.Revision
});
}
@@ -233,17 +232,17 @@ namespace DiscImageChef.Server.Controllers
// ReSharper disable once RedundantCatchClause
catch
{
#if DEBUG
if(Debugger.IsAttached) throw;
#endif
#if DEBUG
if (Debugger.IsAttached) throw;
#endif
response.Content = "error";
return response;
}
}
FileStream WaitForFile(string fullPath, FileMode mode, FileAccess access, FileShare share)
private FileStream WaitForFile(string fullPath, FileMode mode, FileAccess access, FileShare share)
{
for(int numTries = 0; numTries < 100; numTries++)
for (var numTries = 0; numTries < 100; numTries++)
{
FileStream fs = null;
try
@@ -251,9 +250,9 @@ namespace DiscImageChef.Server.Controllers
fs = new FileStream(fullPath, mode, access, share);
return fs;
}
catch(IOException)
catch (IOException)
{
if(fs != null) fs.Dispose();
if (fs != null) fs.Dispose();
Thread.Sleep(50);
}
}

1478
DiscImageChef.Server/Migrations/20191102132240_InitialMigration.cs
View File

File diff suppressed because it is too large Load Diff

2748
DiscImageChef.Server/Migrations/DicServerContextModelSnapshot.cs
View File

File diff suppressed because it is too large Load Diff

29
DiscImageChef.Server/Models/CdOffset.cs
View File

@@ -32,38 +32,39 @@
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations.Schema;
using DiscImageChef.CommonTypes.Metadata;
namespace DiscImageChef.Server.Models
{
public class CompactDiscOffset : CdOffset
{
public CompactDiscOffset() { }
public CompactDiscOffset()
{
}
public CompactDiscOffset(string manufacturer, string model, short offset, int submissions, float agreement)
{
Manufacturer = manufacturer;
Model = model;
Offset = offset;
Submissions = submissions;
Agreement = agreement;
AddedWhen = ModifiedWhen = DateTime.UtcNow;
Model = model;
Offset = offset;
Submissions = submissions;
Agreement = agreement;
AddedWhen = ModifiedWhen = DateTime.UtcNow;
}
public CompactDiscOffset(CdOffset offset)
{
Manufacturer = offset.Manufacturer;
Model = offset.Model;
Offset = offset.Offset;
Submissions = offset.Submissions;
Agreement = offset.Agreement;
AddedWhen = ModifiedWhen = DateTime.UtcNow;
Model = offset.Model;
Offset = offset.Offset;
Submissions = offset.Submissions;
Agreement = offset.Agreement;
AddedWhen = ModifiedWhen = DateTime.UtcNow;
}
public int Id { get; set; }
public int Id { get; set; }
public DateTime AddedWhen { get; set; }
public DateTime ModifiedWhen { get; set; }
public DateTime ModifiedWhen { get; set; }
public virtual ICollection<Device> Devices { get; set; }
}
}

8
DiscImageChef.Server/Models/Command.cs
View File

@@ -36,9 +36,9 @@ namespace DiscImageChef.Server.Models
{
public class Command
{
[Key]
public int Id { get; set; }
public string Name { get; set; }
public long Count { get; set; }
[Key] public int Id { get; set; }
public string Name { get; set; }
public long Count { get; set; }
}
}

42
DiscImageChef.Server/Models/Context.cs
View File

@@ -37,28 +37,32 @@ namespace DiscImageChef.Server.Models
{
public sealed class DicServerContext : DbContext
{
public DbSet<Device> Devices { get; set; }
public DbSet<UploadedReport> Reports { get; set; }
public DbSet<Command> Commands { get; set; }
public DbSet<DeviceStat> DeviceStats { get; set; }
public DbSet<Filesystem> Filesystems { get; set; }
public DbSet<Filter> Filters { get; set; }
public DbSet<Media> Medias { get; set; }
public DbSet<MediaFormat> MediaFormats { get; set; }
public DbSet<OperatingSystem> OperatingSystems { get; set; }
public DbSet<Partition> Partitions { get; set; }
public DbSet<Version> Versions { get; set; }
public DbSet<UsbVendor> UsbVendors { get; set; }
public DbSet<UsbProduct> UsbProducts { get; set; }
public DbSet<CompactDiscOffset> CdOffsets { get; set; }
public DicServerContext()
{
}
public DicServerContext() { }
public DicServerContext(DbContextOptions<DicServerContext> options) : base(options)
{
}
public DicServerContext(DbContextOptions<DicServerContext> options) : base(options) { }
public DbSet<Device> Devices { get; set; }
public DbSet<UploadedReport> Reports { get; set; }
public DbSet<Command> Commands { get; set; }
public DbSet<DeviceStat> DeviceStats { get; set; }
public DbSet<Filesystem> Filesystems { get; set; }
public DbSet<Filter> Filters { get; set; }
public DbSet<Media> Medias { get; set; }
public DbSet<MediaFormat> MediaFormats { get; set; }
public DbSet<OperatingSystem> OperatingSystems { get; set; }
public DbSet<Partition> Partitions { get; set; }
public DbSet<Version> Versions { get; set; }
public DbSet<UsbVendor> UsbVendors { get; set; }
public DbSet<UsbProduct> UsbProducts { get; set; }
public DbSet<CompactDiscOffset> CdOffsets { get; set; }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
if(optionsBuilder.IsConfigured) return;
if (optionsBuilder.IsConfigured) return;
var builder = new ConfigurationBuilder().AddJsonFile("appsettings.json");
@@ -82,7 +86,7 @@ namespace DiscImageChef.Server.Models
internal static bool TableExists(string tableName)
{
using(var db = new DicServerContext())
using (var db = new DicServerContext())
{
var connection = db.Database.GetDbConnection();
connection.Open();
@@ -91,7 +95,7 @@ namespace DiscImageChef.Server.Models
command.CommandText =
$"SELECT COUNT(*) FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA=DATABASE() AND TABLE_NAME=\"{tableName}\"";
var result = (long)command.ExecuteScalar();
var result = (long) command.ExecuteScalar();
return result != 0;
}

35
DiscImageChef.Server/Models/Device.cs
View File

@@ -32,7 +32,6 @@
using System;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations.Schema;
using DiscImageChef.CommonTypes.Metadata;
namespace DiscImageChef.Server.Models
@@ -46,27 +45,27 @@ namespace DiscImageChef.Server.Models
public Device(DeviceReportV2 report)
{
ATA = report.ATA;
ATAPI = report.ATAPI;
CompactFlash = report.CompactFlash;
FireWire = report.FireWire;
AddedWhen = DateTime.UtcNow;
ModifiedWhen = DateTime.UtcNow;
ATA = report.ATA;
ATAPI = report.ATAPI;
CompactFlash = report.CompactFlash;
FireWire = report.FireWire;
AddedWhen = DateTime.UtcNow;
ModifiedWhen = DateTime.UtcNow;
MultiMediaCard = report.MultiMediaCard;
PCMCIA = report.PCMCIA;
SCSI = report.SCSI;
SecureDigital = report.SecureDigital;
USB = report.USB;
Manufacturer = report.Manufacturer;
Model = report.Model;
Revision = report.Revision;
Type = report.Type;
PCMCIA = report.PCMCIA;
SCSI = report.SCSI;
SecureDigital = report.SecureDigital;
USB = report.USB;
Manufacturer = report.Manufacturer;
Model = report.Model;
Revision = report.Revision;
Type = report.Type;
}
public DateTime AddedWhen { get; set; }
public DateTime? ModifiedWhen { get; set; }
public DateTime? ModifiedWhen { get; set; }
public virtual CompactDiscOffset CdOffset { get; set; }
[DefaultValue(0)]
public int OptimalMultipleSectorsRead { get; set; }
[DefaultValue(0)] public int OptimalMultipleSectorsRead { get; set; }
}
}

8
DiscImageChef.Server/Models/DeviceItem.cs
View File

@@ -35,9 +35,9 @@ namespace DiscImageChef.Server.Models
public class DeviceItem
{
public string Manufacturer { get; set; }
public string Model { get; set; }
public string Revision { get; set; }
public string Bus { get; set; }
public int ReportId { get; set; }
public string Model { get; set; }
public string Revision { get; set; }
public string Bus { get; set; }
public int ReportId { get; set; }
}
}

14
DiscImageChef.Server/Models/DeviceStat.cs
View File

@@ -36,12 +36,12 @@ namespace DiscImageChef.Server.Models
{
public class DeviceStat
{
[Key]
public int Id { get; set; }
public string Manufacturer { get; set; }
public string Model { get; set; }
public string Revision { get; set; }
public string Bus { get; set; }
public virtual Device Report { get; set; }
[Key] public int Id { get; set; }
public string Manufacturer { get; set; }
public string Model { get; set; }
public string Revision { get; set; }
public string Bus { get; set; }
public virtual Device Report { get; set; }
}
}

2
DiscImageChef.Server/Models/ErrorViewModel.cs
View File

@@ -1,5 +1,3 @@
using System;
namespace DiscImageChef.Server.Models
{
public class ErrorViewModel

8
DiscImageChef.Server/Models/Filesystem.cs
View File

@@ -36,9 +36,9 @@ namespace DiscImageChef.Server.Models
{
public class Filesystem
{
[Key]
public int Id { get; set; }
public string Name { get; set; }
public long Count { get; set; }
[Key] public int Id { get; set; }
public string Name { get; set; }
public long Count { get; set; }
}
}

8
DiscImageChef.Server/Models/Filter.cs
View File

@@ -36,9 +36,9 @@ namespace DiscImageChef.Server.Models
{
public class Filter
{
[Key]
public int Id { get; set; }
public string Name { get; set; }
public long Count { get; set; }
[Key] public int Id { get; set; }
public string Name { get; set; }
public long Count { get; set; }
}
}

10
DiscImageChef.Server/Models/Media.cs
View File

@@ -36,10 +36,10 @@ namespace DiscImageChef.Server.Models
{
public class Media
{
[Key]
public int Id { get; set; }
public string Type { get; set; }
public bool Real { get; set; }
public long Count { get; set; }
[Key] public int Id { get; set; }
public string Type { get; set; }
public bool Real { get; set; }
public long Count { get; set; }
}
}

8
DiscImageChef.Server/Models/MediaFormat.cs
View File

@@ -36,9 +36,9 @@ namespace DiscImageChef.Server.Models
{
public class MediaFormat
{
[Key]
public int Id { get; set; }
public string Name { get; set; }
public long Count { get; set; }
[Key] public int Id { get; set; }
public string Name { get; set; }
public long Count { get; set; }
}
}

4
DiscImageChef.Server/Models/MediaItem.cs
View File

@@ -34,8 +34,8 @@ namespace DiscImageChef.Server.Models
{
public class MediaItem
{
public string Type { get; set; }
public string Type { get; set; }
public string SubType { get; set; }
public long Count { get; set; }
public long Count { get; set; }
}
}

8
DiscImageChef.Server/Models/OperatingSystem.cs
View File

@@ -36,10 +36,10 @@ namespace DiscImageChef.Server.Models
{
public class OperatingSystem
{
[Key]
public int Id { get; set; }
public string Name { get; set; }
[Key] public int Id { get; set; }
public string Name { get; set; }
public string Version { get; set; }
public long Count { get; set; }
public long Count { get; set; }
}
}

8
DiscImageChef.Server/Models/Partition.cs
View File

@@ -36,9 +36,9 @@ namespace DiscImageChef.Server.Models
{
public class Partition
{
[Key]
public int Id { get; set; }
public string Name { get; set; }
public long Count { get; set; }
[Key] public int Id { get; set; }
public string Name { get; set; }
public long Count { get; set; }
}
}

26
DiscImageChef.Server/Models/UploadedReport.cs
View File

@@ -44,20 +44,20 @@ namespace DiscImageChef.Server.Models
public UploadedReport(DeviceReportV2 report)
{
ATA = report.ATA;
ATAPI = report.ATAPI;
CompactFlash = report.CompactFlash;
FireWire = report.FireWire;
UploadedWhen = DateTime.UtcNow;
ATA = report.ATA;
ATAPI = report.ATAPI;
CompactFlash = report.CompactFlash;
FireWire = report.FireWire;
UploadedWhen = DateTime.UtcNow;
MultiMediaCard = report.MultiMediaCard;
PCMCIA = report.PCMCIA;
SCSI = report.SCSI;
SecureDigital = report.SecureDigital;
USB = report.USB;
Manufacturer = report.Manufacturer;
Model = report.Model;
Revision = report.Revision;
Type = report.Type;
PCMCIA = report.PCMCIA;
SCSI = report.SCSI;
SecureDigital = report.SecureDigital;
USB = report.USB;
Manufacturer = report.Manufacturer;
Model = report.Model;
Revision = report.Revision;
Type = report.Type;
}
public DateTime UploadedWhen { get; set; }

21
DiscImageChef.Server/Models/UsbProduct.cs
View File

@@ -32,31 +32,32 @@
using System;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using Newtonsoft.Json;
namespace DiscImageChef.Server.Models
{
public class UsbProduct
{
public UsbProduct() { }
public UsbProduct()
{
}
public UsbProduct(UsbVendor vendor, ushort id, string product)
{
ProductId = id;
Product = product;
Product = product;
AddedWhen = ModifiedWhen = DateTime.UtcNow;
Vendor = vendor;
Vendor = vendor;
}
[Key]
public int Id { get; set; }
public int ProductId { get; set; }
public string Product { get; set; }
[Key] public int Id { get; set; }
public int ProductId { get; set; }
public string Product { get; set; }
public DateTime AddedWhen { get; set; }
public DateTime ModifiedWhen { get; set; }
public int VendorId { get; set; }
[JsonIgnore]
public virtual UsbVendor Vendor { get; set; }
[JsonIgnore] public virtual UsbVendor Vendor { get; set; }
}
}

20
DiscImageChef.Server/Models/UsbVendor.cs
View File

@@ -33,30 +33,30 @@
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using Newtonsoft.Json;
namespace DiscImageChef.Server.Models
{
public class UsbVendor
{
public UsbVendor() { }
public UsbVendor()
{
}
public UsbVendor(ushort id, string vendor)
{
VendorId = id;
Vendor = vendor;
VendorId = id;
Vendor = vendor;
AddedWhen = ModifiedWhen = DateTime.UtcNow;
}
[Key]
public int Id { get; set; }
public int VendorId { get; set; }
public string Vendor { get; set; }
[Key] public int Id { get; set; }
public int VendorId { get; set; }
public string Vendor { get; set; }
public DateTime AddedWhen { get; set; }
public DateTime ModifiedWhen { get; set; }
[JsonIgnore]
public virtual ICollection<UsbProduct> Products { get; set; }
[JsonIgnore] public virtual ICollection<UsbProduct> Products { get; set; }
}
}

6
DiscImageChef.Server/Models/Version.cs
View File

@@ -36,9 +36,9 @@ namespace DiscImageChef.Server.Models
{
public class Version
{
[Key]
public int Id { get; set; }
[Key] public int Id { get; set; }
public string Value { get; set; }
public long Count { get; set; }
public long Count { get; set; }
}
}

142
DiscImageChef.Server/Program.cs
View File

@@ -1,14 +1,11 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using DiscImageChef.CommonTypes.Interop;
using DiscImageChef.Server.Models;
using Microsoft.AspNetCore.Hosting;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Version = DiscImageChef.CommonTypes.Interop.Version;
namespace DiscImageChef.Server
{
@@ -19,68 +16,68 @@ namespace DiscImageChef.Server
DateTime start;
DateTime end;
System.Console.Clear();
System.Console.Clear();
System.Console.Write(
"\u001b[32m . ,,\n" +
"\u001b[32m ;,. '0d.\n" +
"\u001b[32m oc oWd \u001b[31m" +
@"________/\\\\\\\\\___/\\\\\\\\\\\_________/\\\\\\\\\___/\\\\____________/\\\\_" +
"\n\u001b[0m" +
"\u001b[32m ;X. 'WN' \u001b[31m" +
@" _____/\\\////////___\/////\\\///_______/\\\////////___\/\\\\\\________/\\\\\\_" +
"\n\u001b[0m" +
"\u001b[32m oMo cMM: \u001b[31m" +
@" ___/\\\/________________\/\\\________/\\\/____________\/\\\//\\\____/\\\//\\\_" +
"\n\u001b[0m" +
"\u001b[32m ;MM. .MMM; \u001b[31m" +
@" __/\\\__________________\/\\\_______/\\\______________\/\\\\///\\\/\\\/_\/\\\_" +
"\n\u001b[0m" +
"\u001b[32m NMM WMMW \u001b[31m" +
@" _\/\\\__________________\/\\\______\/\\\______________\/\\\__\///\\\/___\/\\\_" +
"\n\u001b[0m" +
"\u001b[32m 'MMM MMMM; \u001b[31m" +
@" _\//\\\_________________\/\\\______\//\\\_____________\/\\\____\///_____\/\\\_" +
"\n\u001b[0m" +
"\u001b[32m ,MMM: dMMMM: \u001b[31m" +
@" __\///\\\_______________\/\\\_______\///\\\___________\/\\\_____________\/\\\_" +
"\n\u001b[0m" +
"\u001b[32m .MMMW. :MMMMM. \u001b[31m" +
@" ____\////\\\\\\\\\___/\\\\\\\\\\\_____\////\\\\\\\\\__\/\\\_____________\/\\\_" +
"\n\u001b[0m" +
"\u001b[32m XMMMW: .:xKNMMMMMMN0d, lMMMMMd \u001b[31m" +
@" _______\/////////___\///////////_________\/////////___\///______________\///__" +
"\n\u001b[0m" +
"\u001b[32m :MMMMMK; cWMNkl:;;;:lxKMXc .0MMMMMO\u001b[0m\n" +
"\u001b[32m ..KMMMMMMNo,. ,OMMMMMMW:,. \u001b[37;1m DiscImageChef Website\u001b[0m\n" +
"\u001b[32m .;d0NMMMMMMMMMMMMMMW0d:' .;lOWMMMMMMMMMMMMMXkl. \u001b[37;1m Version \u001b[0m\u001b[33m{0}\u001b[37;1m-\u001b[0m\u001b[31m{1}\u001b[0m\n" +
"\u001b[32m :KMMMMMMMMMMMMMMMMMMMMMMMMc WMMMMMMMMMMMMMMMMMMMMMMWk'\u001b[0m\n" +
"\u001b[32m ;NMMMMWX0kkkkO0XMMMMMMMMMMM0' dNMMMMMMMMMMW0xl:;,;:oOWMMX; \u001b[37;1m Running under \u001b[35;1m{2}\u001b[37;1m, \u001b[35m{3}-bit\u001b[37;1m in \u001b[35m{4}-bit\u001b[37;1m mode.\u001b[0m\n" +
"\u001b[32m xMMWk:. .c0MMMMMW' OMMMMMM0c'.. .oNMO \u001b[37;1m Using \u001b[33;1m{5}\u001b[37;1m version \u001b[31;1m{6}\u001b[0m\n" +
"\u001b[32m OMNc .MNc oWMMk 'WMMNl. .MMK ;KX.\u001b[0m\n" +
"\u001b[32m xMO WMN ; ., , ': ,MMx lK\u001b[0m\n" +
"\u001b[32m ,Md cMMl .XMMMWWMMMO XMW. :\u001b[0m\n" +
"\u001b[32m Ok xMMl XMMMMMMMMc 0MW,\u001b[0m\n" +
"\u001b[32m 0 oMM0' lMMMMMMMM. :NMN'\u001b[0m\n" +
"\u001b[32m . .0MMKl ;MMMMMMMM oNMWd\u001b[0m\n" +
"\u001b[32m .dNW cMMMMMMMM, XKl\u001b[0m\n" +
"\u001b[32m 0MMMMMMMMK\u001b[0m\n" +
"\u001b[32m ;MMMMMMMMMMO \u001b[37;1m Proudly presented to you by:\u001b[0m\n" +
"\u001b[32m 'WMMMMKxMMMMM0 \u001b[34;1m Natalia Portillo\u001b[0m\n" +
"\u001b[32m oMMMMNc :WMMMMN:\u001b[0m\n" +
"\u001b[32m .dWMMM0; dWMMMMXl. \u001b[37;1m Thanks to all contributors, collaborators, translators, donators and friends.\u001b[0m\n" +
"\u001b[32m .......,cd0WMMNk: c0MMMMMWKkolc:clodc'\u001b[0m\n" +
"\u001b[32m .';loddol:'. ':oxkkOkkxoc,.\u001b[0m\n" +
"\u001b[0m\n", DiscImageChef.CommonTypes.Interop.Version.GetVersion(),
#if DEBUG
"DEBUG"
#else
System.Console.Write(
"\u001b[32m . ,,\n" +
"\u001b[32m ;,. '0d.\n" +
"\u001b[32m oc oWd \u001b[31m" +
@"________/\\\\\\\\\___/\\\\\\\\\\\_________/\\\\\\\\\___/\\\\____________/\\\\_" +
"\n\u001b[0m" +
"\u001b[32m ;X. 'WN' \u001b[31m" +
@" _____/\\\////////___\/////\\\///_______/\\\////////___\/\\\\\\________/\\\\\\_" +
"\n\u001b[0m" +
"\u001b[32m oMo cMM: \u001b[31m" +
@" ___/\\\/________________\/\\\________/\\\/____________\/\\\//\\\____/\\\//\\\_" +
"\n\u001b[0m" +
"\u001b[32m ;MM. .MMM; \u001b[31m" +
@" __/\\\__________________\/\\\_______/\\\______________\/\\\\///\\\/\\\/_\/\\\_" +
"\n\u001b[0m" +
"\u001b[32m NMM WMMW \u001b[31m" +
@" _\/\\\__________________\/\\\______\/\\\______________\/\\\__\///\\\/___\/\\\_" +
"\n\u001b[0m" +
"\u001b[32m 'MMM MMMM; \u001b[31m" +
@" _\//\\\_________________\/\\\______\//\\\_____________\/\\\____\///_____\/\\\_" +
"\n\u001b[0m" +
"\u001b[32m ,MMM: dMMMM: \u001b[31m" +
@" __\///\\\_______________\/\\\_______\///\\\___________\/\\\_____________\/\\\_" +
"\n\u001b[0m" +
"\u001b[32m .MMMW. :MMMMM. \u001b[31m" +
@" ____\////\\\\\\\\\___/\\\\\\\\\\\_____\////\\\\\\\\\__\/\\\_____________\/\\\_" +
"\n\u001b[0m" +
"\u001b[32m XMMMW: .:xKNMMMMMMN0d, lMMMMMd \u001b[31m" +
@" _______\/////////___\///////////_________\/////////___\///______________\///__" +
"\n\u001b[0m" +
"\u001b[32m :MMMMMK; cWMNkl:;;;:lxKMXc .0MMMMMO\u001b[0m\n" +
"\u001b[32m ..KMMMMMMNo,. ,OMMMMMMW:,. \u001b[37;1m DiscImageChef Website\u001b[0m\n" +
"\u001b[32m .;d0NMMMMMMMMMMMMMMW0d:' .;lOWMMMMMMMMMMMMMXkl. \u001b[37;1m Version \u001b[0m\u001b[33m{0}\u001b[37;1m-\u001b[0m\u001b[31m{1}\u001b[0m\n" +
"\u001b[32m :KMMMMMMMMMMMMMMMMMMMMMMMMc WMMMMMMMMMMMMMMMMMMMMMMWk'\u001b[0m\n" +
"\u001b[32m ;NMMMMWX0kkkkO0XMMMMMMMMMMM0' dNMMMMMMMMMMW0xl:;,;:oOWMMX; \u001b[37;1m Running under \u001b[35;1m{2}\u001b[37;1m, \u001b[35m{3}-bit\u001b[37;1m in \u001b[35m{4}-bit\u001b[37;1m mode.\u001b[0m\n" +
"\u001b[32m xMMWk:. .c0MMMMMW' OMMMMMM0c'.. .oNMO \u001b[37;1m Using \u001b[33;1m{5}\u001b[37;1m version \u001b[31;1m{6}\u001b[0m\n" +
"\u001b[32m OMNc .MNc oWMMk 'WMMNl. .MMK ;KX.\u001b[0m\n" +
"\u001b[32m xMO WMN ; ., , ': ,MMx lK\u001b[0m\n" +
"\u001b[32m ,Md cMMl .XMMMWWMMMO XMW. :\u001b[0m\n" +
"\u001b[32m Ok xMMl XMMMMMMMMc 0MW,\u001b[0m\n" +
"\u001b[32m 0 oMM0' lMMMMMMMM. :NMN'\u001b[0m\n" +
"\u001b[32m . .0MMKl ;MMMMMMMM oNMWd\u001b[0m\n" +
"\u001b[32m .dNW cMMMMMMMM, XKl\u001b[0m\n" +
"\u001b[32m 0MMMMMMMMK\u001b[0m\n" +
"\u001b[32m ;MMMMMMMMMMO \u001b[37;1m Proudly presented to you by:\u001b[0m\n" +
"\u001b[32m 'WMMMMKxMMMMM0 \u001b[34;1m Natalia Portillo\u001b[0m\n" +
"\u001b[32m oMMMMNc :WMMMMN:\u001b[0m\n" +
"\u001b[32m .dWMMM0; dWMMMMXl. \u001b[37;1m Thanks to all contributors, collaborators, translators, donators and friends.\u001b[0m\n" +
"\u001b[32m .......,cd0WMMNk: c0MMMMMWKkolc:clodc'\u001b[0m\n" +
"\u001b[32m .';loddol:'. ':oxkkOkkxoc,.\u001b[0m\n" +
"\u001b[0m\n", Version.GetVersion(),
#if DEBUG
"DEBUG"
#else
"RELEASE"
#endif
, DiscImageChef.CommonTypes.Interop.DetectOS.GetPlatformName(DiscImageChef.CommonTypes.Interop.DetectOS.GetRealPlatformID()),
Environment.Is64BitOperatingSystem ? 64 : 32, Environment.Is64BitProcess ? 64 : 32,
DiscImageChef.CommonTypes.Interop.DetectOS.IsMono ? "Mono" : ".NET Core",
DiscImageChef.CommonTypes.Interop.DetectOS.IsMono ? DiscImageChef.CommonTypes.Interop.Version.GetMonoVersion() : DiscImageChef.CommonTypes.Interop.Version.GetNetCoreVersion());
#endif
, DetectOS.GetPlatformName(DetectOS.GetRealPlatformID()),
Environment.Is64BitOperatingSystem ? 64 : 32, Environment.Is64BitProcess ? 64 : 32,
DetectOS.IsMono ? "Mono" : ".NET Core",
DetectOS.IsMono ? Version.GetMonoVersion() : Version.GetNetCoreVersion());
var host = CreateHostBuilder(args).Build();
@@ -97,15 +94,14 @@ namespace DiscImageChef.Server
context.Database.Migrate();
end = DateTime.Now;
System.Console.WriteLine("\u001b[31;1mTook \u001b[32;1m{0} seconds\u001b[31;1m...\u001b[0m",
(end - start).TotalSeconds);
(end - start).TotalSeconds);
}
catch(Exception ex)
catch (Exception ex)
{
System.Console.WriteLine("\u001b[31;1mCould not open database...\u001b[0m");
#if DEBUG
#if DEBUG
System.Console.WriteLine("\u001b[31;1mException: {0}\u001b[0m", ex.Message);
#endif
#endif
return;
}
}
@@ -114,8 +110,10 @@ namespace DiscImageChef.Server
host.Run();
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
public static IHostBuilder CreateHostBuilder(string[] args)
{
return Host.CreateDefaultBuilder(args)
.ConfigureWebHostDefaults(webBuilder => { webBuilder.UseStartup<Startup>(); });
}
}
}

9
DiscImageChef.Server/Startup.cs
View File

@@ -1,11 +1,6 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using DiscImageChef.Server.Models;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.HttpsPolicy;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
@@ -56,8 +51,8 @@ namespace DiscImageChef.Server
app.UseEndpoints(endpoints =>
{
endpoints.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
"default",
"{controller=Home}/{action=Index}/{id?}");
});
}
}

2
DiscImageChef.Server/Views/Home/CODE_OF_CONDUCT.cshtml
View File

@@ -36,7 +36,7 @@
// ****************************************************************************/
}
<p>
@Html.ActionLink("Return to main page.", "Index")<br />
@Html.ActionLink("Return to main page.", "Index")<br/>
DiscImageChef's code of conduct:
</p>
<div class="container">@Html.Raw(ViewBag.Markdown)</div>

2
DiscImageChef.Server/Views/Home/CONTRIBUTING.cshtml
View File

@@ -36,7 +36,7 @@
// ****************************************************************************/
}
<p>
@Html.ActionLink("Return to main page.", "Index")<br />
@Html.ActionLink("Return to main page.", "Index")<br/>
How to contribute to DiscImageChef:
</p>
<div class="container">@Html.Raw(ViewBag.Markdown)</div>

2
DiscImageChef.Server/Views/Home/Changelog.cshtml
View File

@@ -36,7 +36,7 @@
// ****************************************************************************/
}
<p>
@Html.ActionLink("Return to main page.", "Index")<br />
@Html.ActionLink("Return to main page.", "Index")<br/>
DiscImageChef list of changes:
</p>
<div class="container">@Html.Raw(ViewBag.Markdown)</div>

2
DiscImageChef.Server/Views/Home/DONATING.cshtml
View File

@@ -36,7 +36,7 @@
// ****************************************************************************/
}
<p>
@Html.ActionLink("Return to main page.", "Index")<br />
@Html.ActionLink("Return to main page.", "Index")<br/>
DiscImageChef list of things to be donated:
</p>
<div class="container">@Html.Raw(ViewBag.Markdown)</div>

2
DiscImageChef.Server/Views/Home/ISSUE_TEMPLATE.cshtml
View File

@@ -36,7 +36,7 @@
// ****************************************************************************/
}
<p>
@Html.ActionLink("Return to main page.", "Index")<br />
@Html.ActionLink("Return to main page.", "Index")<br/>
DiscImageChef's template for issue reports:
</p>
<div class="container">@Html.Raw(ViewBag.Markdown)</div>

2
DiscImageChef.Server/Views/Home/PULL_REQUEST_TEMPLATE.cshtml
View File

@@ -36,7 +36,7 @@
// ****************************************************************************/
}
<p>
@Html.ActionLink("Return to main page.", "Index")<br />
@Html.ActionLink("Return to main page.", "Index")<br/>
DiscImageChef's template for pull requests:
</p>
<div class="container">@Html.Raw(ViewBag.Markdown)</div>

2
DiscImageChef.Server/Views/Home/TODO.cshtml
View File

@@ -36,7 +36,7 @@
// ****************************************************************************/
}
<p>
@Html.ActionLink("Return to main page.", "Index")<br />
@Html.ActionLink("Return to main page.", "Index")<br/>
DiscImageChef list of things to do:
</p>
<div class="container">@Html.Raw(ViewBag.Markdown)</div>

182
DiscImageChef.Server/Views/Report/View.cshtml
View File

@@ -42,91 +42,91 @@ DiscImageChef Report for
@ViewBag.lblModel
@ViewBag.lblRevision
@if(ViewBag.UsbItem != null)
@if (ViewBag.UsbItem != null)
{
<div id="divUsb">
<br />
<b>USB characteristics:</b><br />
<i>Manufacturer:</i> @ViewBag.UsbItem.Manufacturer<br />
<i>Product:</i> @ViewBag.UsbItem.Product<br />
<i>Vendor ID:</i> @ViewBag.UsbItem.VendorDescription<br />
<br/>
<b>USB characteristics:</b><br/>
<i>Manufacturer:</i> @ViewBag.UsbItem.Manufacturer<br/>
<i>Product:</i> @ViewBag.UsbItem.Product<br/>
<i>Vendor ID:</i> @ViewBag.UsbItem.VendorDescription<br/>
<i>Product ID:</i> @ViewBag.UsbItem.ProductDescription
</div>
}
@if(ViewBag.FireWireItem != null)
@if (ViewBag.FireWireItem != null)
{
<div id="divFireWire">
<br />
<b>FireWire characteristics:</b><br />
<i>Manufacturer:</i> @ViewBag.FireWire.Manufacturer<br />
<i>Product:</i> @ViewBag.FireWire.Product<br />
<i>Vendor ID:</i> @ViewBag.FireWire.VendorDescription<br />
<br/>
<b>FireWire characteristics:</b><br/>
<i>Manufacturer:</i> @ViewBag.FireWire.Manufacturer<br/>
<i>Product:</i> @ViewBag.FireWire.Product<br/>
<i>Vendor ID:</i> @ViewBag.FireWire.VendorDescription<br/>
<i>Product ID:</i> @ViewBag.FireWire.ProductDescription
</div>
}
@if(ViewBag.PcmciaItem != null)
@if (ViewBag.PcmciaItem != null)
{
<div id="divPcmcia">
<br />
<b>PCMCIA characteristics:</b><br />
<i>Manufacturer:</i> @ViewBag.PcmciaItem.Manufacturer<br />
<i>Product:</i> @ViewBag.PcmciaItem.ProductName<br />
<i>Manufacturer code:</i> @ViewBag.PcmciaItem.VendorDescription<br />
<i>Card code:</i> @ViewBag.PcmciaItem.CardCode<br />
<i>Compliance:</i> @ViewBag.PcmciaItem.Compliance<br />
@if(ViewBag.repPcmciaTuples != null)
<br/>
<b>PCMCIA characteristics:</b><br/>
<i>Manufacturer:</i> @ViewBag.PcmciaItem.Manufacturer<br/>
<i>Product:</i> @ViewBag.PcmciaItem.ProductName<br/>
<i>Manufacturer code:</i> @ViewBag.PcmciaItem.VendorDescription<br/>
<i>Card code:</i> @ViewBag.PcmciaItem.CardCode<br/>
<i>Compliance:</i> @ViewBag.PcmciaItem.Compliance<br/>
@if (ViewBag.repPcmciaTuples != null)
{
foreach(KeyValuePair<string, string> kvp in ViewBag.repPcmciaTuples)
foreach (KeyValuePair<string, string> kvp in ViewBag.repPcmciaTuples)
{
<text><i>@kvp.Key</i>: @kvp.Value<br /></text>
<text><i>@kvp.Key</i>: @kvp.Value<br/></text>
}
}
</div>
}
@if(ViewBag.AtaItem != null)
@if (ViewBag.AtaItem != null)
{
<div id="divAta">
<br />
<br/>
<b>
@ViewBag.AtaItem characteristics:
</b><br />
@ViewBag.lblAtaDeviceType<br />
@foreach(KeyValuePair<string, string> kvp in ViewBag.repAtaTwo)
</b><br/>
@ViewBag.lblAtaDeviceType<br/>
@foreach (KeyValuePair<string, string> kvp in ViewBag.repAtaTwo)
{
<text><i>@kvp.Key</i>: @kvp.Value<br /></text>
<text><i>@kvp.Key</i>: @kvp.Value<br/></text>
}
<br />
@foreach(string item in ViewBag.repAtaOne)
<br/>
@foreach (string item in ViewBag.repAtaOne)
{
@Html.Raw(item)<br />
@Html.Raw(item)<br/>
}
</div>
}
@if(ViewBag.repScsi != null)
@if (ViewBag.repScsi != null)
{
<div id="divScsi">
<br />
<b>SCSI characteristics:</b><br />
<i>Vendor: </i>@ViewBag.lblScsiVendor<br />
<i>Product: </i>@ViewBag.lblScsiProduct<br />
<i>Revision: </i>@ViewBag.lblScsiRevision<br />
@foreach(string item in ViewBag.repScsi)
<br/>
<b>SCSI characteristics:</b><br/>
<i>Vendor: </i>@ViewBag.lblScsiVendor<br/>
<i>Product: </i>@ViewBag.lblScsiProduct<br/>
<i>Revision: </i>@ViewBag.lblScsiRevision<br/>
@foreach (string item in ViewBag.repScsi)
{
@Html.Raw(item)<br />
@Html.Raw(item)<br/>
}
@if(ViewBag.repModeSense != null)
@if (ViewBag.repModeSense != null)
{
<div id="divScsiModeSense">
<br /><i>SCSI mode sense pages:</i>
<br/><i>SCSI mode sense pages:</i>
<table border="1">
<tr>
<th>Mode</th>
<th>Contents</th>
</tr>
@foreach(KeyValuePair<string, string> kvp in ViewBag.repModeSense)
@foreach (KeyValuePair<string, string> kvp in ViewBag.repModeSense)
{
<tr>
<td>
@@ -140,16 +140,16 @@ DiscImageChef Report for
</table>
</div>
}
@if(ViewBag.repEvpd != null)
@if (ViewBag.repEvpd != null)
{
<div id="divScsiEvpd">
<br /><i>SCSI extended vital product data pages:</i>
<br/><i>SCSI extended vital product data pages:</i>
<table border="1">
<tr>
<th>EVPD</th>
<th>Contents</th>
</tr>
@foreach(KeyValuePair<string, string> kvp in ViewBag.repEvpd)
@foreach (KeyValuePair<string, string> kvp in ViewBag.repEvpd)
{
<tr>
<td>
@@ -163,66 +163,66 @@ DiscImageChef Report for
</table>
</div>
}
@if(ViewBag.repScsiMmcMode != null)
@if (ViewBag.repScsiMmcMode != null)
{
<div id="divScsiMmcMode">
<br /><b>SCSI CD-ROM capabilities:</b><br />
@foreach(string item in ViewBag.repScsiMmcMode)
<br/><b>SCSI CD-ROM capabilities:</b><br/>
@foreach (string item in ViewBag.repScsiMmcMode)
{
@Html.Raw(item)<br />
@Html.Raw(item)<br/>
}
</div>
}
@if(ViewBag.repScsiMmcFeatures != null)
@if (ViewBag.repScsiMmcFeatures != null)
{
<div id="divScsiMmcFeatures">
<br /><b>SCSI MMC features:</b><br />
@foreach(string item in ViewBag.repScsiMmcFeatures)
<br/><b>SCSI MMC features:</b><br/>
@foreach (string item in ViewBag.repScsiMmcFeatures)
{
@Html.Raw(item)<br />
@Html.Raw(item)<br/>
}
</div>
}
@if(ViewBag.divScsiSscVisible == true)
@if (ViewBag.divScsiSscVisible == true)
{
<div id="divScsiSsc">
<br /><b>SCSI Streaming device capabilities:</b><br />
Block size granularity: @ViewBag.lblScsiSscGranularity<br />
Maximum block length: @ViewBag.lblScsiSscMaxBlock bytes<br />
Minimum block length: @ViewBag.lblScsiSscMinBlock bytes<br />
@if(ViewBag.repScsiSscDensities != null)
<br/><b>SCSI Streaming device capabilities:</b><br/>
Block size granularity: @ViewBag.lblScsiSscGranularity<br/>
Maximum block length: @ViewBag.lblScsiSscMaxBlock bytes<br/>
Minimum block length: @ViewBag.lblScsiSscMinBlock bytes<br/>
@if (ViewBag.repScsiSscDensities != null)
{
foreach(SupportedDensity density in ViewBag.repScsiSscDensities)
foreach (SupportedDensity density in ViewBag.repScsiSscDensities)
{
<text>
<br />
<br/>
<b>
Information for supported density with primary code @($"{density.PrimaryCode:X2h}") and secondary code @($"{density.SecondaryCode:X2h}")
</b><br />
Drive can write this density: @density.Writable<br />
Duplicate density: @density.Duplicate<br />
Default density: @density.DefaultDensity<br />
</b><br/>
Drive can write this density: @density.Writable<br/>
Duplicate density: @density.Duplicate<br/>
Default density: @density.DefaultDensity<br/>
Density has @density.BitsPerMm bits per mm, with @density.Tracks tracks in a @density.Width mm width tape
Name: @density.Name<br />
Organization: @density.Organization<br />
Description: @density.Description<br />
Maximum capacity: @density.Capacity megabytes<br />
Name: @density.Name<br/>
Organization: @density.Organization<br/>
Description: @density.Description<br/>
Maximum capacity: @density.Capacity megabytes<br/>
</text>
}
}
@if(ViewBag.repScsiSscMedias != null)
@if (ViewBag.repScsiSscMedias != null)
{
foreach(SscSupportedMedia media in ViewBag.repScsiSscMedias)
foreach (SscSupportedMedia media in ViewBag.repScsiSscMedias)
{
<text>
<br />
<br/>
<b>
Information for supported media with type code @($"{media.MediumType:X2h}")
</b><br />
</b><br/>
Media is @media.Length m long in a @media.Width mm width tape
Name: @media.Name<br />
Organization: @media.Organization<br />
Description: @media.Description<br />
Name: @media.Name<br/>
Organization: @media.Organization<br/>
Description: @media.Description<br/>
</text>
}
}
@@ -230,35 +230,35 @@ DiscImageChef Report for
}
</div>
}
@if(ViewBag.repTestedMedia != null)
@if (ViewBag.repTestedMedia != null)
{
<div id="divTestedMedia">
<br /><b>Tested media:</b><br />
@foreach(string item in ViewBag.repTestedMedia)
<br/><b>Tested media:</b><br/>
@foreach (string item in ViewBag.repTestedMedia)
{
@Html.Raw(item)<br />
@Html.Raw(item)<br/>
}
</div>
}
@if(ViewBag.repMMC != null)
@if (ViewBag.repMMC != null)
{
<div id="divMMC">
<br />
<b>MultiMediaCard device:</b><br />
@foreach(string item in ViewBag.repMMC)
<br/>
<b>MultiMediaCard device:</b><br/>
@foreach (string item in ViewBag.repMMC)
{
@Html.Raw(item)<br />
@Html.Raw(item)<br/>
}
</div>
}
@if(ViewBag.repSD != null)
@if (ViewBag.repSD != null)
{
<div id="divSD">
<br />
<b>SecureDigital device:</b><br />
@foreach(string item in ViewBag.repSD)
<br/>
<b>SecureDigital device:</b><br/>
@foreach (string item in ViewBag.repSD)
{
@Html.Raw(item)<br />
@Html.Raw(item)<br/>
}
</div>
}

2
DiscImageChef.Server/Views/Shared/Error.cshtml
View File

@@ -22,4 +22,4 @@
It can result in displaying sensitive information from exceptions to end users.
For local debugging, enable the <strong>Development</strong> environment by setting the <strong>ASPNETCORE_ENVIRONMENT</strong> environment variable to <strong>Development</strong>
and restarting the app.
</p>
</p>

18
DiscImageChef.Server/Views/Shared/_Layout.cshtml
View File

@@ -35,23 +35,23 @@
<html>
<meta charset="UTF-8">
<head>
@switch(DateTime.UtcNow.DayOfYear)
@switch (DateTime.UtcNow.DayOfYear)
{
// 24th January, Macintosh launch
case 24:
<link href="~/css/mac/dicserver.css"
rel="stylesheet" type="text/css" />
rel="stylesheet" type="text/css"/>
<link href="~/css/mac/dicserver_highcharts.css"
rel="stylesheet" type="text/css" />
rel="stylesheet" type="text/css"/>
break;
default:
<link href="~/css/dos/dicserver.css"
rel="stylesheet" type="text/css" />
rel="stylesheet" type="text/css"/>
<link href="~/css/dos/dicserver_highcharts.css"
rel="stylesheet" type="text/css" />
rel="stylesheet" type="text/css"/>
break;
}
<meta charset="utf-8" />
<meta charset="utf-8"/>
<title>@ViewBag.Title</title>
<!-- Global site tag (gtag.js) - Google Analytics -->
<script async
@@ -73,8 +73,8 @@
<a href="http://www.claunia.com"
target="_blank">
Claunia.com
</a><br />
@switch(DateTime.UtcNow.DayOfYear)
</a><br/>
@switch (DateTime.UtcNow.DayOfYear)
{
// 24th January, Macintosh launch
case 24:
@@ -86,7 +86,7 @@
;
break;
}
<br />
<br/>
CSS © 2018-2019
<a href="https://getbootstrap.com/"
target="_blank">

2
DiscImageChef.Server/Views/Shared/_ValidationScriptsPartial.cshtml
View File

@@ -1,2 +1,2 @@
<script src="~/lib/jquery-validation/dist/jquery.validate.min.js"></script>
<script src="~/lib/jquery-validation-unobtrusive/jquery.validate.unobtrusive.min.js"></script>
<script src="~/lib/jquery-validation-unobtrusive/jquery.validate.unobtrusive.min.js"></script>

59
DiscImageChef.Server/Views/Stats/Index.cshtml
View File

@@ -1,9 +1,4 @@
@using System.Collections
@using DiscImageChef.CommonTypes.Metadata
@using DiscImageChef.Server.Models
@using Highsoft.Web.Mvc.Charts
@using Chart = Highsoft.Web.Mvc.Charts.Chart
@using Filter = DiscImageChef.Server.Models.Filter
@{
// /***************************************************************************
// The Disc Image Chef
@@ -51,7 +46,7 @@
</i> Server version @ViewBag.Version
</header>
<div class="container-fluid mt-3">
@if(ViewBag.repOperatingSystems != null)
@if (ViewBag.repOperatingSystems != null)
{
<div class="container"
id="divOperatingSystems">
@@ -129,7 +124,7 @@
id="osCollapse">
<div class="card-body">
<table class="table-dark">
@foreach(NameValueStats os in ViewBag.repOperatingSystems)
@foreach (NameValueStats os in ViewBag.repOperatingSystems)
{
<tr>
<td class="text-left">
@@ -142,10 +137,10 @@
</div>
</div>
</div>
<br />
<br/>
</div>
}
@if(ViewBag.repVersions != null)
@if (ViewBag.repVersions != null)
{
<div class="container mt-3"
id="divVersions">
@@ -175,7 +170,7 @@
id="versionsCollapse">
<div class="card-body">
<table class="table-dark">
@foreach(NameValueStats version in ViewBag.repVersions)
@foreach (NameValueStats version in ViewBag.repVersions)
{
<tr>
<td class="text-left">
@@ -188,10 +183,10 @@
</div>
</div>
</div>
<br />
<br/>
</div>
}
@if(ViewBag.repCommands != null)
@if (ViewBag.repCommands != null)
{
<div class="container mt-3"
id="divCommands">
@@ -221,7 +216,7 @@
id="commandsCollapse">
<div class="card-body">
<table class="table-dark">
@foreach(Command command in ViewBag.repCommands)
@foreach (Command command in ViewBag.repCommands)
{
<tr>
<td class="text-left">
@@ -234,10 +229,10 @@
</div>
</div>
</div>
<br />
<br/>
</div>
}
@if(ViewBag.repFilters != null)
@if (ViewBag.repFilters != null)
{
<div class="container mt-3"
id="divFilters">
@@ -271,7 +266,7 @@
<th class="table-dark-header">Filter</th>
<th class="table-dark-header">Times</th>
</tr>
@foreach(Filter filter in ViewBag.repFilters)
@foreach (Filter filter in ViewBag.repFilters)
{
<tr>
<td class="text-right">
@@ -289,7 +284,7 @@
</div>
</div>
}
@if(ViewBag.repMediaImages != null)
@if (ViewBag.repMediaImages != null)
{
<div class="container mt-3"
id="divMediaImages">
@@ -323,7 +318,7 @@
<th class="table-dark-header">Media image format</th>
<th class="table-dark-header">Times</th>
</tr>
@foreach(MediaFormat format in ViewBag.repMediaImages)
@foreach (MediaFormat format in ViewBag.repMediaImages)
{
<tr>
<td class="text-left">
@@ -341,7 +336,7 @@
</div>
</div>
}
@if(ViewBag.repPartitions != null)
@if (ViewBag.repPartitions != null)
{
<div class="container mt-3"
id="divPartitions">
@@ -375,7 +370,7 @@
<th class="table-dark-header">Partitioning scheme</th>
<th class="table-dark-header">Times</th>
</tr>
@foreach(Partition partition in ViewBag.repPartitions)
@foreach (Partition partition in ViewBag.repPartitions)
{
<tr>
<td class="text-left">
@@ -393,7 +388,7 @@
</div>
</div>
}
@if(ViewBag.repFilesystems != null)
@if (ViewBag.repFilesystems != null)
{
<div class="container mt-3"
id="divFilesystems">
@@ -427,7 +422,7 @@
<th class="table-dark-header">Filesystem name</th>
<th class="table-dark-header">Times</th>
</tr>
@foreach(Filesystem filesystem in ViewBag.repFilesystems)
@foreach (Filesystem filesystem in ViewBag.repFilesystems)
{
<tr>
<td class="text-left">
@@ -445,7 +440,7 @@
</div>
</div>
}
@if(ViewBag.repVirtualMedia != null)
@if (ViewBag.repVirtualMedia != null)
{
<div class="container mt-3"
id="divVirtualMedia">
@@ -480,7 +475,7 @@
<th class="table-dark-header">Logical type</th>
<th class="table-dark-header">Times</th>
</tr>
@foreach(MediaItem media in ViewBag.repVirtualMedia)
@foreach (MediaItem media in ViewBag.repVirtualMedia)
{
<tr>
<td class="text-left">
@@ -501,7 +496,7 @@
</div>
</div>
}
@if(ViewBag.repRealMedia != null)
@if (ViewBag.repRealMedia != null)
{
<div class="container mt-3"
id="divRealMedia">
@@ -536,7 +531,7 @@
<th class="table-dark-header">Logical type</th>
<th class="table-dark-header">Times</th>
</tr>
@foreach(MediaItem media in ViewBag.repRealMedia)
@foreach (MediaItem media in ViewBag.repRealMedia)
{
<tr>
<td class="text-left">
@@ -557,7 +552,7 @@
</div>
</div>
}
@if(ViewBag.repDevices != null)
@if (ViewBag.repDevices != null)
{
<div class="container mt-3"
id="divDevices">
@@ -623,7 +618,7 @@
<th class="table-dark-header">Bus</th>
<th class="table-dark-header">Report</th>
</tr>
@foreach(DeviceItem device in ViewBag.repDevices)
@foreach (DeviceItem device in ViewBag.repDevices)
{
<tr>
<td>
@@ -639,12 +634,14 @@
@device.Bus
</td>
<td>
@if(device.ReportId != 0)
@if (device.ReportId != 0)
{
<text>@Html.ActionLink("Yes", "View", "Report", new {id = device.ReportId}, new {target = "_blank"})</text>
}
else
{ <text>No</text> }
{
<text>No</text>
}
</td>
</tr>
}
@@ -657,7 +654,7 @@
<script src="http://code.highcharts.com/highcharts.js"></script>
<script src="https://code.highcharts.com/modules/exporting.js"></script>
@{
/* string highChartsTitleColor;
/* string highChartsTitleColor;
string highChartsDataLabelColor;
switch(DateTime.UtcNow.DayOfYear)

2
DiscImageChef.Server/Views/_ViewImports.cshtml
View File

@@ -1,3 +1,3 @@
@using DiscImageChef.Server
@using DiscImageChef.Server.Models
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers

2
DiscImageChef.Server/Views/_ViewStart.cshtml
View File

@@ -1,3 +1,3 @@
@{
Layout = "_Layout";
}
}