aaru-dps/Aaru.Server
1
0
Fork 0
mirror of https://github.com/aaru-dps/Aaru.Server.git synced 2025-12-16 19:24: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> /// <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) 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; string decoded;
if(evpd.page >= 0x01 && evpd.page <= 0x7F) decoded = EVPD.DecodeASCIIPage(evpd.value); 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 == 0x81) decoded = EVPD.PrettifyPage_81(evpd.value);
else if(evpd.page == 0x82) decoded = EVPD.DecodePage82(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 == 0x83) decoded = EVPD.PrettifyPage_83(evpd.value);
else if(evpd.page == 0x84) decoded = EVPD.PrettifyPage_84(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 == 0x85) decoded = EVPD.PrettifyPage_85(evpd.value);
else if(evpd.page == 0x86) decoded = EVPD.PrettifyPage_86(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 == 0x89) decoded = EVPD.PrettifyPage_89(evpd.value);
else if(evpd.page == 0xB0) decoded = EVPD.PrettifyPage_B0(evpd.value); else if (evpd.page == 0xB0) decoded = EVPD.PrettifyPage_B0(evpd.value);
else if(evpd.page == 0xB2) else if (evpd.page == 0xB2)
decoded = decoded =
$"TapeAlert Supported Flags Bitmap: 0x{EVPD.DecodePageB2(evpd.value):X16}<br/>"; $"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 == 0xB4) decoded = EVPD.DecodePageB4(evpd.value);
else if(evpd.page == 0xC0 && vendor.Trim() == "quantum") else if (evpd.page == 0xC0 && vendor.Trim() == "quantum")
decoded = EVPD.PrettifyPage_C0_Quantum(evpd.value); decoded = EVPD.PrettifyPage_C0_Quantum(evpd.value);
else if(evpd.page == 0xC0 && vendor.Trim() == "seagate") else if (evpd.page == 0xC0 && vendor.Trim() == "seagate")
decoded = decoded =
EVPD.PrettifyPage_C0_Seagate(evpd.value); 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); 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); 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); decoded = EVPD.PrettifyPage_C0_C1_Certance(evpd.value);
else if((evpd.page == 0xC2 || evpd.page == 0xC3 || evpd.page == 0xC4 || evpd.page == 0xC5 || else if ((evpd.page == 0xC2 || evpd.page == 0xC3 || evpd.page == 0xC4 || evpd.page == 0xC5 ||
evpd.page == 0xC6) && evpd.page == 0xC6) &&
vendor.Trim() == "certance") decoded = EVPD.PrettifyPage_C2_C3_C4_C5_C6_Certance(evpd.value); 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 || else if ((evpd.page == 0xC0 || evpd.page == 0xC1 || evpd.page == 0xC2 || evpd.page == 0xC3 ||
evpd.page == 0xC4 || evpd.page == 0xC5) && evpd.page == 0xC4 || evpd.page == 0xC5) &&
vendor.Trim() == "hp") decoded = EVPD.PrettifyPage_C0_to_C5_HP(evpd.value); vendor.Trim() == "hp") decoded = EVPD.PrettifyPage_C0_to_C5_HP(evpd.value);
else if(evpd.page == 0xDF && vendor.Trim() == "certance") else if (evpd.page == 0xDF && vendor.Trim() == "certance")
decoded = EVPD.PrettifyPage_DF_Certance(evpd.value); decoded = EVPD.PrettifyPage_DF_Certance(evpd.value);
else decoded = "Undecoded"; 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); 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 namespace DiscImageChef.Server
{ {
static class ScsiInquiry internal static class ScsiInquiry
{ {
/// <summary> /// <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 /// 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> /// <returns>List of values</returns>
internal static IEnumerable<string> Report(Inquiry.SCSIInquiry? inquiryNullable) 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: case PeripheralQualifiers.Supported:
scsiOneValue.Add("Device is connected and supported."); scsiOneValue.Add("Device is connected and supported.");
@@ -70,7 +70,7 @@ namespace DiscImageChef.Server
break; break;
} }
switch((PeripheralDeviceTypes)inquiry.PeripheralDeviceType) switch ((PeripheralDeviceTypes) inquiry.PeripheralDeviceType)
{ {
case PeripheralDeviceTypes.DirectAccess: //0x00, case PeripheralDeviceTypes.DirectAccess: //0x00,
scsiOneValue.Add("Direct-access device"); scsiOneValue.Add("Direct-access device");
@@ -146,7 +146,7 @@ namespace DiscImageChef.Server
break; break;
} }
switch((ANSIVersions)inquiry.ANSIVersion) switch ((ANSIVersions) inquiry.ANSIVersion)
{ {
case ANSIVersions.ANSINoVersion: case ANSIVersions.ANSINoVersion:
scsiOneValue.Add("Device does not claim to comply with any SCSI ANSI standard"); scsiOneValue.Add("Device does not claim to comply with any SCSI ANSI standard");
@@ -171,11 +171,12 @@ namespace DiscImageChef.Server
break; break;
default: default:
scsiOneValue 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; break;
} }
switch((ECMAVersions)inquiry.ECMAVersion) switch ((ECMAVersions) inquiry.ECMAVersion)
{ {
case ECMAVersions.ECMANoVersion: case ECMAVersions.ECMANoVersion:
scsiOneValue.Add("Device does not claim to comply with any SCSI ECMA standard"); scsiOneValue.Add("Device does not claim to comply with any SCSI ECMA standard");
@@ -185,11 +186,12 @@ namespace DiscImageChef.Server
break; break;
default: default:
scsiOneValue 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; break;
} }
switch((ISOVersions)inquiry.ISOVersion) switch ((ISOVersions) inquiry.ISOVersion)
{ {
case ISOVersions.ISONoVersion: case ISOVersions.ISONoVersion:
scsiOneValue.Add("Device does not claim to comply with any SCSI ISO/IEC standard"); scsiOneValue.Add("Device does not claim to comply with any SCSI ISO/IEC standard");
@@ -199,38 +201,39 @@ namespace DiscImageChef.Server
break; break;
default: default:
scsiOneValue 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; break;
} }
if(inquiry.RMB) scsiOneValue.Add("Device is removable"); if (inquiry.RMB) scsiOneValue.Add("Device is removable");
if(inquiry.AERC) scsiOneValue.Add("Device supports Asynchronous Event Reporting Capability"); if (inquiry.AERC) scsiOneValue.Add("Device supports Asynchronous Event Reporting Capability");
if(inquiry.TrmTsk) scsiOneValue.Add("Device supports TERMINATE TASK command"); if (inquiry.TrmTsk) scsiOneValue.Add("Device supports TERMINATE TASK command");
if(inquiry.NormACA) scsiOneValue.Add("Device supports setting Normal ACA"); if (inquiry.NormACA) scsiOneValue.Add("Device supports setting Normal ACA");
if(inquiry.HiSup) scsiOneValue.Add("Device supports LUN hierarchical addressing"); if (inquiry.HiSup) scsiOneValue.Add("Device supports LUN hierarchical addressing");
if(inquiry.SCCS) scsiOneValue.Add("Device contains an embedded storage array controller"); 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.ACC) scsiOneValue.Add("Device contains an Access Control Coordinator");
if(inquiry.ThreePC) scsiOneValue.Add("Device supports third-party copy commands"); if (inquiry.ThreePC) scsiOneValue.Add("Device supports third-party copy commands");
if(inquiry.Protect) scsiOneValue.Add("Device supports protection information"); if (inquiry.Protect) scsiOneValue.Add("Device supports protection information");
if(inquiry.BQue) scsiOneValue.Add("Device supports basic queueing"); if (inquiry.BQue) scsiOneValue.Add("Device supports basic queueing");
if(inquiry.EncServ) scsiOneValue.Add("Device contains an embedded enclosure services component"); if (inquiry.EncServ) scsiOneValue.Add("Device contains an embedded enclosure services component");
if(inquiry.MultiP) scsiOneValue.Add("Multi-port device"); if (inquiry.MultiP) scsiOneValue.Add("Multi-port device");
if(inquiry.MChngr) scsiOneValue.Add("Device contains or is attached to a medium changer"); 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.ACKREQQ) scsiOneValue.Add("Device supports request and acknowledge handshakes");
if(inquiry.Addr32) scsiOneValue.Add("Device supports 32-bit wide SCSI addresses"); 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.Addr16) scsiOneValue.Add("Device supports 16-bit wide SCSI addresses");
if(inquiry.RelAddr) scsiOneValue.Add("Device supports relative addressing"); if (inquiry.RelAddr) scsiOneValue.Add("Device supports relative addressing");
if(inquiry.WBus32) scsiOneValue.Add("Device supports 32-bit wide data transfers"); 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.WBus16) scsiOneValue.Add("Device supports 16-bit wide data transfers");
if(inquiry.Sync) scsiOneValue.Add("Device supports synchronous data transfer"); if (inquiry.Sync) scsiOneValue.Add("Device supports synchronous data transfer");
if(inquiry.Linked) scsiOneValue.Add("Device supports linked commands"); 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.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.QAS) scsiOneValue.Add("Device supports Quick Arbitration and Selection");
if(inquiry.CmdQue) scsiOneValue.Add("Device supports TCQ queue"); if (inquiry.CmdQue) scsiOneValue.Add("Device supports TCQ queue");
if(inquiry.IUS) scsiOneValue.Add("Device supports information unit transfers"); if (inquiry.IUS) scsiOneValue.Add("Device supports information unit transfers");
if(inquiry.SftRe) scsiOneValue.Add("Device implements RESET as a soft reset"); if (inquiry.SftRe) scsiOneValue.Add("Device implements RESET as a soft reset");
switch((TGPSValues)inquiry.TPGS) switch ((TGPSValues) inquiry.TPGS)
{ {
case TGPSValues.NotSupported: case TGPSValues.NotSupported:
scsiOneValue.Add("Device does not support assymetrical access"); scsiOneValue.Add("Device does not support assymetrical access");
@@ -249,7 +252,7 @@ namespace DiscImageChef.Server
break; break;
} }
switch((SPIClocking)inquiry.Clocking) switch ((SPIClocking) inquiry.Clocking)
{ {
case SPIClocking.ST: case SPIClocking.ST:
scsiOneValue.Add("Device supports only ST clocking"); scsiOneValue.Add("Device supports only ST clocking");
@@ -268,10 +271,10 @@ namespace DiscImageChef.Server
break; break;
} }
if(inquiry.VersionDescriptors == null) return scsiOneValue; if (inquiry.VersionDescriptors == null) return scsiOneValue;
foreach(ushort versionDescriptor in inquiry.VersionDescriptors) foreach (var versionDescriptor in inquiry.VersionDescriptors)
switch(versionDescriptor) switch (versionDescriptor)
{ {
case 0xFFFF: case 0xFFFF:
case 0x0000: break; case 0x0000: break;
@@ -403,11 +406,12 @@ namespace DiscImageChef.Server
break; break;
case 0x01DD: case 0x01DD:
scsiOneValue 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; break;
case 0x01DE: case 0x01DE:
scsiOneValue 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; break;
case 0x01E0: case 0x01E0:
scsiOneValue.Add("Device complies with SCC-2 (no version claimed)"); scsiOneValue.Add("Device complies with SCC-2 (no version claimed)");
@@ -744,7 +748,8 @@ namespace DiscImageChef.Server
break; break;
case 0x04E7: case 0x04E7:
scsiOneValue 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; break;
case 0x0500: case 0x0500:
scsiOneValue.Add("Device complies with ADC-3 (no version claimed)"); scsiOneValue.Add("Device complies with ADC-3 (no version claimed)");
@@ -1033,7 +1038,8 @@ namespace DiscImageChef.Server
break; break;
case 0x0ABC: case 0x0ABC:
scsiOneValue 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; break;
case 0x0AC0: case 0x0AC0:
scsiOneValue.Add("Device complies with Fast-20 (no version claimed)"); scsiOneValue.Add("Device complies with Fast-20 (no version claimed)");
@@ -1175,7 +1181,8 @@ namespace DiscImageChef.Server
break; break;
case 0x0C4F: case 0x0C4F:
scsiOneValue 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; break;
case 0x0C52: case 0x0C52:
scsiOneValue.Add("Device complies with SAS-2.1 ISO/IEC 14776-153"); scsiOneValue.Add("Device complies with SAS-2.1 ISO/IEC 14776-153");
@@ -1203,7 +1210,8 @@ namespace DiscImageChef.Server
break; break;
case 0x0D3C: case 0x0D3C:
scsiOneValue 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; break;
case 0x0D40: case 0x0D40:
scsiOneValue.Add("Device complies with FC-AL (no version claimed)"); scsiOneValue.Add("Device complies with FC-AL (no version claimed)");
@@ -1276,7 +1284,7 @@ namespace DiscImageChef.Server
break; break;
case 0x0E03: case 0x0E03:
scsiOneValue 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; break;
case 0x0E20: case 0x0E20:
scsiOneValue.Add("Device complies with FC-LS (no version claimed)"); scsiOneValue.Add("Device complies with FC-LS (no version claimed)");
@@ -1334,7 +1342,8 @@ namespace DiscImageChef.Server
break; break;
case 0x0EA6: case 0x0EA6:
scsiOneValue 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; break;
case 0x0EC0: case 0x0EC0:
scsiOneValue.Add("Device complies with FC-SP-2 (no version claimed)"); scsiOneValue.Add("Device complies with FC-SP-2 (no version claimed)");
@@ -1515,22 +1524,23 @@ namespace DiscImageChef.Server
break; break;
case 0x1621: case 0x1621:
scsiOneValue 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; break;
case 0x1622: case 0x1622:
scsiOneValue 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; break;
case 0x1623: case 0x1623:
scsiOneValue 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; break;
case 0x1628: case 0x1628:
scsiOneValue.Add("Device complies with ATA/ATAPI-8 ATA8-AAM ANSI INCITS 451-2008"); scsiOneValue.Add("Device complies with ATA/ATAPI-8 ATA8-AAM ANSI INCITS 451-2008");
break; break;
case 0x162A: case 0x162A:
scsiOneValue 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; break;
case 0x1728: case 0x1728:
scsiOneValue.Add("Device complies with Universal Serial Bus Specification, Revision 1.1"); scsiOneValue.Add("Device complies with Universal Serial Bus Specification, Revision 1.1");
@@ -1540,7 +1550,7 @@ namespace DiscImageChef.Server
break; break;
case 0x1730: case 0x1730:
scsiOneValue 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; break;
case 0x1740: case 0x1740:
scsiOneValue.Add("Device complies with UAS (no version claimed)"); 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> /// <param name="mmcOneValue">List to put the values on</param>
public static void Report(MmcFeatures ftr, ref List<string> mmcOneValue) 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}"); mmcOneValue.Add($"Drive supports AACS version {ftr.AACSVersion}");
else if(ftr.SupportsAACS) mmcOneValue.Add("Drive supports AACS"); else if (ftr.SupportsAACS) mmcOneValue.Add("Drive supports AACS");
if(ftr.AGIDs.HasValue) mmcOneValue.Add($"Drive supports {ftr.AGIDs} AGIDs concurrently"); if (ftr.AGIDs.HasValue) mmcOneValue.Add($"Drive supports {ftr.AGIDs} AGIDs concurrently");
if(ftr.CanGenerateBindingNonce) if (ftr.CanGenerateBindingNonce)
{ {
mmcOneValue.Add("Drive supports generating the binding nonce"); 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"); 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"); mmcOneValue.Add($"{ftr.BlocksPerReadableUnit} logical blocks per media writable unit");
if(ftr.BufferUnderrunFreeInDVD) mmcOneValue.Add("Drive supports zero loss linking writing DVDs"); 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.BufferUnderrunFreeInSAO)
if(ftr.BufferUnderrunFreeInTAO) mmcOneValue.Add("Drive supports zero loss linking in Track at Once Mode"); mmcOneValue.Add("Drive supports zero loss linking in Session at Once Mode");
if(ftr.CanAudioScan) mmcOneValue.Add("Drive supports the SCAN command"); if (ftr.BufferUnderrunFreeInTAO) mmcOneValue.Add("Drive supports zero loss linking in Track at Once Mode");
if(ftr.CanEject) mmcOneValue.Add("Drive can eject media"); if (ftr.CanAudioScan) mmcOneValue.Add("Drive supports the SCAN command");
if(ftr.CanEraseSector) mmcOneValue.Add("Drive supports media that require erasing before writing"); if (ftr.CanEject) mmcOneValue.Add("Drive can eject media");
if(ftr.CanExpandBDRESpareArea) mmcOneValue.Add("Drive can expand the spare area on a formatted BD-RE disc"); if (ftr.CanEraseSector) mmcOneValue.Add("Drive supports media that require erasing before writing");
if(ftr.CanFormat) mmcOneValue.Add("Drive can format media into logical blocks"); if (ftr.CanExpandBDRESpareArea)
if(ftr.CanFormatBDREWithoutSpare) mmcOneValue.Add("Drive can format BD-RE with no spares allocated"); mmcOneValue.Add("Drive can expand the spare area on a formatted BD-RE disc");
if(ftr.CanFormatQCert) mmcOneValue.Add("Drive can format BD-RE discs with quick certification"); if (ftr.CanFormat) mmcOneValue.Add("Drive can format media into logical blocks");
if(ftr.CanFormatCert) mmcOneValue.Add("Drive can format BD-RE discs with full certification"); if (ftr.CanFormatBDREWithoutSpare) mmcOneValue.Add("Drive can format BD-RE with no spares allocated");
if(ftr.CanFormatFRF) mmcOneValue.Add("Drive can fast re-format BD-RE discs"); if (ftr.CanFormatQCert) mmcOneValue.Add("Drive can format BD-RE discs with quick certification");
if(ftr.CanFormatRRM) mmcOneValue.Add("Drive can format BD-R discs with RRM format"); if (ftr.CanFormatCert) mmcOneValue.Add("Drive can format BD-RE discs with full certification");
if(ftr.CanLoad) mmcOneValue.Add("Drive can load media"); if (ftr.CanFormatFRF) mmcOneValue.Add("Drive can fast re-format BD-RE discs");
if(ftr.CanMuteSeparateChannels) mmcOneValue.Add("Drive is able to mute channels separately"); if (ftr.CanFormatRRM) mmcOneValue.Add("Drive can format BD-R discs with RRM format");
if(ftr.CanOverwriteSAOTrack) mmcOneValue.Add("Drive can overwrite a SAO track with another in CD-RWs"); if (ftr.CanLoad) mmcOneValue.Add("Drive can load media");
if(ftr.CanOverwriteTAOTrack) mmcOneValue.Add("Drive can overwrite a TAO track with another in CD-RWs"); if (ftr.CanMuteSeparateChannels) mmcOneValue.Add("Drive is able to mute channels separately");
if(ftr.CanPlayCDAudio) mmcOneValue.Add("Drive has an analogue audio output"); if (ftr.CanOverwriteSAOTrack) mmcOneValue.Add("Drive can overwrite a SAO track with another in CD-RWs");
if(ftr.CanPseudoOverwriteBDR) mmcOneValue.Add("Drive can write BD-R on Pseudo-OVerwrite SRM mode"); if (ftr.CanOverwriteTAOTrack) mmcOneValue.Add("Drive can overwrite a TAO track with another in CD-RWs");
if(ftr.CanReadAllDualR) mmcOneValue.Add("Drive can read DVD-R DL from all recording modes"); if (ftr.CanPlayCDAudio) mmcOneValue.Add("Drive has an analogue audio output");
if(ftr.CanReadAllDualRW) mmcOneValue.Add("Drive can read DVD-RW DL from all recording modes"); if (ftr.CanPseudoOverwriteBDR) mmcOneValue.Add("Drive can write BD-R on Pseudo-OVerwrite SRM mode");
if(ftr.CanReadBD) mmcOneValue.Add("Drive can read BD-ROM"); if (ftr.CanReadAllDualR) mmcOneValue.Add("Drive can read DVD-R DL from all recording modes");
if(ftr.CanReadBDR) mmcOneValue.Add("Drive can read BD-R Ver.1"); if (ftr.CanReadAllDualRW) mmcOneValue.Add("Drive can read DVD-RW DL from all recording modes");
if(ftr.CanReadBDRE1) mmcOneValue.Add("Drive can read BD-RE Ver.1"); if (ftr.CanReadBD) mmcOneValue.Add("Drive can read BD-ROM");
if(ftr.CanReadBDRE2) mmcOneValue.Add("Drive can read BD-RE Ver.2"); if (ftr.CanReadBDR) mmcOneValue.Add("Drive can read BD-R Ver.1");
if(ftr.CanReadBDROM) mmcOneValue.Add("Drive can read BD-ROM Ver.1"); if (ftr.CanReadBDRE1) mmcOneValue.Add("Drive can read BD-RE Ver.1");
if(ftr.CanReadBluBCA) mmcOneValue.Add("Drive can read BD's Burst Cutting Area"); if (ftr.CanReadBDRE2) mmcOneValue.Add("Drive can read BD-RE Ver.2");
if(ftr.CanReadCD) mmcOneValue.Add("Drive can read CD-ROM"); if (ftr.CanReadBDROM) mmcOneValue.Add("Drive can read BD-ROM Ver.1");
if(ftr.CanWriteCDMRW && ftr.CanReadDVDPlusMRW && ftr.CanWriteDVDPlusMRW) 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"); 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"); 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"); 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.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.CanReadDVDPlusMRW) mmcOneValue.Add("Drive can read CD-MRW and DVD+MRW");
else if(ftr.CanReadCDMRW) mmcOneValue.Add("Drive can read CD-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.CanReadCPRM_MKB) mmcOneValue.Add("Drive supports reading Media Key Block of CPRM");
if(ftr.CanReadDDCD) mmcOneValue.Add("Drive can read DDCDs"); if (ftr.CanReadDDCD) mmcOneValue.Add("Drive can read DDCDs");
if(ftr.CanReadDVD) mmcOneValue.Add("Drive can read DVD"); if (ftr.CanReadDVD) mmcOneValue.Add("Drive can read DVD");
if(ftr.CanWriteDVDPlusRW) mmcOneValue.Add("Drive can read and write DVD+RW"); if (ftr.CanWriteDVDPlusRW) mmcOneValue.Add("Drive can read and write DVD+RW");
else if(ftr.CanReadDVDPlusRW) mmcOneValue.Add("Drive can read 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"); if (ftr.CanWriteDVDPlusR) mmcOneValue.Add("Drive can read and write DVD+R");
else if(ftr.CanReadDVDPlusR) mmcOneValue.Add("Drive can read 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"); 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"); 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.CanReadDriveAACSCertificate) mmcOneValue.Add("Drive supports reading the Drive Certificate");
if(ftr.CanReadHDDVD && ftr.CanReadHDDVDR && ftr.CanReadHDDVDRAM) 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"); 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"); 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"); 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"); 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.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.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.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.CanReadOldBDROM) mmcOneValue.Add("Drive can read BD-ROM pre-1.0");
if(ftr.CanReadSpareAreaInformation) mmcOneValue.Add("Drive can return Spare Area Information"); 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.CanReportDriveSerial) mmcOneValue.Add("Drive is to report drive serial number");
if(ftr.CanReportMediaSerial) mmcOneValue.Add("Drive is to read media 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.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.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.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.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.CanUpgradeFirmware) mmcOneValue.Add("Drive supports Microcode Upgrade");
if(ftr.ErrorRecoveryPage) mmcOneValue.Add("Drive shall report Read/Write Error Recovery mode page"); 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.Locked) mmcOneValue.Add("Drive can lock media");
if(ftr.LogicalBlockSize > 0) mmcOneValue.Add($"{ftr.LogicalBlockSize} bytes per logical block"); if (ftr.LogicalBlockSize > 0) mmcOneValue.Add($"{ftr.LogicalBlockSize} bytes per logical block");
if(ftr.MultiRead) if (ftr.MultiRead)
mmcOneValue.Add("Drive claims capability to read all CD formats according to OSTA Multi-Read Specification"); mmcOneValue.Add(
"Drive claims capability to read all CD formats according to OSTA Multi-Read Specification");
if(ftr.PhysicalInterfaceStandard.HasValue) if (ftr.PhysicalInterfaceStandard.HasValue)
switch(ftr.PhysicalInterfaceStandard) switch (ftr.PhysicalInterfaceStandard)
{ {
case PhysicalInterfaces.Unspecified: case PhysicalInterfaces.Unspecified:
mmcOneValue.Add("Drive uses an unspecified physical interface"); mmcOneValue.Add("Drive uses an unspecified physical interface");
@@ -166,86 +169,86 @@ namespace DiscImageChef.Server
break; break;
default: default:
mmcOneValue mmcOneValue
.Add($"Drive uses an unknown interface with code {(uint)ftr.PhysicalInterfaceStandard}"); .Add($"Drive uses an unknown interface with code {(uint) ftr.PhysicalInterfaceStandard}");
break; break;
} }
if(ftr.PreventJumper) mmcOneValue.Add("Drive power ups locked"); if (ftr.PreventJumper) mmcOneValue.Add("Drive power ups locked");
if(ftr.SupportsBusEncryption) mmcOneValue.Add("Drive supports bus encryption"); if (ftr.SupportsBusEncryption) mmcOneValue.Add("Drive supports bus encryption");
if(ftr.CanWriteBD) mmcOneValue.Add("Drive can write BD-R or BD-RE"); 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.CanWriteBDR) mmcOneValue.Add("Drive can write BD-R Ver.1");
if(ftr.CanWriteBDRE1) mmcOneValue.Add("Drive can write BD-RE 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.CanWriteBDRE2) mmcOneValue.Add("Drive can write BD-RE Ver.2");
if(ftr.CanWriteBusEncryptedBlocks) mmcOneValue.Add("Drive supports writing with bus encryption"); if (ftr.CanWriteBusEncryptedBlocks) mmcOneValue.Add("Drive supports writing with bus encryption");
if(ftr.CanWriteCDRW) mmcOneValue.Add("Drive can write CD-RW"); if (ftr.CanWriteCDRW) mmcOneValue.Add("Drive can write CD-RW");
if(ftr.CanWriteCDRWCAV) mmcOneValue.Add("Drive can write High-Speed CD-RW"); if (ftr.CanWriteCDRWCAV) mmcOneValue.Add("Drive can write High-Speed CD-RW");
if(ftr.CanWriteCDSAO && !ftr.CanWriteRaw) if (ftr.CanWriteCDSAO && !ftr.CanWriteRaw)
mmcOneValue.Add("Drive can write CDs in Session at Once Mode:"); 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) 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 Session at Once and in Raw Modes:"); 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.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.CanWriteCSSManagedDVD) mmcOneValue.Add("Drive can write CSS managed DVDs");
if(ftr.CanWriteDDCDR) mmcOneValue.Add("Drive supports writing DDCD-R"); if (ftr.CanWriteDDCDR) mmcOneValue.Add("Drive supports writing DDCD-R");
if(ftr.CanWriteDDCDRW) mmcOneValue.Add("Drive supports writing DDCD-RW"); if (ftr.CanWriteDDCDRW) mmcOneValue.Add("Drive supports writing DDCD-RW");
if(ftr.CanWriteDVDPlusRWDL) mmcOneValue.Add("Drive can read and write DVD+RW DL"); 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"); else if (ftr.CanReadDVDPlusRWDL) mmcOneValue.Add("Drive can read DVD+RW DL");
if(ftr.CanWriteDVDR && ftr.CanWriteDVDRW && ftr.CanWriteDVDRDL) if (ftr.CanWriteDVDR && ftr.CanWriteDVDRW && ftr.CanWriteDVDRDL)
mmcOneValue.Add("Drive supports writing DVD-R, DVD-RW and DVD-R DL"); 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"); 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 && ftr.CanWriteDVDRW) mmcOneValue.Add("Drive supports writing DVD-R and DVD-RW");
else if(ftr.CanWriteDVDR) mmcOneValue.Add("Drive supports writing DVD-R"); else if (ftr.CanWriteDVDR) mmcOneValue.Add("Drive supports writing DVD-R");
if(ftr.CanWriteHDDVDR && ftr.CanWriteHDDVDRAM) if (ftr.CanWriteHDDVDR && ftr.CanWriteHDDVDRAM)
mmcOneValue.Add("Drive can write HD DVD-RW, HD DVD-R and HD DVD-RAM"); 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.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.CanWriteHDDVDRAM) mmcOneValue.Add("Drive can write HD DVD-RW and HD DVD-RAM");
// TODO: Write HD DVD-RW // TODO: Write HD DVD-RW
/* /*
else else
mmcOneValue.Add("Drive can write HD DVD-RW"); mmcOneValue.Add("Drive can write HD DVD-RW");
*/ */
if(ftr.CanWriteOldBDR) mmcOneValue.Add("Drive can write BD-R pre-1.0"); 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.CanWriteOldBDRE) mmcOneValue.Add("Drive can write BD-RE pre-1.0");
if(ftr.CanWriteRWSubchannelInTAO) if (ftr.CanWriteRWSubchannelInTAO)
{ {
mmcOneValue.Add("Drive can write user provided data in the R-W subchannels in Track at Once Mode"); 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"); 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"); 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"); 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"); mmcOneValue.Add("Drive can write multi-session CDs in raw mode");
if(ftr.EmbeddedChanger) if (ftr.EmbeddedChanger)
{ {
mmcOneValue.Add("Drive contains an embedded changer"); mmcOneValue.Add("Drive contains an embedded changer");
if(ftr.ChangerIsSideChangeCapable) mmcOneValue.Add("Drive can change disc side"); if (ftr.ChangerIsSideChangeCapable) mmcOneValue.Add("Drive can change disc side");
if(ftr.ChangerSupportsDiscPresent) if (ftr.ChangerSupportsDiscPresent)
mmcOneValue.Add("Drive is able to report slots contents after a reset or change"); mmcOneValue.Add("Drive is able to report slots contents after a reset or change");
mmcOneValue.Add($"Drive has {ftr.ChangerSlots + 1} slots"); 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}"); mmcOneValue.Add($"Drive supports DVD CSS/CPPM version {ftr.CSSVersion}");
else if(ftr.SupportsCSS) mmcOneValue.Add("Drive supports DVD CSS/CPRM"); else if (ftr.SupportsCSS) mmcOneValue.Add("Drive supports DVD CSS/CPRM");
if(ftr.SupportsCPRM && ftr.CPRMVersion.HasValue) if (ftr.SupportsCPRM && ftr.CPRMVersion.HasValue)
mmcOneValue.Add($"Drive supports DVD CPPM version {ftr.CPRMVersion}"); mmcOneValue.Add($"Drive supports DVD CPPM version {ftr.CPRMVersion}");
else if(ftr.SupportsCPRM) mmcOneValue.Add("Drive supports DVD CPRM"); 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.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.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.FirmwareDate.HasValue) mmcOneValue.Add($"Drive firmware is dated {ftr.FirmwareDate}");
if(ftr.SupportsC2) mmcOneValue.Add("Drive supports C2 Error Pointers"); 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.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.SupportsDeviceBusyEvent) mmcOneValue.Add("Drive supports Device Busy events");
if(ftr.LoadingMechanismType.HasValue) if (ftr.LoadingMechanismType.HasValue)
switch(ftr.LoadingMechanismType) switch (ftr.LoadingMechanismType)
{ {
case 0: case 0:
mmcOneValue.Add("Drive uses media caddy"); mmcOneValue.Add("Drive uses media caddy");
@@ -267,20 +270,20 @@ namespace DiscImageChef.Server
break; break;
} }
if(ftr.SupportsHybridDiscs) mmcOneValue.Add("Drive is able to access Hybrid discs"); if (ftr.SupportsHybridDiscs) mmcOneValue.Add("Drive is able to access Hybrid discs");
if(ftr.SupportsModePage1Ch) if (ftr.SupportsModePage1Ch)
mmcOneValue.Add("Drive supports the Informational Exceptions Control mode page 1Ch"); 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"); 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.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.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.SupportsSecurDisc) mmcOneValue.Add("Drive supports SecurDisc");
if(ftr.SupportsSeparateVolume) mmcOneValue.Add("Drive supports separate volume per channel"); if (ftr.SupportsSeparateVolume) mmcOneValue.Add("Drive supports separate volume per channel");
if(ftr.SupportsVCPS) mmcOneValue.Add("Drive supports VCPS"); if (ftr.SupportsVCPS) mmcOneValue.Add("Drive supports VCPS");
if(ftr.VolumeLevels.HasValue) mmcOneValue.Add($"Drive has {ftr.VolumeLevels + 1} volume levels"); if (ftr.VolumeLevels.HasValue) mmcOneValue.Add($"Drive has {ftr.VolumeLevels + 1} volume levels");
if(ftr.SupportsWriteProtectPAC) if (ftr.SupportsWriteProtectPAC)
mmcOneValue.Add("Drive supports reading/writing the Disc Write Protect PAC on BD-R/-RE media"); 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.Add("Drive supports writing the Write Inhibit DCB on DVD+RW media");
mmcOneValue.Sort(); 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> /// <param name="mmcOneValue">List to put the values on</param>
public static void Report(Modes.ModePage_2A mode, ref List<string> mmcOneValue) public static void Report(Modes.ModePage_2A mode, ref List<string> mmcOneValue)
{ {
if(mode.AudioPlay) mmcOneValue.Add("Drive can play audio"); 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.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.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.MultiSession) mmcOneValue.Add("Drive supports multi-session discs and/or Photo-CD");
if(mode.CDDACommand) mmcOneValue.Add("Drive can read digital audio"); if (mode.CDDACommand) mmcOneValue.Add("Drive can read digital audio");
if(mode.AccurateCDDA) mmcOneValue.Add("Drive can continue from streaming loss"); 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.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.DeinterlaveSubchannel) mmcOneValue.Add("Drive can read, deinterleave and correct R-W subchannels");
if(mode.C2Pointer) mmcOneValue.Add("Drive supports C2 pointers"); if (mode.C2Pointer) mmcOneValue.Add("Drive supports C2 pointers");
if(mode.UPC) mmcOneValue.Add("Drive can read Media Catalogue Number"); if (mode.UPC) mmcOneValue.Add("Drive can read Media Catalogue Number");
if(mode.ISRC) mmcOneValue.Add("Drive can read ISRC"); if (mode.ISRC) mmcOneValue.Add("Drive can read ISRC");
switch(mode.LoadingMechanism) switch (mode.LoadingMechanism)
{ {
case 0: case 0:
mmcOneValue.Add("Drive uses media caddy"); mmcOneValue.Add("Drive uses media caddy");
@@ -81,89 +81,93 @@ namespace DiscImageChef.Server
break; break;
} }
if(mode.Lock) mmcOneValue.Add("Drive can lock media"); if (mode.Lock) mmcOneValue.Add("Drive can lock media");
if(mode.PreventJumper) if (mode.PreventJumper)
{ {
mmcOneValue.Add("Drive power ups locked"); mmcOneValue.Add("Drive power ups locked");
mmcOneValue.Add(mode.LockState mmcOneValue.Add(mode.LockState
? "Drive is locked, media cannot be ejected or inserted" ? "Drive is locked, media cannot be ejected or inserted"
: "Drive is not locked, media can be ejected and inserted"); : "Drive is not locked, media can be ejected and inserted");
} }
else else
{
mmcOneValue.Add(mode.LockState mmcOneValue.Add(mode.LockState
? "Drive is locked, media cannot be ejected, but if empty, can be inserted" ? "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 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.SeparateChannelMute) mmcOneValue.Add("Each channel can be muted independently");
if(mode.SeparateChannelVolume) mmcOneValue.Add("Each channel's volume can be controlled 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"); mmcOneValue.Add($"Drive supports {mode.SupportedVolumeLevels} volume levels");
if(mode.BufferSize > 0) mmcOneValue.Add($"Drive has {mode.BufferSize} Kbyte of buffer"); if (mode.BufferSize > 0) mmcOneValue.Add($"Drive has {mode.BufferSize} Kbyte of buffer");
if(mode.MaximumSpeed > 0) if (mode.MaximumSpeed > 0)
mmcOneValue.Add($"Drive's maximum reading speed is {mode.MaximumSpeed} Kbyte/sec."); 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."); 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"); 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"); 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.ReadDVDROM) mmcOneValue.Add("Drive can read DVD-ROM");
if(mode.ReadDVDR) if (mode.ReadDVDR)
mmcOneValue.Add(mode.WriteDVDR ? "Drive can read and write DVD-R" : "Drive can read DVD-R"); 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"); 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.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.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.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.SDP) mmcOneValue.Add("Drive contains a changer that can report the exact contents of the slots");
if(mode.CurrentWriteSpeedSelected > 0) if (mode.CurrentWriteSpeedSelected > 0)
{ {
if(mode.RotationControlSelected == 0) if (mode.RotationControlSelected == 0)
mmcOneValue mmcOneValue
.Add($"Drive's current writing speed is {mode.CurrentWriteSpeedSelected} Kbyte/sec. in CLV mode"); .Add(
else if(mode.RotationControlSelected == 1) $"Drive's current writing speed is {mode.CurrentWriteSpeedSelected} Kbyte/sec. in CLV mode");
else if (mode.RotationControlSelected == 1)
mmcOneValue 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 else
{ {
if(mode.MaxWriteSpeed > 0) if (mode.MaxWriteSpeed > 0)
mmcOneValue.Add($"Drive's maximum writing speed is {mode.MaxWriteSpeed} Kbyte/sec."); 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."); mmcOneValue.Add($"Drive's current writing speed is {mode.CurrentWriteSpeed} Kbyte/sec.");
} }
if(mode.WriteSpeedPerformanceDescriptors != null) if (mode.WriteSpeedPerformanceDescriptors != null)
foreach(Modes.ModePage_2A_WriteDescriptor descriptor in foreach (var descriptor in
mode.WriteSpeedPerformanceDescriptors.Where(descriptor => descriptor.WriteSpeed > 0)) 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"); mmcOneValue.Add($"Drive supports writing at {descriptor.WriteSpeed} Kbyte/sec. in CLV mode");
else if(descriptor.RotationControl == 1) else if (descriptor.RotationControl == 1)
mmcOneValue 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.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.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.Sort();
mmcOneValue.Add(""); 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="deviceType">SCSI peripheral device type</param>
/// <param name="scsiOneValue">List to put values on</param> /// <param name="scsiOneValue">List to put values on</param>
/// <param name="modePages">List to put key=value pairs on</param> /// <param name="modePages">List to put key=value pairs on</param>
public static void Report(ScsiMode modeSense, string vendor, public static void Report(ScsiMode modeSense, string vendor,
PeripheralDeviceTypes deviceType, PeripheralDeviceTypes deviceType,
ref List<string> scsiOneValue, ref Dictionary<string, string> modePages) ref List<string> scsiOneValue, ref Dictionary<string, string> modePages)
{ {
if(modeSense.MediumType.HasValue) scsiOneValue.Add($"Medium type is {modeSense.MediumType:X2}h"); if (modeSense.MediumType.HasValue) scsiOneValue.Add($"Medium type is {modeSense.MediumType:X2}h");
if(modeSense.WriteProtected) scsiOneValue.Add("Device is write protected."); if (modeSense.WriteProtected) scsiOneValue.Add("Device is write protected.");
if(modeSense.BlockDescriptors != null) if (modeSense.BlockDescriptors != null)
foreach(BlockDescriptor descriptor in modeSense.BlockDescriptors) foreach (var descriptor in modeSense.BlockDescriptors)
if(descriptor.Blocks.HasValue && descriptor.BlockLength.HasValue) if (descriptor.Blocks.HasValue && descriptor.BlockLength.HasValue)
scsiOneValue 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 else
scsiOneValue.Add($"Density code {descriptor.Density:X2}h"); scsiOneValue.Add($"Density code {descriptor.Density:X2}h");
if(modeSense.DPOandFUA) scsiOneValue.Add("Drive supports DPO and FUA bits"); if (modeSense.DPOandFUA) scsiOneValue.Add("Drive supports DPO and FUA bits");
if(modeSense.BlankCheckEnabled) scsiOneValue.Add("Blank checking during write is enabled"); if (modeSense.BlankCheckEnabled) scsiOneValue.Add("Blank checking during write is enabled");
if(modeSense.BufferedMode.HasValue) if (modeSense.BufferedMode.HasValue)
switch(modeSense.BufferedMode) switch (modeSense.BufferedMode)
{ {
case 0: case 0:
scsiOneValue.Add("Device writes directly to media"); scsiOneValue.Add("Device writes directly to media");
@@ -80,35 +81,38 @@ namespace DiscImageChef.Server
break; break;
} }
if(modeSense.ModePages == null) return; if (modeSense.ModePages == null) return;
foreach(ScsiPage page in modeSense.ModePages) foreach (var page in modeSense.ModePages)
switch(page.page) switch (page.page)
{ {
case 0x00: 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)); modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_00_SFF(page.value));
else else
modePages 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"); "Unknown vendor mode page");
break; break;
} }
case 0x01: case 0x01:
{ {
if(page.subpage == 0) if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", modePages.Add($"MODE page {page.page:X2}h",
deviceType == PeripheralDeviceTypes.MultiMediaDevice deviceType == PeripheralDeviceTypes.MultiMediaDevice
? Modes.PrettifyModePage_01_MMC(page.value) ? Modes.PrettifyModePage_01_MMC(page.value)
: Modes.PrettifyModePage_01(page.value)); : Modes.PrettifyModePage_01(page.value));
else goto default; else goto default;
break; break;
} }
case 0x02: case 0x02:
{ {
if(page.subpage == 0) if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_02(page.value)); modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_02(page.value));
else goto default; else goto default;
@@ -116,7 +120,7 @@ namespace DiscImageChef.Server
} }
case 0x03: case 0x03:
{ {
if(page.subpage == 0) if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_03(page.value)); modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_03(page.value));
else goto default; else goto default;
@@ -124,7 +128,7 @@ namespace DiscImageChef.Server
} }
case 0x04: case 0x04:
{ {
if(page.subpage == 0) if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_04(page.value)); modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_04(page.value));
else goto default; else goto default;
@@ -132,7 +136,7 @@ namespace DiscImageChef.Server
} }
case 0x05: case 0x05:
{ {
if(page.subpage == 0) if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_05(page.value)); modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_05(page.value));
else goto default; else goto default;
@@ -140,7 +144,7 @@ namespace DiscImageChef.Server
} }
case 0x06: case 0x06:
{ {
if(page.subpage == 0) if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_06(page.value)); modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_06(page.value));
else goto default; else goto default;
@@ -148,18 +152,18 @@ namespace DiscImageChef.Server
} }
case 0x07: case 0x07:
{ {
if(page.subpage == 0) if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", modePages.Add($"MODE page {page.page:X2}h",
deviceType == PeripheralDeviceTypes.MultiMediaDevice deviceType == PeripheralDeviceTypes.MultiMediaDevice
? Modes.PrettifyModePage_07_MMC(page.value) ? Modes.PrettifyModePage_07_MMC(page.value)
: Modes.PrettifyModePage_07(page.value)); : Modes.PrettifyModePage_07(page.value));
else goto default; else goto default;
break; break;
} }
case 0x08: case 0x08:
{ {
if(page.subpage == 0) if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_08(page.value)); modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_08(page.value));
else goto default; else goto default;
@@ -167,18 +171,18 @@ namespace DiscImageChef.Server
} }
case 0x0A: case 0x0A:
{ {
if(page.subpage == 0) if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_0A(page.value)); 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", 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; else goto default;
break; break;
} }
case 0x0B: case 0x0B:
{ {
if(page.subpage == 0) if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_0B(page.value)); modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_0B(page.value));
else goto default; else goto default;
@@ -186,7 +190,7 @@ namespace DiscImageChef.Server
} }
case 0x0D: case 0x0D:
{ {
if(page.subpage == 0) if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_0D(page.value)); modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_0D(page.value));
else goto default; else goto default;
@@ -194,7 +198,7 @@ namespace DiscImageChef.Server
} }
case 0x0E: case 0x0E:
{ {
if(page.subpage == 0) if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_0E(page.value)); modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_0E(page.value));
else goto default; else goto default;
@@ -202,7 +206,7 @@ namespace DiscImageChef.Server
} }
case 0x0F: case 0x0F:
{ {
if(page.subpage == 0) if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_0F(page.value)); modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_0F(page.value));
else goto default; else goto default;
@@ -210,18 +214,18 @@ namespace DiscImageChef.Server
} }
case 0x10: case 0x10:
{ {
if(page.subpage == 0) if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", modePages.Add($"MODE page {page.page:X2}h",
deviceType == PeripheralDeviceTypes.SequentialAccess deviceType == PeripheralDeviceTypes.SequentialAccess
? Modes.PrettifyModePage_10_SSC(page.value) ? Modes.PrettifyModePage_10_SSC(page.value)
: Modes.PrettifyModePage_10(page.value)); : Modes.PrettifyModePage_10(page.value));
else goto default; else goto default;
break; break;
} }
case 0x11: case 0x11:
{ {
if(page.subpage == 0) if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_11(page.value)); modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_11(page.value));
else goto default; else goto default;
@@ -231,7 +235,7 @@ namespace DiscImageChef.Server
case 0x13: case 0x13:
case 0x14: 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)); modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_12_13_14(page.value));
else goto default; else goto default;
@@ -239,18 +243,18 @@ namespace DiscImageChef.Server
} }
case 0x1A: case 0x1A:
{ {
if(page.subpage == 0) if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_1A(page.value)); 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", 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; else goto default;
break; break;
} }
case 0x1B: case 0x1B:
{ {
if(page.subpage == 0) if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_1B(page.value)); modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_1B(page.value));
else goto default; else goto default;
@@ -258,21 +262,21 @@ namespace DiscImageChef.Server
} }
case 0x1C: case 0x1C:
{ {
if(page.subpage == 0) if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", modePages.Add($"MODE page {page.page:X2}h",
deviceType == PeripheralDeviceTypes.MultiMediaDevice deviceType == PeripheralDeviceTypes.MultiMediaDevice
? Modes.PrettifyModePage_1C_SFF(page.value) ? Modes.PrettifyModePage_1C_SFF(page.value)
: Modes.PrettifyModePage_1C(page.value)); : Modes.PrettifyModePage_1C(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", 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; else goto default;
break; break;
} }
case 0x1D: case 0x1D:
{ {
if(page.subpage == 0) if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_1D(page.value)); modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_1D(page.value));
else goto default; else goto default;
@@ -280,7 +284,7 @@ namespace DiscImageChef.Server
} }
case 0x21: case 0x21:
{ {
if(vendor == "CERTANCE") if (vendor == "CERTANCE")
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyCertanceModePage_21(page.value)); modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyCertanceModePage_21(page.value));
else goto default; else goto default;
@@ -288,7 +292,7 @@ namespace DiscImageChef.Server
} }
case 0x22: case 0x22:
{ {
if(vendor == "CERTANCE") if (vendor == "CERTANCE")
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyCertanceModePage_22(page.value)); modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyCertanceModePage_22(page.value));
else goto default; else goto default;
@@ -296,7 +300,7 @@ namespace DiscImageChef.Server
} }
case 0x24: case 0x24:
{ {
if(vendor == "IBM") if (vendor == "IBM")
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyIBMModePage_24(page.value)); modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyIBMModePage_24(page.value));
else goto default; else goto default;
@@ -304,7 +308,7 @@ namespace DiscImageChef.Server
} }
case 0x2A: case 0x2A:
{ {
if(page.subpage == 0) if (page.subpage == 0)
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_2A(page.value)); modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyModePage_2A(page.value));
else goto default; else goto default;
@@ -312,7 +316,7 @@ namespace DiscImageChef.Server
} }
case 0x2F: case 0x2F:
{ {
if(vendor == "IBM") if (vendor == "IBM")
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyIBMModePage_2F(page.value)); modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyIBMModePage_2F(page.value));
else goto default; else goto default;
@@ -320,7 +324,7 @@ namespace DiscImageChef.Server
} }
case 0x30: 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"); modePages.Add("MODE page 30h", "Drive identifies as an Apple OEM drive");
else goto default; else goto default;
@@ -328,7 +332,7 @@ namespace DiscImageChef.Server
} }
case 0x3B: case 0x3B:
{ {
if(vendor == "HP") if (vendor == "HP")
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyHPModePage_3B(page.value)); modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyHPModePage_3B(page.value));
else goto default; else goto default;
@@ -336,7 +340,7 @@ namespace DiscImageChef.Server
} }
case 0x3C: case 0x3C:
{ {
if(vendor == "HP") if (vendor == "HP")
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyHPModePage_3C(page.value)); modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyHPModePage_3C(page.value));
else goto default; else goto default;
@@ -344,9 +348,9 @@ namespace DiscImageChef.Server
} }
case 0x3D: case 0x3D:
{ {
if(vendor == "IBM") if (vendor == "IBM")
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyIBMModePage_3D(page.value)); 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)); modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyHPModePage_3D(page.value));
else goto default; else goto default;
@@ -354,9 +358,9 @@ namespace DiscImageChef.Server
} }
case 0x3E: case 0x3E:
{ {
if(vendor == "FUJITSU") if (vendor == "FUJITSU")
modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyFujitsuModePage_3E(page.value)); 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)); modePages.Add($"MODE page {page.page:X2}h", Modes.PrettifyHPModePage_3E(page.value));
else goto default; else goto default;
@@ -364,16 +368,19 @@ namespace DiscImageChef.Server
} }
default: default:
{ {
modePages.Add(page.subpage != 0 ? $"MODE page {page.page:X2}h subpage {page.subpage:X2}h" : $"MODE page {page.page:X2}h", modePages.Add(
"Unknown mode page"); page.subpage != 0
? $"MODE page {page.page:X2}h subpage {page.subpage:X2}h"
: $"MODE page {page.page:X2}h",
"Unknown mode page");
} }
break; break;
} }
Dictionary<string, string> newModePages = new Dictionary<string, string>(); var newModePages = new Dictionary<string, string>();
foreach(KeyValuePair<string, string> kvp in modePages) foreach (var kvp in modePages)
newModePages.Add(kvp.Key, 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; 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> /// <param name="testedMedia">List of tested media</param>
public static void Report(IEnumerable<TestedSequentialMedia> testedMedia, ref List<string> mediaOneValue) 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>"); 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>"); 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}"); 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.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.CanReadMediaSerial == true) mediaOneValue.Add("Drive can read medium serial number.");
if(media.MediaIsRecognized) mediaOneValue.Add("Drive recognizes this medium."); if (media.MediaIsRecognized) mediaOneValue.Add("Drive recognizes this medium.");
mediaOneValue.Add(""); mediaOneValue.Add("");
} }

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

@@ -41,51 +41,51 @@ namespace DiscImageChef.Server
{ {
public static void Convert(Stats newStats) 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"}); ctx.Commands.Add(new Command {Count = newStats.Commands.Analyze, Name = "analyze"});
else existing.Count += newStats.Commands.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"}); ctx.Commands.Add(new Command {Count = newStats.Commands.Benchmark, Name = "benchmark"});
else existing.Count += newStats.Commands.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"}); ctx.Commands.Add(new Command {Count = newStats.Commands.Checksum, Name = "checksum"});
else existing.Count += newStats.Commands.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"}); ctx.Commands.Add(new Command {Count = newStats.Commands.Compare, Name = "compare"});
else existing.Count += newStats.Commands.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 ctx.Commands.Add(new Command
{ {
Count = newStats.Commands.CreateSidecar, Name = "create-sidecar" Count = newStats.Commands.CreateSidecar, Name = "create-sidecar"
@@ -93,127 +93,127 @@ namespace DiscImageChef.Server
else existing.Count += newStats.Commands.CreateSidecar; 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"}); ctx.Commands.Add(new Command {Count = newStats.Commands.Decode, Name = "decode"});
else existing.Count += newStats.Commands.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"}); ctx.Commands.Add(new Command {Count = newStats.Commands.DeviceInfo, Name = "device-info"});
else existing.Count += newStats.Commands.DeviceInfo; 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"}); ctx.Commands.Add(new Command {Count = newStats.Commands.DeviceReport, Name = "device-report"});
else existing.Count += newStats.Commands.DeviceReport; 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"}); ctx.Commands.Add(new Command {Count = newStats.Commands.DumpMedia, Name = "dump-media"});
else existing.Count += newStats.Commands.DumpMedia; 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"}); ctx.Commands.Add(new Command {Count = newStats.Commands.Entropy, Name = "entropy"});
else existing.Count += newStats.Commands.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"}); ctx.Commands.Add(new Command {Count = newStats.Commands.Formats, Name = "formats"});
else existing.Count += newStats.Commands.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"}); ctx.Commands.Add(new Command {Count = newStats.Commands.MediaInfo, Name = "media-info"});
else existing.Count += newStats.Commands.MediaInfo; 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"}); ctx.Commands.Add(new Command {Count = newStats.Commands.MediaScan, Name = "media-scan"});
else existing.Count += newStats.Commands.MediaScan; 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"}); ctx.Commands.Add(new Command {Count = newStats.Commands.PrintHex, Name = "printhex"});
else existing.Count += newStats.Commands.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"}); ctx.Commands.Add(new Command {Count = newStats.Commands.Verify, Name = "verify"});
else existing.Count += newStats.Commands.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; 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"}); ctx.Commands.Add(new Command {Count = newStats.Commands.ExtractFiles, Name = "extract-files"});
else existing.Count += newStats.Commands.ExtractFiles; 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"}); ctx.Commands.Add(new Command {Count = newStats.Commands.ListDevices, Name = "list-devices"});
else existing.Count += newStats.Commands.ListDevices; 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 ctx.Commands.Add(new Command
{ {
Count = newStats.Commands.ListEncodings, Name = "list-encodings" Count = newStats.Commands.ListEncodings, Name = "list-encodings"
@@ -221,139 +221,143 @@ namespace DiscImageChef.Server
else existing.Count += newStats.Commands.ListEncodings; 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"}); ctx.Commands.Add(new Command {Count = newStats.Commands.ConvertImage, Name = "convert-image"});
else existing.Count += newStats.Commands.ConvertImage; 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"}); ctx.Commands.Add(new Command {Count = newStats.Commands.ImageInfo, Name = "image-info"});
else existing.Count += newStats.Commands.ImageInfo; else existing.Count += newStats.Commands.ImageInfo;
} }
} }
if(newStats.OperatingSystems != null) if (newStats.OperatingSystems != null)
foreach(OsStats operatingSystem in newStats.OperatingSystems) {
foreach (var operatingSystem in newStats.OperatingSystems)
{ {
if(string.IsNullOrWhiteSpace(operatingSystem.name) || if (string.IsNullOrWhiteSpace(operatingSystem.name) ||
string.IsNullOrWhiteSpace(operatingSystem.version)) continue; string.IsNullOrWhiteSpace(operatingSystem.version)) continue;
OperatingSystem existing = var existing =
ctx.OperatingSystems.FirstOrDefault(c => c.Name == operatingSystem.name && ctx.OperatingSystems.FirstOrDefault(c => c.Name == operatingSystem.name &&
c.Version == operatingSystem.version); c.Version == operatingSystem.version);
if(existing == null) if (existing == null)
ctx.OperatingSystems.Add(new OperatingSystem ctx.OperatingSystems.Add(new OperatingSystem
{ {
Count = operatingSystem.Value, Count = operatingSystem.Value,
Name = operatingSystem.name, Name = operatingSystem.name,
Version = operatingSystem.version Version = operatingSystem.version
}); });
else existing.Count += operatingSystem.Value; else existing.Count += operatingSystem.Value;
} }
}
else else
{ {
OperatingSystem existing = var existing =
ctx.OperatingSystems.FirstOrDefault(c => c.Name == "Linux" && c.Version == null); 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++; else existing.Count++;
} }
if(newStats.Versions != null) if (newStats.Versions != null)
foreach(NameValueStats nvs in newStats.Versions) {
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 existing.Count += nvs.Value;
} }
}
else 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++; else existing.Count++;
} }
if(newStats.Filesystems != null) if (newStats.Filesystems != null)
foreach(NameValueStats nvs in newStats.Filesystems) 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; else existing.Count += nvs.Value;
} }
if(newStats.Partitions != null) if (newStats.Partitions != null)
foreach(NameValueStats nvs in newStats.Partitions) 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; else existing.Count += nvs.Value;
} }
if(newStats.MediaImages != null) if (newStats.MediaImages != null)
foreach(NameValueStats nvs in newStats.MediaImages) 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; else existing.Count += nvs.Value;
} }
if(newStats.Filters != null) if (newStats.Filters != null)
foreach(NameValueStats nvs in newStats.Filters) 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; else existing.Count += nvs.Value;
} }
if(newStats.Devices != null) if (newStats.Devices != null)
foreach(DeviceStats device in newStats.Devices) 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 && if (!ctx.DeviceStats.Any(c => c.Bus == device.Bus && c.Manufacturer == device.Manufacturer &&
c.Model == device.Model && c.Revision == device.Revision)) c.Model == device.Model && c.Revision == device.Revision))
ctx.DeviceStats.Add(new DeviceStat ctx.DeviceStats.Add(new DeviceStat
{ {
Bus = device.Bus, Bus = device.Bus,
Manufacturer = device.Manufacturer, Manufacturer = device.Manufacturer,
Model = device.Model, Model = device.Model,
Revision = device.Revision Revision = device.Revision
}); });
} }
if(newStats.Medias != null) if (newStats.Medias != null)
foreach(MediaStats media in newStats.Medias) 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}); ctx.Medias.Add(new Media {Count = media.Value, Real = media.real, Type = media.type});
else existing.Count += media.Value; 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> /// <param name="testedMedias">List of tested media</param>
public static void Report(List<CommonTypes.Metadata.TestedMedia> testedMedias, ref List<string> mediaOneValue) 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>"); 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"); 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>"); 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 mediaOneValue.Add(testedMedia.MediaIsRecognized
? "Drive recognizes this medium." ? "Drive recognizes this medium."
: "Drive does not recognize 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}"); mediaOneValue.Add($"Medium manufactured by: {testedMedia.Manufacturer}");
if(!string.IsNullOrWhiteSpace(testedMedia.Model)) if (!string.IsNullOrWhiteSpace(testedMedia.Model))
mediaOneValue.Add($"Medium model: {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"); mediaOneValue.Add($"Logical sector size: {testedMedia.BlockSize} bytes");
if(testedMedia.PhysicalBlockSize != null) if (testedMedia.PhysicalBlockSize != null)
mediaOneValue.Add($"Physical sector size: {testedMedia.PhysicalBlockSize} bytes"); 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"); 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"); 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 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"); .Add(
else if(testedMedia.Blocks * testedMedia.BlockSize / 1024 / 1024 > 1000) $"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 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 else
mediaOneValue 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; testedMedia.CurrentCHS.Sectors;
mediaOneValue 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($"Heads: {testedMedia.CHS.Heads} max., {testedMedia.CurrentCHS.Heads} current");
mediaOneValue 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 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 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($"Cylinders: {testedMedia.CHS.Cylinders}");
mediaOneValue.Add($"Heads: {testedMedia.CHS.Heads}"); mediaOneValue.Add($"Heads: {testedMedia.CHS.Heads}");
mediaOneValue.Add($"Sectors per track: {testedMedia.CHS.Sectors}"); mediaOneValue.Add($"Sectors per track: {testedMedia.CHS.Sectors}");
mediaOneValue.Add($"Sectors addressable in CHS mode: {currentSectors}"); mediaOneValue.Add($"Sectors addressable in CHS mode: {currentSectors}");
mediaOneValue 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}"); 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 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"); .Add(
else if((ulong)testedMedia.LBASectors * testedMedia.BlockSize / 1024 / 1024 > 1000) $"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 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 else
mediaOneValue 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}"); 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 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"); .Add(
else if(testedMedia.LBA48Sectors * testedMedia.BlockSize / 1024 / 1024 > 1000) $"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 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 else
mediaOneValue 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 && if (testedMedia.NominalRotationRate != null && testedMedia.NominalRotationRate != 0x0000 &&
testedMedia.NominalRotationRate != 0xFFFF) testedMedia.NominalRotationRate != 0xFFFF)
mediaOneValue.Add(testedMedia.NominalRotationRate == 0x0001 mediaOneValue.Add(testedMedia.NominalRotationRate == 0x0001
? "Medium does not rotate." ? "Medium does not rotate."
: $"Medium rotates at {testedMedia.NominalRotationRate} rpm"); : $"Medium rotates at {testedMedia.NominalRotationRate} rpm");
if(testedMedia.BlockSize != null && if (testedMedia.BlockSize != null &&
testedMedia.PhysicalBlockSize != null && testedMedia.PhysicalBlockSize != null &&
testedMedia.BlockSize.Value != testedMedia.PhysicalBlockSize.Value && testedMedia.BlockSize.Value != testedMedia.PhysicalBlockSize.Value &&
(testedMedia.LogicalAlignment & 0x8000) == 0x0000 && (testedMedia.LogicalAlignment & 0x8000) == 0x0000 &&
(testedMedia.LogicalAlignment & 0x4000) == 0x4000) (testedMedia.LogicalAlignment & 0x4000) == 0x4000)
mediaOneValue 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"); 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"); 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"); 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"); 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"); 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"); 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"); 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 mediaOneValue
.Add("Device can use the READ SECTOR(S) RETRY command in 28-bit LBA mode with this medium"); .Add("Device can use the READ SECTOR(S) RETRY command in 28-bit LBA mode with this medium");
if(testedMedia.SupportsReadDmaLba == true) if (testedMedia.SupportsReadDmaLba == true)
mediaOneValue.Add("Device can use the READ DMA command in 28-bit LBA mode with this medium"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); 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 mediaOneValue
.Add("Device can use the READ CD command with LBA addressing with this medium to read raw sector"); .Add(
if(testedMedia.SupportsReadCdMsfRaw == true) "Device can use the READ CD command with LBA addressing with this medium to read raw sector");
if (testedMedia.SupportsReadCdMsfRaw == true)
mediaOneValue 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"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); mediaOneValue.Add("Device can correct subchannels when reading from this medium");
if(testedMedia.CanReadCorrectedSubchannelWithC2 == true) if (testedMedia.CanReadCorrectedSubchannelWithC2 == true)
mediaOneValue mediaOneValue
.Add("Device can correct subchannels and report the C2 pointers when reading from this medium"); .Add("Device can correct subchannels and report the C2 pointers when reading from this medium");
if(testedMedia.CanReadDCB == true) if (testedMedia.CanReadDCB == true)
mediaOneValue.Add("Device can read the Disc Control Blocks from this medium"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); 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.CanReadLeadIn == true)
if(testedMedia.CanReadLeadOut == 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"); 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"); 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"); 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.CanReadPAC == true) mediaOneValue.Add("Device can read the PAC from this medium");
if(testedMedia.CanReadPFI == true) if (testedMedia.CanReadPFI == true)
mediaOneValue.Add("Device can read the Physical Format Information from this medium"); 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"); 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"); mediaOneValue.Add("Device can read the P to Q subchannels from this medium");
if(testedMedia.CanReadPQSubchannelWithC2 == true) if (testedMedia.CanReadPQSubchannelWithC2 == true)
mediaOneValue mediaOneValue
.Add("Device can read the P to Q subchannels from this medium reporting the C2 pointers"); .Add("Device can read the P to Q subchannels from this medium reporting the C2 pointers");
if(testedMedia.CanReadPRI == true) if (testedMedia.CanReadPRI == true)
mediaOneValue.Add("Device can read the Pre-Recorded Information from this medium"); 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"); mediaOneValue.Add("Device can read the R to W subchannels from this medium");
if(testedMedia.CanReadRWSubchannelWithC2 == true) if (testedMedia.CanReadRWSubchannelWithC2 == true)
mediaOneValue mediaOneValue
.Add("Device can read the R to W subchannels from this medium reporting the C2 pointers"); .Add("Device can read the R to W subchannels from this medium reporting the C2 pointers");
if(testedMedia.CanReadRecordablePFI == true) if (testedMedia.CanReadRecordablePFI == true)
mediaOneValue.Add("Device can read the Physical Format Information from Lead-In from this medium"); 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"); 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("Device can read the Table of Contents from this medium");
mediaOneValue.Add(""); mediaOneValue.Add("");

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

@@ -41,7 +41,7 @@ namespace DiscImageChef.Server.Controllers
{ {
public class HomeController : Controller public class HomeController : Controller
{ {
private IWebHostEnvironment _environment; private readonly IWebHostEnvironment _environment;
public HomeController(IWebHostEnvironment environment) public HomeController(IWebHostEnvironment environment)
{ {
@@ -52,10 +52,10 @@ namespace DiscImageChef.Server.Controllers
[Route("README")] [Route("README")]
public ActionResult Index() public ActionResult Index()
{ {
StreamReader sr = var sr =
new StreamReader(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(), new StreamReader(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"docs", "README.md")); "docs", "README.md"));
string mdcontent = sr.ReadToEnd(); var mdcontent = sr.ReadToEnd();
sr.Close(); sr.Close();
mdcontent = mdcontent.Replace(".md)", ")"); mdcontent = mdcontent.Replace(".md)", ")");
@@ -70,10 +70,10 @@ namespace DiscImageChef.Server.Controllers
[Route("Changelog")] [Route("Changelog")]
public ActionResult Changelog() public ActionResult Changelog()
{ {
StreamReader sr = var sr =
new StreamReader(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(), new StreamReader(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"docs", "Changelog.md")); "docs", "Changelog.md"));
string mdcontent = sr.ReadToEnd(); var mdcontent = sr.ReadToEnd();
sr.Close(); sr.Close();
mdcontent = mdcontent.Replace(".md)", ")"); mdcontent = mdcontent.Replace(".md)", ")");
@@ -88,10 +88,10 @@ namespace DiscImageChef.Server.Controllers
[Route("CODE_OF_CONDUCT")] [Route("CODE_OF_CONDUCT")]
public ActionResult CODE_OF_CONDUCT() public ActionResult CODE_OF_CONDUCT()
{ {
StreamReader sr = var sr =
new StreamReader(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(), new StreamReader(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"docs", "CODE_OF_CONDUCT.md")); "docs", "CODE_OF_CONDUCT.md"));
string mdcontent = sr.ReadToEnd(); var mdcontent = sr.ReadToEnd();
sr.Close(); sr.Close();
mdcontent = mdcontent.Replace(".md)", ")").Replace("(.github/", "("); mdcontent = mdcontent.Replace(".md)", ")").Replace("(.github/", "(");
@@ -106,10 +106,10 @@ namespace DiscImageChef.Server.Controllers
[Route("PULL_REQUEST_TEMPLATE")] [Route("PULL_REQUEST_TEMPLATE")]
public ActionResult PULL_REQUEST_TEMPLATE() public ActionResult PULL_REQUEST_TEMPLATE()
{ {
StreamReader sr = var sr =
new StreamReader(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(), new StreamReader(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"docs", "PULL_REQUEST_TEMPLATE.md")); "docs", "PULL_REQUEST_TEMPLATE.md"));
string mdcontent = sr.ReadToEnd(); var mdcontent = sr.ReadToEnd();
sr.Close(); sr.Close();
mdcontent = mdcontent.Replace(".md)", ")").Replace("(.github/", "("); mdcontent = mdcontent.Replace(".md)", ")").Replace("(.github/", "(");
@@ -124,10 +124,10 @@ namespace DiscImageChef.Server.Controllers
[Route("ISSUE_TEMPLATE")] [Route("ISSUE_TEMPLATE")]
public ActionResult ISSUE_TEMPLATE() public ActionResult ISSUE_TEMPLATE()
{ {
StreamReader sr = var sr =
new StreamReader(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(), new StreamReader(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"docs", "ISSUE_TEMPLATE.md")); "docs", "ISSUE_TEMPLATE.md"));
string mdcontent = sr.ReadToEnd(); var mdcontent = sr.ReadToEnd();
sr.Close(); sr.Close();
mdcontent = mdcontent.Replace(".md)", ")").Replace("(.github/", "("); mdcontent = mdcontent.Replace(".md)", ")").Replace("(.github/", "(");
@@ -142,10 +142,10 @@ namespace DiscImageChef.Server.Controllers
[Route("CONTRIBUTING")] [Route("CONTRIBUTING")]
public ActionResult CONTRIBUTING() public ActionResult CONTRIBUTING()
{ {
StreamReader sr = var sr =
new StreamReader(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(), new StreamReader(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"docs", "CONTRIBUTING.md")); "docs", "CONTRIBUTING.md"));
string mdcontent = sr.ReadToEnd(); var mdcontent = sr.ReadToEnd();
sr.Close(); sr.Close();
mdcontent = mdcontent.Replace(".md)", ")").Replace("(.github/", "("); mdcontent = mdcontent.Replace(".md)", ")").Replace("(.github/", "(");
@@ -160,10 +160,10 @@ namespace DiscImageChef.Server.Controllers
[Route("DONATING")] [Route("DONATING")]
public ActionResult DONATING() public ActionResult DONATING()
{ {
StreamReader sr = var sr =
new StreamReader(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(), new StreamReader(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"docs", "DONATING.md")); "docs", "DONATING.md"));
string mdcontent = sr.ReadToEnd(); var mdcontent = sr.ReadToEnd();
sr.Close(); sr.Close();
mdcontent = mdcontent.Replace(".md)", ")"); mdcontent = mdcontent.Replace(".md)", ")");
@@ -178,10 +178,10 @@ namespace DiscImageChef.Server.Controllers
[Route("TODO")] [Route("TODO")]
public ActionResult TODO() public ActionResult TODO()
{ {
StreamReader sr = var sr =
new StreamReader(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(), new StreamReader(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"docs", "TODO.md")); "docs", "TODO.md"));
string mdcontent = sr.ReadToEnd(); var mdcontent = sr.ReadToEnd();
sr.Close(); sr.Close();
mdcontent = mdcontent.Replace(".md)", ")"); 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 DiscImageChef.Server.Models;
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Routing; using Microsoft.AspNetCore.Routing;
using Tuple = DiscImageChef.Decoders.PCMCIA.Tuple;
namespace DiscImageChef.Server.Controllers namespace DiscImageChef.Server.Controllers
{ {
public class ReportController : Controller public class ReportController : Controller
{ {
private DicServerContext _ctx; private readonly DicServerContext _ctx;
public ReportController(DicServerContext context) public ReportController(DicServerContext context)
{ {
_ctx = 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) 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 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.lblManufacturer = report.Manufacturer;
ViewBag.lblModel = report.Model; ViewBag.lblModel = report.Model;
ViewBag.lblRevision = report.Revision; ViewBag.lblRevision = report.Revision;
if(report.USB != null) if (report.USB != null)
{ {
string usbVendorDescription = null; string usbVendorDescription = null;
string usbProductDescription = null; string usbProductDescription = null;
UsbProduct dbProduct = var dbProduct =
_ctx.UsbProducts.FirstOrDefault(p => p.ProductId == report.USB.ProductID && _ctx.UsbProducts.FirstOrDefault(p => p.ProductId == report.USB.ProductID &&
p.Vendor != null && p.Vendor != null &&
p.Vendor.VendorId == report.USB.VendorID); 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 else
{ {
usbProductDescription = dbProduct.Product; usbProductDescription = dbProduct.Product;
usbVendorDescription = dbProduct.Vendor.Vendor; usbVendorDescription = dbProduct.Vendor.Vendor;
} }
ViewBag.UsbItem = new Item ViewBag.UsbItem = new Item
{ {
Manufacturer = report.USB.Manufacturer, Manufacturer = report.USB.Manufacturer,
Product = report.USB.Product, Product = report.USB.Product,
VendorDescription = VendorDescription =
usbVendorDescription != null usbVendorDescription != null
? $"0x{report.USB.VendorID:x4} ({usbVendorDescription})" ? $"0x{report.USB.VendorID:x4} ({usbVendorDescription})"
: $"0x{report.USB.VendorID:x4}", : $"0x{report.USB.VendorID:x4}",
ProductDescription = usbProductDescription != null ProductDescription = usbProductDescription != null
? $"0x{report.USB.ProductID:x4} ({usbProductDescription})" ? $"0x{report.USB.ProductID:x4} ({usbProductDescription})"
: $"0x{report.USB.ProductID:x4}" : $"0x{report.USB.ProductID:x4}"
}; };
} }
if(report.FireWire != null) if (report.FireWire != null)
ViewBag.FireWireItem = new Item ViewBag.FireWireItem = new Item
{ {
Manufacturer = report.FireWire.Manufacturer, Manufacturer = report.FireWire.Manufacturer,
Product = report.FireWire.Product, Product = report.FireWire.Product,
VendorDescription = $"0x{report.FireWire.VendorID:x8}", VendorDescription = $"0x{report.FireWire.VendorID:x8}",
ProductDescription = $"0x{report.FireWire.ProductID:x8}" ProductDescription = $"0x{report.FireWire.ProductID:x8}"
}; };
if(report.PCMCIA != null) if (report.PCMCIA != null)
{ {
ViewBag.PcmciaItem = new PcmciaItem ViewBag.PcmciaItem = new PcmciaItem
{ {
Manufacturer = report.PCMCIA.Manufacturer, Manufacturer = report.PCMCIA.Manufacturer,
Product = report.PCMCIA.ProductName, Product = report.PCMCIA.ProductName,
VendorDescription = $"0x{report.PCMCIA.ManufacturerCode:x4}", VendorDescription = $"0x{report.PCMCIA.ManufacturerCode:x4}",
ProductDescription = $"0x{report.PCMCIA.CardCode:x4}", ProductDescription = $"0x{report.PCMCIA.CardCode:x4}",
Compliance = report.PCMCIA.Compliance Compliance = report.PCMCIA.Compliance
}; };
Tuple[] tuples = CIS.GetTuples(report.PCMCIA.CIS); var tuples = CIS.GetTuples(report.PCMCIA.CIS);
if(tuples != null) if (tuples != null)
{ {
Dictionary<string, string> decodedTuples = new Dictionary<string, string>(); var decodedTuples = new Dictionary<string, string>();
foreach(Tuple tuple in tuples) foreach (var tuple in tuples)
switch(tuple.Code) switch (tuple.Code)
{ {
case TupleCodes.CISTPL_NULL: case TupleCodes.CISTPL_NULL:
case TupleCodes.CISTPL_END: case TupleCodes.CISTPL_END:
@@ -137,20 +139,20 @@ namespace DiscImageChef.Server.Controllers
case TupleCodes.CISTPL_VERS_1: break; case TupleCodes.CISTPL_VERS_1: break;
case TupleCodes.CISTPL_DEVICEGEO: case TupleCodes.CISTPL_DEVICEGEO:
case TupleCodes.CISTPL_DEVICEGEO_A: case TupleCodes.CISTPL_DEVICEGEO_A:
DeviceGeometryTuple geom = CIS.DecodeDeviceGeometryTuple(tuple.Data); var geom = CIS.DecodeDeviceGeometryTuple(tuple.Data);
if(geom?.Geometries != null) if (geom?.Geometries != null)
foreach(DeviceGeometry geometry in geom.Geometries) foreach (var geometry in geom.Geometries)
{ {
decodedTuples.Add("Device width", decodedTuples.Add("Device width",
$"{(1 << (geometry.CardInterface - 1)) * 8} bits"); $"{(1 << (geometry.CardInterface - 1)) * 8} bits");
decodedTuples.Add("Erase block", 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", 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", 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", 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; break;
@@ -191,44 +193,44 @@ namespace DiscImageChef.Server.Controllers
decodedTuples.Add("Undecoded tuple ID", tuple.Code.ToString()); decodedTuples.Add("Undecoded tuple ID", tuple.Code.ToString());
break; break;
default: default:
decodedTuples.Add("Unknown tuple ID", $"0x{(byte)tuple.Code:X2}"); decodedTuples.Add("Unknown tuple ID", $"0x{(byte) tuple.Code:X2}");
break; 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; List<TestedMedia> testedMedia = null;
bool ata = false; var ata = false;
bool atapi = false; var atapi = false;
bool sscMedia = false; var sscMedia = false;
if(report.ATA != null || report.ATAPI != null) if (report.ATA != null || report.ATAPI != null)
{ {
ata = true; ata = true;
List<string> ataOneValue = new List<string>(); var ataOneValue = new List<string>();
Dictionary<string, string> ataTwoValue = new Dictionary<string, string>(); var ataTwoValue = new Dictionary<string, string>();
CommonTypes.Metadata.Ata ataReport; CommonTypes.Metadata.Ata ataReport;
if(report.ATAPI != null) if (report.ATAPI != null)
{ {
ViewBag.AtaItem = "ATAPI"; ViewBag.AtaItem = "ATAPI";
ataReport = report.ATAPI; ataReport = report.ATAPI;
atapi = true; atapi = true;
} }
else else
{ {
ViewBag.AtaItem = "ATA"; ViewBag.AtaItem = "ATA";
ataReport = report.ATA; ataReport = report.ATA;
} }
bool cfa = report.CompactFlash; var cfa = report.CompactFlash;
if(atapi && !cfa) ViewBag.lblAtaDeviceType = "ATAPI device"; if (atapi && !cfa) ViewBag.lblAtaDeviceType = "ATAPI device";
else if(!atapi && cfa) ViewBag.lblAtaDeviceType = "CompactFlash device"; else if (!atapi && cfa) ViewBag.lblAtaDeviceType = "CompactFlash device";
else ViewBag.lblAtaDeviceType = "ATA device"; else ViewBag.lblAtaDeviceType = "ATA device";
Ata.Report(ataReport, cfa, atapi, ref removable, ref ataOneValue, ref ataTwoValue, ref testedMedia); Ata.Report(ataReport, cfa, atapi, ref removable, ref ataOneValue, ref ataTwoValue, ref testedMedia);
@@ -236,62 +238,62 @@ namespace DiscImageChef.Server.Controllers
ViewBag.repAtaTwo = ataTwoValue; ViewBag.repAtaTwo = ataTwoValue;
} }
if(report.SCSI != null) if (report.SCSI != null)
{ {
List<string> scsiOneValue = new List<string>(); var scsiOneValue = new List<string>();
Dictionary<string, string> modePages = new Dictionary<string, string>(); var modePages = new Dictionary<string, string>();
Dictionary<string, string> evpdPages = new Dictionary<string, string>(); var evpdPages = new Dictionary<string, string>();
string vendorId = StringHandlers.CToString(report.SCSI.Inquiry?.VendorIdentification); var vendorId = StringHandlers.CToString(report.SCSI.Inquiry?.VendorIdentification);
if(report.SCSI.Inquiry != null) if (report.SCSI.Inquiry != null)
{ {
Inquiry.SCSIInquiry inq = report.SCSI.Inquiry.Value; var inq = report.SCSI.Inquiry.Value;
ViewBag.lblScsiVendor = VendorString.Prettify(vendorId) != vendorId ViewBag.lblScsiVendor = VendorString.Prettify(vendorId) != vendorId
? $"{vendorId} ({VendorString.Prettify(vendorId)})" ? $"{vendorId} ({VendorString.Prettify(vendorId)})"
: vendorId; : vendorId;
ViewBag.lblScsiProduct = StringHandlers.CToString(inq.ProductIdentification); ViewBag.lblScsiProduct = StringHandlers.CToString(inq.ProductIdentification);
ViewBag.lblScsiRevision = StringHandlers.CToString(inq.ProductRevisionLevel); ViewBag.lblScsiRevision = StringHandlers.CToString(inq.ProductRevisionLevel);
} }
scsiOneValue.AddRange(ScsiInquiry.Report(report.SCSI.Inquiry)); scsiOneValue.AddRange(ScsiInquiry.Report(report.SCSI.Inquiry));
if(report.SCSI.SupportsModeSense6) scsiOneValue.Add("Device supports MODE SENSE (6)"); 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.SupportsModeSense10) scsiOneValue.Add("Device supports MODE SENSE (10)");
if(report.SCSI.SupportsModeSubpages) scsiOneValue.Add("Device supports MODE SENSE subpages"); 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; var devType = PeripheralDeviceTypes.DirectAccess;
if(report.SCSI.Inquiry != null) if (report.SCSI.Inquiry != null)
devType = (PeripheralDeviceTypes)report.SCSI.Inquiry.Value.PeripheralDeviceType; devType = (PeripheralDeviceTypes) report.SCSI.Inquiry.Value.PeripheralDeviceType;
ScsiModeSense.Report(report.SCSI.ModeSense, vendorId, devType, ref scsiOneValue, ref modePages); 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; 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); 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); 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; ViewBag.divScsiSscVisible = true;
@@ -304,160 +306,167 @@ namespace DiscImageChef.Server.Controllers
ViewBag.lblScsiSscMinBlock = ViewBag.lblScsiSscMinBlock =
report.SCSI.SequentialDevice.MinBlockLength?.ToString() ?? "Unspecified"; report.SCSI.SequentialDevice.MinBlockLength?.ToString() ?? "Unspecified";
if(report.SCSI.SequentialDevice.SupportedDensities != null) if (report.SCSI.SequentialDevice.SupportedDensities != null)
ViewBag.repScsiSscDensities = report.SCSI.SequentialDevice.SupportedDensities; ViewBag.repScsiSscDensities = report.SCSI.SequentialDevice.SupportedDensities;
if(report.SCSI.SequentialDevice.SupportedMediaTypes != null) if (report.SCSI.SequentialDevice.SupportedMediaTypes != null)
ViewBag.repScsiSscMedias = report.SCSI.SequentialDevice.SupportedMediaTypes; 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); SscTestedMedia.Report(report.SCSI.SequentialDevice.TestedMedia, ref mediaOneValue);
if(mediaOneValue.Count > 0) if (mediaOneValue.Count > 0)
{ {
sscMedia = true; sscMedia = true;
ViewBag.repTestedMedia = mediaOneValue; ViewBag.repTestedMedia = mediaOneValue;
} }
} }
} }
else if(report.SCSI.ReadCapabilities != null) else if (report.SCSI.ReadCapabilities != null)
{ {
removable = false; removable = false;
scsiOneValue.Add(""); scsiOneValue.Add("");
if(report.SCSI.ReadCapabilities.Blocks.HasValue && if (report.SCSI.ReadCapabilities.Blocks.HasValue &&
report.SCSI.ReadCapabilities.BlockSize.HasValue) report.SCSI.ReadCapabilities.BlockSize.HasValue)
{ {
scsiOneValue 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 / if (report.SCSI.ReadCapabilities.Blocks * report.SCSI.ReadCapabilities.BlockSize / 1024 /
1024 > 1000000) 1024 > 1000000)
scsiOneValue 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"); .Add(
else if(report.SCSI.ReadCapabilities.Blocks * report.SCSI.ReadCapabilities.BlockSize / $"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");
1024 / else if (report.SCSI.ReadCapabilities.Blocks * report.SCSI.ReadCapabilities.BlockSize /
1024 > 1000) 1024 /
1024 > 1000)
scsiOneValue 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 else
scsiOneValue 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"); 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"); scsiOneValue.Add($"Density code: {report.SCSI.ReadCapabilities.Density:X2}h");
if((report.SCSI.ReadCapabilities.SupportsReadLong == true || if ((report.SCSI.ReadCapabilities.SupportsReadLong == true ||
report.SCSI.ReadCapabilities.SupportsReadLong16 == true) && report.SCSI.ReadCapabilities.SupportsReadLong16 == true) &&
report.SCSI.ReadCapabilities.LongBlockSize.HasValue) report.SCSI.ReadCapabilities.LongBlockSize.HasValue)
scsiOneValue.Add($"Long block size: {report.SCSI.ReadCapabilities.LongBlockSize} bytes"); 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."); 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."); 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."); 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."); 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."); 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."); 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."); 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."); scsiOneValue.Add("Device supports READ LONG (16) command.");
} }
else testedMedia = report.SCSI.RemovableMedias; else
{
testedMedia = report.SCSI.RemovableMedias;
}
ViewBag.repScsi = scsiOneValue; 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) mmcOneValue.Add(Decoders.MMC.Decoders.PrettifyCID(report.MultiMediaCard.CID)
.Replace("\n", "<br/>")); .Replace("\n", "<br/>"));
mmcOneValue.Add(""); mmcOneValue.Add("");
} }
if(report.MultiMediaCard.CSD != null) if (report.MultiMediaCard.CSD != null)
{ {
mmcOneValue.Add(Decoders.MMC.Decoders.PrettifyCSD(report.MultiMediaCard.CSD) mmcOneValue.Add(Decoders.MMC.Decoders.PrettifyCSD(report.MultiMediaCard.CSD)
.Replace("\n", "<br/>")); .Replace("\n", "<br/>"));
mmcOneValue.Add(""); mmcOneValue.Add("");
} }
if(report.MultiMediaCard.ExtendedCSD != null) if (report.MultiMediaCard.ExtendedCSD != null)
{ {
mmcOneValue.Add(Decoders.MMC.Decoders.PrettifyExtendedCSD(report.MultiMediaCard.ExtendedCSD) mmcOneValue.Add(Decoders.MMC.Decoders.PrettifyExtendedCSD(report.MultiMediaCard.ExtendedCSD)
.Replace("\n", "<br/>")); .Replace("\n", "<br/>"));
mmcOneValue.Add(""); mmcOneValue.Add("");
} }
if(report.MultiMediaCard.OCR != null) if (report.MultiMediaCard.OCR != null)
{ {
mmcOneValue.Add(Decoders.MMC.Decoders.PrettifyCSD(report.MultiMediaCard.OCR) mmcOneValue.Add(Decoders.MMC.Decoders.PrettifyCSD(report.MultiMediaCard.OCR)
.Replace("\n", "<br/>")); .Replace("\n", "<br/>"));
mmcOneValue.Add(""); mmcOneValue.Add("");
} }
ViewBag.repMMC = mmcOneValue; 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) sdOneValue.Add(Decoders.SecureDigital.Decoders.PrettifyCID(report.SecureDigital.CID)
.Replace("\n", "<br/>")); .Replace("\n", "<br/>"));
sdOneValue.Add(""); sdOneValue.Add("");
} }
if(report.SecureDigital.CSD != null) if (report.SecureDigital.CSD != null)
{ {
sdOneValue.Add(Decoders.SecureDigital.Decoders.PrettifyCSD(report.SecureDigital.CSD) sdOneValue.Add(Decoders.SecureDigital.Decoders.PrettifyCSD(report.SecureDigital.CSD)
.Replace("\n", "<br/>")); .Replace("\n", "<br/>"));
sdOneValue.Add(""); sdOneValue.Add("");
} }
if(report.SecureDigital.SCR != null) if (report.SecureDigital.SCR != null)
{ {
sdOneValue.Add(Decoders.SecureDigital.Decoders.PrettifySCR(report.SecureDigital.SCR) sdOneValue.Add(Decoders.SecureDigital.Decoders.PrettifySCR(report.SecureDigital.SCR)
.Replace("\n", "<br/>")); .Replace("\n", "<br/>"));
sdOneValue.Add(""); sdOneValue.Add("");
} }
if(report.SecureDigital.OCR != null) if (report.SecureDigital.OCR != null)
{ {
sdOneValue.Add(Decoders.SecureDigital.Decoders.PrettifyCSD(report.SecureDigital.OCR) sdOneValue.Add(Decoders.SecureDigital.Decoders.PrettifyCSD(report.SecureDigital.OCR)
.Replace("\n", "<br/>")); .Replace("\n", "<br/>"));
sdOneValue.Add(""); sdOneValue.Add("");
} }
ViewBag.repSD = sdOneValue; 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); 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; throw;
#endif #endif
return Content("Could not load device report"); 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 Highsoft.Web.Mvc.Charts;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc; 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 PlatformID = DiscImageChef.CommonTypes.Interop.PlatformID;
using Version = DiscImageChef.Server.Models.Version;
namespace DiscImageChef.Server.Controllers namespace DiscImageChef.Server.Controllers
{ {
@@ -57,13 +53,13 @@ namespace DiscImageChef.Server.Controllers
/// </summary> /// </summary>
public class StatsController : Controller public class StatsController : Controller
{ {
DicServerContext ctx; private readonly IWebHostEnvironment _environment;
List<DeviceItem> devices; private readonly DicServerContext ctx;
List<NameValueStats> operatingSystems; private List<DeviceItem> devices;
List<MediaItem> realMedia; private List<NameValueStats> operatingSystems;
List<NameValueStats> versions; private List<MediaItem> realMedia;
List<MediaItem> virtualMedia; private List<NameValueStats> versions;
private IWebHostEnvironment _environment; private List<MediaItem> virtualMedia;
public StatsController(IWebHostEnvironment environment, DicServerContext context) public StatsController(IWebHostEnvironment environment, DicServerContext context)
{ {
@@ -77,118 +73,120 @@ namespace DiscImageChef.Server.Controllers
try try
{ {
if( if (
System.IO.File System.IO.File
.Exists(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(), .Exists(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"Statistics", "Statistics.xml"))) "Statistics", "Statistics.xml")))
try try
{ {
Stats statistics = new Stats(); var statistics = new Stats();
XmlSerializer xs = new XmlSerializer(statistics.GetType()); var xs = new XmlSerializer(statistics.GetType());
FileStream fs = var fs =
WaitForFile(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(), "Statistics", "Statistics.xml"), WaitForFile(
FileMode.Open, FileAccess.Read, FileShare.Read); Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
statistics = (Stats)xs.Deserialize(fs); "Statistics", "Statistics.xml"),
FileMode.Open, FileAccess.Read, FileShare.Read);
statistics = (Stats) xs.Deserialize(fs);
fs.Close(); fs.Close();
StatsConverter.Convert(statistics); StatsConverter.Convert(statistics);
System.IO.File System.IO.File
.Delete(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(), .Delete(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
"Statistics", "Statistics.xml")); "Statistics", "Statistics.xml"));
} }
catch(XmlException) catch (XmlException)
{ {
// Do nothing // Do nothing
} }
if(ctx.OperatingSystems.Any()) if (ctx.OperatingSystems.Any())
{ {
operatingSystems = new List<NameValueStats>(); operatingSystems = new List<NameValueStats>();
foreach(OperatingSystem nvs in ctx.OperatingSystems) foreach (var nvs in ctx.OperatingSystems)
operatingSystems.Add(new NameValueStats operatingSystems.Add(new NameValueStats
{ {
name = 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 Value = nvs.Count
}); });
ViewBag.repOperatingSystems = operatingSystems.OrderBy(os => os.name).ToList(); 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); 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); decimal osCount = ctx.OperatingSystems.Where(o => o.Name == os).Sum(o => o.Count);
osPieData.Add(new PieSeriesData osPieData.Add(new PieSeriesData
{ {
Name = Name =
DetectOS.GetPlatformName((PlatformID)Enum.Parse(typeof(PlatformID), DetectOS.GetPlatformName((PlatformID) Enum.Parse(typeof(PlatformID),
os)), os)),
Y = (double?)(osCount / totalOsCount), Y = (double?) (osCount / totalOsCount),
Sliced = os == "Linux", Sliced = os == "Linux",
Selected = os == "Linux" Selected = os == "Linux"
}); });
} }
ViewData["osPieData"] = osPieData; 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()) decimal linuxCount = ctx.OperatingSystems.Where(o => o.Name == PlatformID.Linux.ToString())
.Sum(o => o.Count); .Sum(o => o.Count);
foreach(OperatingSystem version in foreach (var version in
ctx.OperatingSystems.Where(o => o.Name == PlatformID.Linux.ToString())) ctx.OperatingSystems.Where(o => o.Name == PlatformID.Linux.ToString()))
linuxPieData.Add(new PieSeriesData linuxPieData.Add(new PieSeriesData
{ {
Name = Name =
$"{DetectOS.GetPlatformName(PlatformID.Linux, version.Version)}{(string.IsNullOrEmpty(version.Version) ? "" : " ")}{version.Version}", $"{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; 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()) decimal macosCount = ctx.OperatingSystems.Where(o => o.Name == PlatformID.MacOSX.ToString())
.Sum(o => o.Count); .Sum(o => o.Count);
foreach(OperatingSystem version in foreach (var version in
ctx.OperatingSystems.Where(o => o.Name == PlatformID.MacOSX.ToString())) ctx.OperatingSystems.Where(o => o.Name == PlatformID.MacOSX.ToString()))
macosPieData.Add(new PieSeriesData macosPieData.Add(new PieSeriesData
{ {
Name = Name =
$"{DetectOS.GetPlatformName(PlatformID.MacOSX, version.Version)}{(string.IsNullOrEmpty(version.Version) ? "" : " ")}{version.Version}", $"{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; 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()) decimal windowsCount = ctx.OperatingSystems.Where(o => o.Name == PlatformID.Win32NT.ToString())
.Sum(o => o.Count); .Sum(o => o.Count);
foreach(OperatingSystem version in foreach (var version in
ctx.OperatingSystems.Where(o => o.Name == PlatformID.Win32NT.ToString())) ctx.OperatingSystems.Where(o => o.Name == PlatformID.Win32NT.ToString()))
windowsPieData.Add(new PieSeriesData windowsPieData.Add(new PieSeriesData
{ {
Name = Name =
$"{DetectOS.GetPlatformName(PlatformID.Win32NT, version.Version)}{(string.IsNullOrEmpty(version.Version) ? "" : " ")}{version.Version}", $"{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; ViewData["windowsPieData"] = windowsPieData;
} }
if(ctx.Versions.Any()) if (ctx.Versions.Any())
{ {
versions = new List<NameValueStats>(); versions = new List<NameValueStats>();
foreach(Version nvs in ctx.Versions) foreach (var nvs in ctx.Versions)
versions.Add(new NameValueStats 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 Value = nvs.Count
}); });
@@ -202,210 +200,211 @@ namespace DiscImageChef.Server.Controllers
version.Value == "previous" version.Value == "previous"
? "Previous than 3.4.99.0" ? "Previous than 3.4.99.0"
: version.Value, : version.Value,
Y = (double?)(version.Count / Y = (double?) (version.Count /
totalVersionCount), totalVersionCount),
Sliced = version.Value == "previous", Sliced = version.Value == "previous",
Selected = version.Value == "previous" Selected = version.Value == "previous"
}).ToList(); }).ToList();
} }
if(ctx.Commands.Any()) if (ctx.Commands.Any())
{ {
ViewBag.repCommands = ctx.Commands.OrderBy(c => c.Name).ToList(); ViewBag.repCommands = ctx.Commands.OrderBy(c => c.Name).ToList();
decimal totalCommandCount = ctx.Commands.Sum(o => o.Count); decimal totalCommandCount = ctx.Commands.Sum(o => o.Count);
ViewData["commandsPieData"] = ctx ViewData["commandsPieData"] = ctx
.Commands.Select(command => new PieSeriesData .Commands.Select(command => new PieSeriesData
{ {
Name = command.Name, Name = command.Name,
Y = (double?)(command.Count / Y = (double?) (command.Count /
totalCommandCount), totalCommandCount),
Sliced = command.Name == "analyze", Sliced = command.Name == "analyze",
Selected = command.Name == "analyze" Selected = command.Name == "analyze"
}).ToList(); }).ToList();
} }
if(ctx.Filters.Any()) if (ctx.Filters.Any())
{ {
ViewBag.repFilters = ctx.Filters.OrderBy(filter => filter.Name).ToList(); 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); 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 filtersPieData.Add(new PieSeriesData
{ {
Name = filter.Name, Name = filter.Name,
Y = (double?)(filter.Count / totalFiltersCount), Y = (double?) (filter.Count / totalFiltersCount),
Sliced = filter.Name == "No filter", Sliced = filter.Name == "No filter",
Selected = filter.Name == "No filter" Selected = filter.Name == "No filter"
}); });
ViewData["filtersPieData"] = filtersPieData; ViewData["filtersPieData"] = filtersPieData;
} }
if(ctx.MediaFormats.Any()) if (ctx.MediaFormats.Any())
{ {
ViewBag.repMediaImages = ctx.MediaFormats.OrderBy(filter => filter.Name).ToList(); 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 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; top10FormatCount += format.Count;
formatsPieData.Add(new PieSeriesData formatsPieData.Add(new PieSeriesData
{ {
Name = format.Name, Y = (double?)(format.Count / totalFormatsCount) Name = format.Name, Y = (double?) (format.Count / totalFormatsCount)
}); });
} }
formatsPieData.Add(new PieSeriesData formatsPieData.Add(new PieSeriesData
{ {
Name = "Other", Name = "Other",
Y = (double?)((totalFormatsCount - top10FormatCount) / Y = (double?) ((totalFormatsCount - top10FormatCount) /
totalFormatsCount), totalFormatsCount),
Sliced = true, Sliced = true,
Selected = true Selected = true
}); });
ViewData["formatsPieData"] = formatsPieData; ViewData["formatsPieData"] = formatsPieData;
} }
if(ctx.Partitions.Any()) if (ctx.Partitions.Any())
{ {
ViewBag.repPartitions = ctx.Partitions.OrderBy(filter => filter.Name).ToList(); 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 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; top10PartitionCount += partition.Count;
partitionsPieData.Add(new PieSeriesData partitionsPieData.Add(new PieSeriesData
{ {
Name = partition.Name, Name = partition.Name,
Y = (double?)(partition.Count / totalPartitionsCount) Y = (double?) (partition.Count / totalPartitionsCount)
}); });
} }
partitionsPieData.Add(new PieSeriesData partitionsPieData.Add(new PieSeriesData
{ {
Name = "Other", Name = "Other",
Y = (double?)((totalPartitionsCount - top10PartitionCount) / Y = (double?) ((totalPartitionsCount - top10PartitionCount) /
totalPartitionsCount), totalPartitionsCount),
Sliced = true, Sliced = true,
Selected = true Selected = true
}); });
ViewData["partitionsPieData"] = partitionsPieData; ViewData["partitionsPieData"] = partitionsPieData;
} }
if(ctx.Filesystems.Any()) if (ctx.Filesystems.Any())
{ {
ViewBag.repFilesystems = ctx.Filesystems.OrderBy(filter => filter.Name).ToList(); 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 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; top10FilesystemCount += filesystem.Count;
filesystemsPieData.Add(new PieSeriesData filesystemsPieData.Add(new PieSeriesData
{ {
Name = filesystem.Name, Name = filesystem.Name,
Y = (double?)(filesystem.Count / totalFilesystemsCount) Y = (double?) (filesystem.Count / totalFilesystemsCount)
}); });
} }
filesystemsPieData.Add(new PieSeriesData filesystemsPieData.Add(new PieSeriesData
{ {
Name = "Other", Name = "Other",
Y = (double?)((totalFilesystemsCount - top10FilesystemCount) / Y = (double?) ((totalFilesystemsCount - top10FilesystemCount) /
totalFilesystemsCount), totalFilesystemsCount),
Sliced = true, Sliced = true,
Selected = true Selected = true
}); });
ViewData["filesystemsPieData"] = filesystemsPieData; ViewData["filesystemsPieData"] = filesystemsPieData;
} }
if(ctx.Medias.Any()) if (ctx.Medias.Any())
{ {
realMedia = new List<MediaItem>(); realMedia = new List<MediaItem>();
virtualMedia = new List<MediaItem>(); virtualMedia = new List<MediaItem>();
foreach(Media nvs in ctx.Medias) foreach (var nvs in ctx.Medias)
try try
{ {
MediaType MediaType
.MediaTypeToString((CommonTypes.MediaType)Enum.Parse(typeof(CommonTypes.MediaType), nvs.Type), .MediaTypeToString(
out string type, out string subtype); (CommonTypes.MediaType) Enum.Parse(typeof(CommonTypes.MediaType), nvs.Type),
out var type, out var subtype);
if(nvs.Real) if (nvs.Real)
realMedia.Add(new MediaItem {Type = type, SubType = subtype, Count = nvs.Count}); realMedia.Add(new MediaItem {Type = type, SubType = subtype, Count = nvs.Count});
else virtualMedia.Add(new MediaItem {Type = type, SubType = subtype, Count = nvs.Count}); else virtualMedia.Add(new MediaItem {Type = type, SubType = subtype, Count = nvs.Count});
} }
catch catch
{ {
if(nvs.Real) if (nvs.Real)
realMedia.Add(new MediaItem {Type = nvs.Type, SubType = null, Count = nvs.Count}); 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}); else virtualMedia.Add(new MediaItem {Type = nvs.Type, SubType = null, Count = nvs.Count});
} }
if(realMedia.Count > 0) if (realMedia.Count > 0)
{ {
ViewBag.repRealMedia = ViewBag.repRealMedia =
realMedia.OrderBy(media => media.Type).ThenBy(media => media.SubType).ToList(); 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 totalRealMediaCount = realMedia.Sum(o => o.Count);
decimal top10RealMediaCount = 0; 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; top10RealMediaCount += realMediaItem.Count;
realMediaPieData.Add(new PieSeriesData realMediaPieData.Add(new PieSeriesData
{ {
Name = $"{realMediaItem.Type} ({realMediaItem.SubType})", Name = $"{realMediaItem.Type} ({realMediaItem.SubType})",
Y = (double?)(realMediaItem.Count / totalRealMediaCount) Y = (double?) (realMediaItem.Count / totalRealMediaCount)
}); });
} }
realMediaPieData.Add(new PieSeriesData realMediaPieData.Add(new PieSeriesData
{ {
Name = "Other", Name = "Other",
Y = (double?)((totalRealMediaCount - top10RealMediaCount) / Y = (double?) ((totalRealMediaCount - top10RealMediaCount) /
totalRealMediaCount), totalRealMediaCount),
Sliced = true, Sliced = true,
Selected = true Selected = true
}); });
ViewData["realMediaPieData"] = realMediaPieData; ViewData["realMediaPieData"] = realMediaPieData;
} }
if(virtualMedia.Count > 0) if (virtualMedia.Count > 0)
{ {
ViewBag.repVirtualMedia = ViewBag.repVirtualMedia =
virtualMedia.OrderBy(media => media.Type).ThenBy(media => media.SubType).ToList(); 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 totalVirtualMediaCount = virtualMedia.Sum(o => o.Count);
decimal top10VirtualMediaCount = 0; 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; top10VirtualMediaCount += virtualMediaItem.Count;
@@ -413,8 +412,8 @@ namespace DiscImageChef.Server.Controllers
{ {
Name = Name =
$"{virtualMediaItem.Type} ({virtualMediaItem.SubType})", $"{virtualMediaItem.Type} ({virtualMediaItem.SubType})",
Y = (double?)(virtualMediaItem.Count / Y = (double?) (virtualMediaItem.Count /
totalVirtualMediaCount) totalVirtualMediaCount)
}); });
} }
@@ -424,7 +423,7 @@ namespace DiscImageChef.Server.Controllers
Y = (double?) Y = (double?)
((totalVirtualMediaCount - top10VirtualMediaCount) / ((totalVirtualMediaCount - top10VirtualMediaCount) /
totalVirtualMediaCount), totalVirtualMediaCount),
Sliced = true, Sliced = true,
Selected = true Selected = true
}); });
@@ -432,93 +431,100 @@ namespace DiscImageChef.Server.Controllers
} }
} }
if(ctx.DeviceStats.Any()) if (ctx.DeviceStats.Any())
{ {
devices = new List<DeviceItem>(); devices = new List<DeviceItem>();
foreach(DeviceStat device in ctx.DeviceStats.ToList()) foreach (var device in ctx.DeviceStats.ToList())
{ {
string xmlFile; string xmlFile;
if(!string.IsNullOrWhiteSpace(device.Manufacturer) && if (!string.IsNullOrWhiteSpace(device.Manufacturer) &&
!string.IsNullOrWhiteSpace(device.Model) && !string.IsNullOrWhiteSpace(device.Model) &&
!string.IsNullOrWhiteSpace(device.Revision)) !string.IsNullOrWhiteSpace(device.Revision))
xmlFile = device.Manufacturer + "_" + device.Model + "_" + device.Revision + ".xml"; xmlFile = device.Manufacturer + "_" + device.Model + "_" + device.Revision + ".xml";
else if(!string.IsNullOrWhiteSpace(device.Manufacturer) && else if (!string.IsNullOrWhiteSpace(device.Manufacturer) &&
!string.IsNullOrWhiteSpace(device.Model)) !string.IsNullOrWhiteSpace(device.Model))
xmlFile = device.Manufacturer + "_" + device.Model + ".xml"; xmlFile = device.Manufacturer + "_" + device.Model + ".xml";
else if(!string.IsNullOrWhiteSpace(device.Model) && !string.IsNullOrWhiteSpace(device.Revision)) else if (!string.IsNullOrWhiteSpace(device.Model) &&
xmlFile = device.Model + "_" + device.Revision + ".xml"; !string.IsNullOrWhiteSpace(device.Revision))
else xmlFile = device.Model + ".xml"; xmlFile = device.Model + "_" + device.Revision + ".xml";
else xmlFile = device.Model + ".xml";
xmlFile = xmlFile.Replace('/', '_').Replace('\\', '_').Replace('?', '_'); 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()); var xs = new XmlSerializer(deviceReport.GetType());
FileStream fs = var fs =
WaitForFile(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(), "Reports", xmlFile), WaitForFile(
FileMode.Open, FileAccess.Read, FileShare.Read); Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(),
deviceReport = (DeviceReport)xs.Deserialize(fs); "Reports", xmlFile),
FileMode.Open, FileAccess.Read, FileShare.Read);
deviceReport = (DeviceReport) xs.Deserialize(fs);
fs.Close(); fs.Close();
DeviceReportV2 deviceReportV2 = new DeviceReportV2(deviceReport); var deviceReportV2 = new DeviceReportV2(deviceReport);
device.Report = ctx.Devices.Add(new Device(deviceReportV2)).Entity; device.Report = ctx.Devices.Add(new Device(deviceReportV2)).Entity;
ctx.SaveChanges(); ctx.SaveChanges();
System.IO.File System.IO.File
.Delete(Path.Combine(_environment.ContentRootPath ?? throw new InvalidOperationException(), .Delete(Path.Combine(
"Reports", xmlFile)); _environment.ContentRootPath ?? throw new InvalidOperationException(),
"Reports", xmlFile));
} }
devices.Add(new DeviceItem devices.Add(new DeviceItem
{ {
Manufacturer = device.Manufacturer, Manufacturer = device.Manufacturer,
Model = device.Model, Model = device.Model,
Revision = device.Revision, Revision = device.Revision,
Bus = device.Bus, Bus = device.Bus,
ReportId = device.Report != null && device.Report.Id != 0 ReportId = device.Report != null && device.Report.Id != 0
? device.Report.Id ? device.Report.Id
: 0 : 0
}); });
} }
ViewBag.repDevices = devices.OrderBy(device => device.Manufacturer).ThenBy(device => device.Model) ViewBag.repDevices = devices.OrderBy(device => device.Manufacturer).ThenBy(device => device.Model)
.ThenBy(device => device.Revision).ThenBy(device => device.Bus) .ThenBy(device => device.Revision).ThenBy(device => device.Bus)
.ToList(); .ToList();
ViewData["devicesBusPieData"] = (from deviceBus in devices.Select(d => d.Bus).Distinct() ViewData["devicesBusPieData"] = (from deviceBus in devices.Select(d => d.Bus).Distinct()
let deviceBusCount = devices.Count(d => d.Bus == deviceBus) let deviceBusCount = devices.Count(d => d.Bus == deviceBus)
select new PieSeriesData select new PieSeriesData
{ {
Name = deviceBus, Name = deviceBus,
Y = deviceBusCount / (double)devices.Count Y = deviceBusCount / (double) devices.Count
}).ToList(); }).ToList();
ViewData["devicesManufacturerPieData"] = ViewData["devicesManufacturerPieData"] =
(from manufacturer in (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() .Distinct()
let manufacturerCount = devices.Count(d => d.Manufacturer?.ToLowerInvariant() == manufacturer) let manufacturerCount =
select new PieSeriesData {Name = manufacturer, Y = manufacturerCount / (double)devices.Count}) devices.Count(d => d.Manufacturer?.ToLowerInvariant() == manufacturer)
.ToList(); select new PieSeriesData
{Name = manufacturer, Y = manufacturerCount / (double) devices.Count})
.ToList();
} }
} }
catch(Exception) catch (Exception)
{ {
#if DEBUG #if DEBUG
throw; throw;
#endif #endif
return Content("Could not read statistics"); return Content("Could not read statistics");
} }
return View(); 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; FileStream fs = null;
try try
@@ -526,7 +532,7 @@ namespace DiscImageChef.Server.Controllers
fs = new FileStream(fullPath, mode, access, share); fs = new FileStream(fullPath, mode, access, share);
return fs; return fs;
} }
catch(IOException) catch (IOException)
{ {
fs?.Dispose(); fs?.Dispose();
Thread.Sleep(50); Thread.Sleep(50);

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

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

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

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

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

@@ -35,16 +35,12 @@ using System.Diagnostics;
using System.IO; using System.IO;
using System.Linq; using System.Linq;
using System.Net; using System.Net;
using System.Net.Http;
using System.Text;
using System.Threading; using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
using System.Web;
using System.Xml.Serialization; using System.Xml.Serialization;
using DiscImageChef.CommonTypes.Metadata; using DiscImageChef.CommonTypes.Metadata;
using DiscImageChef.Server.Models; using DiscImageChef.Server.Models;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json; using Newtonsoft.Json;
using OperatingSystem = DiscImageChef.Server.Models.OperatingSystem; using OperatingSystem = DiscImageChef.Server.Models.OperatingSystem;
@@ -54,7 +50,7 @@ namespace DiscImageChef.Server.Controllers
{ {
public class UploadStatsController : Controller public class UploadStatsController : Controller
{ {
DicServerContext _ctx; private readonly DicServerContext _ctx;
private IWebHostEnvironment _environment; private IWebHostEnvironment _environment;
public UploadStatsController(IWebHostEnvironment environment, DicServerContext ctx) public UploadStatsController(IWebHostEnvironment environment, DicServerContext ctx)
@@ -62,6 +58,7 @@ namespace DiscImageChef.Server.Controllers
_environment = environment; _environment = environment;
_ctx = ctx; _ctx = ctx;
} }
/// <summary> /// <summary>
/// Receives statistics from DiscImageChef.Core, processes them and adds them to a server-side global statistics XML /// Receives statistics from DiscImageChef.Core, processes them and adds them to a server-side global statistics XML
/// </summary> /// </summary>
@@ -70,17 +67,18 @@ namespace DiscImageChef.Server.Controllers
[HttpPost] [HttpPost]
public async Task<IActionResult> UploadStats() 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 try
{ {
Stats newStats = new Stats(); var newStats = new Stats();
HttpRequest request = HttpContext.Request; var request = HttpContext.Request;
XmlSerializer xs = new XmlSerializer(newStats.GetType()); var xs = new XmlSerializer(newStats.GetType());
newStats = (Stats) xs.Deserialize(new StringReader(await new StreamReader(request.Body).ReadToEndAsync())); newStats = (Stats) xs.Deserialize(
new StringReader(await new StreamReader(request.Body).ReadToEndAsync()));
if(newStats == null) if (newStats == null)
{ {
response.Content = "notstats"; response.Content = "notstats";
return response; return response;
@@ -91,11 +89,11 @@ namespace DiscImageChef.Server.Controllers
response.Content = "ok"; response.Content = "ok";
return response; return response;
} }
catch(Exception ex) catch (Exception ex)
{ {
#if DEBUG #if DEBUG
if(Debugger.IsAttached) throw; if (Debugger.IsAttached) throw;
#endif #endif
response.Content = "error"; response.Content = "error";
return response; return response;
} }
@@ -109,119 +107,120 @@ namespace DiscImageChef.Server.Controllers
[HttpPost] [HttpPost]
public async Task<IActionResult> UploadStatsV2() 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 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(); 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"; response.Content = "notstats";
return response; return response;
} }
if(newstats.Commands != null) if (newstats.Commands != null)
foreach(NameValueStats nvs in newstats.Commands) 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; else existing.Count += nvs.Value;
} }
if(newstats.Versions != null) if (newstats.Versions != null)
foreach(NameValueStats nvs in newstats.Versions) 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; else existing.Count += nvs.Value;
} }
if(newstats.Filesystems != null) if (newstats.Filesystems != null)
foreach(NameValueStats nvs in newstats.Filesystems) 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; else existing.Count += nvs.Value;
} }
if(newstats.Partitions != null) if (newstats.Partitions != null)
foreach(NameValueStats nvs in newstats.Partitions) 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; else existing.Count += nvs.Value;
} }
if(newstats.MediaFormats != null) if (newstats.MediaFormats != null)
foreach(NameValueStats nvs in newstats.MediaFormats) 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; else existing.Count += nvs.Value;
} }
if(newstats.Filters != null) if (newstats.Filters != null)
foreach(NameValueStats nvs in newstats.Filters) 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; else existing.Count += nvs.Value;
} }
if(newstats.OperatingSystems != null) if (newstats.OperatingSystems != null)
foreach(OsStats operatingSystem in newstats.OperatingSystems) foreach (var operatingSystem in newstats.OperatingSystems)
{ {
OperatingSystem existing = var existing =
_ctx.OperatingSystems.FirstOrDefault(c => c.Name == operatingSystem.name && _ctx.OperatingSystems.FirstOrDefault(c => c.Name == operatingSystem.name &&
c.Version == operatingSystem.version); c.Version == operatingSystem.version);
if(existing == null) if (existing == null)
_ctx.OperatingSystems.Add(new OperatingSystem _ctx.OperatingSystems.Add(new OperatingSystem
{ {
Name = operatingSystem.name, Name = operatingSystem.name,
Version = operatingSystem.version, Version = operatingSystem.version,
Count = operatingSystem.Value Count = operatingSystem.Value
}); });
else existing.Count += operatingSystem.Value; else existing.Count += operatingSystem.Value;
} }
if(newstats.Medias != null) if (newstats.Medias != null)
foreach(MediaStats media in newstats.Medias) 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}); _ctx.Medias.Add(new Media {Type = media.type, Real = media.real, Count = media.Value});
else existing.Count += media.Value; else existing.Count += media.Value;
} }
if(newstats.Devices != null) if (newstats.Devices != null)
foreach(DeviceStats device in newstats.Devices) foreach (var device in newstats.Devices)
{ {
DeviceStat existing = var existing =
_ctx.DeviceStats.FirstOrDefault(c => c.Bus == device.Bus && _ctx.DeviceStats.FirstOrDefault(c => c.Bus == device.Bus &&
c.Manufacturer == device.Manufacturer && c.Manufacturer == device.Manufacturer &&
c.Model == device.Model && c.Model == device.Model &&
c.Revision == device.Revision); c.Revision == device.Revision);
if(existing == null) if (existing == null)
_ctx.DeviceStats.Add(new DeviceStat _ctx.DeviceStats.Add(new DeviceStat
{ {
Bus = device.Bus, Bus = device.Bus,
Manufacturer = device.Manufacturer, Manufacturer = device.Manufacturer,
Model = device.Model, Model = device.Model,
Revision = device.Revision Revision = device.Revision
}); });
} }
@@ -233,17 +232,17 @@ namespace DiscImageChef.Server.Controllers
// ReSharper disable once RedundantCatchClause // ReSharper disable once RedundantCatchClause
catch catch
{ {
#if DEBUG #if DEBUG
if(Debugger.IsAttached) throw; if (Debugger.IsAttached) throw;
#endif #endif
response.Content = "error"; response.Content = "error";
return response; 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; FileStream fs = null;
try try
@@ -251,9 +250,9 @@ namespace DiscImageChef.Server.Controllers
fs = new FileStream(fullPath, mode, access, share); fs = new FileStream(fullPath, mode, access, share);
return fs; return fs;
} }
catch(IOException) catch (IOException)
{ {
if(fs != null) fs.Dispose(); if (fs != null) fs.Dispose();
Thread.Sleep(50); 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;
using System.Collections.Generic; using System.Collections.Generic;
using System.ComponentModel.DataAnnotations.Schema;
using DiscImageChef.CommonTypes.Metadata; using DiscImageChef.CommonTypes.Metadata;
namespace DiscImageChef.Server.Models namespace DiscImageChef.Server.Models
{ {
public class CompactDiscOffset : CdOffset public class CompactDiscOffset : CdOffset
{ {
public CompactDiscOffset() { } public CompactDiscOffset()
{
}
public CompactDiscOffset(string manufacturer, string model, short offset, int submissions, float agreement) public CompactDiscOffset(string manufacturer, string model, short offset, int submissions, float agreement)
{ {
Manufacturer = manufacturer; Manufacturer = manufacturer;
Model = model; Model = model;
Offset = offset; Offset = offset;
Submissions = submissions; Submissions = submissions;
Agreement = agreement; Agreement = agreement;
AddedWhen = ModifiedWhen = DateTime.UtcNow; AddedWhen = ModifiedWhen = DateTime.UtcNow;
} }
public CompactDiscOffset(CdOffset offset) public CompactDiscOffset(CdOffset offset)
{ {
Manufacturer = offset.Manufacturer; Manufacturer = offset.Manufacturer;
Model = offset.Model; Model = offset.Model;
Offset = offset.Offset; Offset = offset.Offset;
Submissions = offset.Submissions; Submissions = offset.Submissions;
Agreement = offset.Agreement; Agreement = offset.Agreement;
AddedWhen = ModifiedWhen = DateTime.UtcNow; AddedWhen = ModifiedWhen = DateTime.UtcNow;
} }
public int Id { get; set; } public int Id { get; set; }
public DateTime AddedWhen { get; set; } public DateTime AddedWhen { get; set; }
public DateTime ModifiedWhen { get; set; } public DateTime ModifiedWhen { get; set; }
public virtual ICollection<Device> Devices { 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 public class Command
{ {
[Key] [Key] public int Id { get; set; }
public int Id { get; set; }
public string Name { get; set; } public string Name { get; set; }
public long Count { 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 sealed class DicServerContext : DbContext
{ {
public DbSet<Device> Devices { get; set; } public DicServerContext()
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(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) protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{ {
if(optionsBuilder.IsConfigured) return; if (optionsBuilder.IsConfigured) return;
var builder = new ConfigurationBuilder().AddJsonFile("appsettings.json"); var builder = new ConfigurationBuilder().AddJsonFile("appsettings.json");
@@ -82,7 +86,7 @@ namespace DiscImageChef.Server.Models
internal static bool TableExists(string tableName) internal static bool TableExists(string tableName)
{ {
using(var db = new DicServerContext()) using (var db = new DicServerContext())
{ {
var connection = db.Database.GetDbConnection(); var connection = db.Database.GetDbConnection();
connection.Open(); connection.Open();
@@ -91,7 +95,7 @@ namespace DiscImageChef.Server.Models
command.CommandText = command.CommandText =
$"SELECT COUNT(*) FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA=DATABASE() AND TABLE_NAME=\"{tableName}\""; $"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; return result != 0;
} }

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

@@ -32,7 +32,6 @@
using System; using System;
using System.ComponentModel; using System.ComponentModel;
using System.ComponentModel.DataAnnotations.Schema;
using DiscImageChef.CommonTypes.Metadata; using DiscImageChef.CommonTypes.Metadata;
namespace DiscImageChef.Server.Models namespace DiscImageChef.Server.Models
@@ -46,27 +45,27 @@ namespace DiscImageChef.Server.Models
public Device(DeviceReportV2 report) public Device(DeviceReportV2 report)
{ {
ATA = report.ATA; ATA = report.ATA;
ATAPI = report.ATAPI; ATAPI = report.ATAPI;
CompactFlash = report.CompactFlash; CompactFlash = report.CompactFlash;
FireWire = report.FireWire; FireWire = report.FireWire;
AddedWhen = DateTime.UtcNow; AddedWhen = DateTime.UtcNow;
ModifiedWhen = DateTime.UtcNow; ModifiedWhen = DateTime.UtcNow;
MultiMediaCard = report.MultiMediaCard; MultiMediaCard = report.MultiMediaCard;
PCMCIA = report.PCMCIA; PCMCIA = report.PCMCIA;
SCSI = report.SCSI; SCSI = report.SCSI;
SecureDigital = report.SecureDigital; SecureDigital = report.SecureDigital;
USB = report.USB; USB = report.USB;
Manufacturer = report.Manufacturer; Manufacturer = report.Manufacturer;
Model = report.Model; Model = report.Model;
Revision = report.Revision; Revision = report.Revision;
Type = report.Type; Type = report.Type;
} }
public DateTime AddedWhen { get; set; } public DateTime AddedWhen { get; set; }
public DateTime? ModifiedWhen { get; set; } public DateTime? ModifiedWhen { get; set; }
public virtual CompactDiscOffset CdOffset { 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 class DeviceItem
{ {
public string Manufacturer { get; set; } public string Manufacturer { get; set; }
public string Model { get; set; } public string Model { get; set; }
public string Revision { get; set; } public string Revision { get; set; }
public string Bus { get; set; } public string Bus { get; set; }
public int ReportId { 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 public class DeviceStat
{ {
[Key] [Key] public int Id { get; set; }
public int Id { get; set; }
public string Manufacturer { get; set; } public string Manufacturer { get; set; }
public string Model { get; set; } public string Model { get; set; }
public string Revision { get; set; } public string Revision { get; set; }
public string Bus { get; set; } public string Bus { get; set; }
public virtual Device Report { 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 namespace DiscImageChef.Server.Models
{ {
public class ErrorViewModel public class ErrorViewModel

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

@@ -36,9 +36,9 @@ namespace DiscImageChef.Server.Models
{ {
public class Filesystem public class Filesystem
{ {
[Key] [Key] public int Id { get; set; }
public int Id { get; set; }
public string Name { get; set; } public string Name { get; set; }
public long Count { 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 public class Filter
{ {
[Key] [Key] public int Id { get; set; }
public int Id { get; set; }
public string Name { get; set; } public string Name { get; set; }
public long Count { 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 public class Media
{ {
[Key] [Key] public int Id { get; set; }
public int Id { get; set; }
public string Type { get; set; } public string Type { get; set; }
public bool Real { get; set; } public bool Real { get; set; }
public long Count { 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 public class MediaFormat
{ {
[Key] [Key] public int Id { get; set; }
public int Id { get; set; }
public string Name { get; set; } public string Name { get; set; }
public long Count { 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 class MediaItem
{ {
public string Type { get; set; } public string Type { get; set; }
public string SubType { 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 public class OperatingSystem
{ {
[Key] [Key] public int Id { get; set; }
public int Id { get; set; }
public string Name { get; set; } public string Name { get; set; }
public string Version { 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 public class Partition
{ {
[Key] [Key] public int Id { get; set; }
public int Id { get; set; }
public string Name { get; set; } public string Name { get; set; }
public long Count { 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) public UploadedReport(DeviceReportV2 report)
{ {
ATA = report.ATA; ATA = report.ATA;
ATAPI = report.ATAPI; ATAPI = report.ATAPI;
CompactFlash = report.CompactFlash; CompactFlash = report.CompactFlash;
FireWire = report.FireWire; FireWire = report.FireWire;
UploadedWhen = DateTime.UtcNow; UploadedWhen = DateTime.UtcNow;
MultiMediaCard = report.MultiMediaCard; MultiMediaCard = report.MultiMediaCard;
PCMCIA = report.PCMCIA; PCMCIA = report.PCMCIA;
SCSI = report.SCSI; SCSI = report.SCSI;
SecureDigital = report.SecureDigital; SecureDigital = report.SecureDigital;
USB = report.USB; USB = report.USB;
Manufacturer = report.Manufacturer; Manufacturer = report.Manufacturer;
Model = report.Model; Model = report.Model;
Revision = report.Revision; Revision = report.Revision;
Type = report.Type; Type = report.Type;
} }
public DateTime UploadedWhen { get; set; } public DateTime UploadedWhen { get; set; }

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

@@ -32,31 +32,32 @@
using System; using System;
using System.ComponentModel.DataAnnotations; using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using Newtonsoft.Json; using Newtonsoft.Json;
namespace DiscImageChef.Server.Models namespace DiscImageChef.Server.Models
{ {
public class UsbProduct public class UsbProduct
{ {
public UsbProduct() { } public UsbProduct()
{
}
public UsbProduct(UsbVendor vendor, ushort id, string product) public UsbProduct(UsbVendor vendor, ushort id, string product)
{ {
ProductId = id; ProductId = id;
Product = product; Product = product;
AddedWhen = ModifiedWhen = DateTime.UtcNow; AddedWhen = ModifiedWhen = DateTime.UtcNow;
Vendor = vendor; Vendor = vendor;
} }
[Key] [Key] public int Id { get; set; }
public int Id { get; set; }
public int ProductId { get; set; } public int ProductId { get; set; }
public string Product { get; set; } public string Product { get; set; }
public DateTime AddedWhen { get; set; } public DateTime AddedWhen { get; set; }
public DateTime ModifiedWhen { get; set; } public DateTime ModifiedWhen { get; set; }
public int VendorId { 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;
using System.Collections.Generic; using System.Collections.Generic;
using System.ComponentModel.DataAnnotations; using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using Newtonsoft.Json; using Newtonsoft.Json;
namespace DiscImageChef.Server.Models namespace DiscImageChef.Server.Models
{ {
public class UsbVendor public class UsbVendor
{ {
public UsbVendor() { } public UsbVendor()
{
}
public UsbVendor(ushort id, string vendor) public UsbVendor(ushort id, string vendor)
{ {
VendorId = id; VendorId = id;
Vendor = vendor; Vendor = vendor;
AddedWhen = ModifiedWhen = DateTime.UtcNow; AddedWhen = ModifiedWhen = DateTime.UtcNow;
} }
[Key] [Key] public int Id { get; set; }
public int Id { get; set; }
public int VendorId { get; set; } public int VendorId { get; set; }
public string Vendor { get; set; } public string Vendor { get; set; }
public DateTime AddedWhen { get; set; } public DateTime AddedWhen { get; set; }
public DateTime ModifiedWhen { get; set; } public DateTime ModifiedWhen { get; set; }
[JsonIgnore] [JsonIgnore] public virtual ICollection<UsbProduct> Products { get; set; }
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 public class Version
{ {
[Key] [Key] public int Id { get; set; }
public int Id { get; set; }
public string Value { 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;
using System.Collections.Generic; using DiscImageChef.CommonTypes.Interop;
using System.Linq;
using System.Threading.Tasks;
using DiscImageChef.Server.Models; using DiscImageChef.Server.Models;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting; using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging; using Version = DiscImageChef.CommonTypes.Interop.Version;
namespace DiscImageChef.Server namespace DiscImageChef.Server
{ {
@@ -19,68 +16,68 @@ namespace DiscImageChef.Server
DateTime start; DateTime start;
DateTime end; DateTime end;
System.Console.Clear(); System.Console.Clear();
System.Console.Write( System.Console.Write(
"\u001b[32m . ,,\n" + "\u001b[32m . ,,\n" +
"\u001b[32m ;,. '0d.\n" + "\u001b[32m ;,. '0d.\n" +
"\u001b[32m oc oWd \u001b[31m" + "\u001b[32m oc oWd \u001b[31m" +
@"________/\\\\\\\\\___/\\\\\\\\\\\_________/\\\\\\\\\___/\\\\____________/\\\\_" + @"________/\\\\\\\\\___/\\\\\\\\\\\_________/\\\\\\\\\___/\\\\____________/\\\\_" +
"\n\u001b[0m" + "\n\u001b[0m" +
"\u001b[32m ;X. 'WN' \u001b[31m" + "\u001b[32m ;X. 'WN' \u001b[31m" +
@" _____/\\\////////___\/////\\\///_______/\\\////////___\/\\\\\\________/\\\\\\_" + @" _____/\\\////////___\/////\\\///_______/\\\////////___\/\\\\\\________/\\\\\\_" +
"\n\u001b[0m" + "\n\u001b[0m" +
"\u001b[32m oMo cMM: \u001b[31m" + "\u001b[32m oMo cMM: \u001b[31m" +
@" ___/\\\/________________\/\\\________/\\\/____________\/\\\//\\\____/\\\//\\\_" + @" ___/\\\/________________\/\\\________/\\\/____________\/\\\//\\\____/\\\//\\\_" +
"\n\u001b[0m" + "\n\u001b[0m" +
"\u001b[32m ;MM. .MMM; \u001b[31m" + "\u001b[32m ;MM. .MMM; \u001b[31m" +
@" __/\\\__________________\/\\\_______/\\\______________\/\\\\///\\\/\\\/_\/\\\_" + @" __/\\\__________________\/\\\_______/\\\______________\/\\\\///\\\/\\\/_\/\\\_" +
"\n\u001b[0m" + "\n\u001b[0m" +
"\u001b[32m NMM WMMW \u001b[31m" + "\u001b[32m NMM WMMW \u001b[31m" +
@" _\/\\\__________________\/\\\______\/\\\______________\/\\\__\///\\\/___\/\\\_" + @" _\/\\\__________________\/\\\______\/\\\______________\/\\\__\///\\\/___\/\\\_" +
"\n\u001b[0m" + "\n\u001b[0m" +
"\u001b[32m 'MMM MMMM; \u001b[31m" + "\u001b[32m 'MMM MMMM; \u001b[31m" +
@" _\//\\\_________________\/\\\______\//\\\_____________\/\\\____\///_____\/\\\_" + @" _\//\\\_________________\/\\\______\//\\\_____________\/\\\____\///_____\/\\\_" +
"\n\u001b[0m" + "\n\u001b[0m" +
"\u001b[32m ,MMM: dMMMM: \u001b[31m" + "\u001b[32m ,MMM: dMMMM: \u001b[31m" +
@" __\///\\\_______________\/\\\_______\///\\\___________\/\\\_____________\/\\\_" + @" __\///\\\_______________\/\\\_______\///\\\___________\/\\\_____________\/\\\_" +
"\n\u001b[0m" + "\n\u001b[0m" +
"\u001b[32m .MMMW. :MMMMM. \u001b[31m" + "\u001b[32m .MMMW. :MMMMM. \u001b[31m" +
@" ____\////\\\\\\\\\___/\\\\\\\\\\\_____\////\\\\\\\\\__\/\\\_____________\/\\\_" + @" ____\////\\\\\\\\\___/\\\\\\\\\\\_____\////\\\\\\\\\__\/\\\_____________\/\\\_" +
"\n\u001b[0m" + "\n\u001b[0m" +
"\u001b[32m XMMMW: .:xKNMMMMMMN0d, lMMMMMd \u001b[31m" + "\u001b[32m XMMMW: .:xKNMMMMMMN0d, lMMMMMd \u001b[31m" +
@" _______\/////////___\///////////_________\/////////___\///______________\///__" + @" _______\/////////___\///////////_________\/////////___\///______________\///__" +
"\n\u001b[0m" + "\n\u001b[0m" +
"\u001b[32m :MMMMMK; cWMNkl:;;;:lxKMXc .0MMMMMO\u001b[0m\n" + "\u001b[32m :MMMMMK; cWMNkl:;;;:lxKMXc .0MMMMMO\u001b[0m\n" +
"\u001b[32m ..KMMMMMMNo,. ,OMMMMMMW:,. \u001b[37;1m DiscImageChef Website\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 .;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 :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 ;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 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 OMNc .MNc oWMMk 'WMMNl. .MMK ;KX.\u001b[0m\n" +
"\u001b[32m xMO WMN ; ., , ': ,MMx lK\u001b[0m\n" + "\u001b[32m xMO WMN ; ., , ': ,MMx lK\u001b[0m\n" +
"\u001b[32m ,Md cMMl .XMMMWWMMMO XMW. :\u001b[0m\n" + "\u001b[32m ,Md cMMl .XMMMWWMMMO XMW. :\u001b[0m\n" +
"\u001b[32m Ok xMMl XMMMMMMMMc 0MW,\u001b[0m\n" + "\u001b[32m Ok xMMl XMMMMMMMMc 0MW,\u001b[0m\n" +
"\u001b[32m 0 oMM0' lMMMMMMMM. :NMN'\u001b[0m\n" + "\u001b[32m 0 oMM0' lMMMMMMMM. :NMN'\u001b[0m\n" +
"\u001b[32m . .0MMKl ;MMMMMMMM oNMWd\u001b[0m\n" + "\u001b[32m . .0MMKl ;MMMMMMMM oNMWd\u001b[0m\n" +
"\u001b[32m .dNW cMMMMMMMM, XKl\u001b[0m\n" + "\u001b[32m .dNW cMMMMMMMM, XKl\u001b[0m\n" +
"\u001b[32m 0MMMMMMMMK\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 ;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 'WMMMMKxMMMMM0 \u001b[34;1m Natalia Portillo\u001b[0m\n" +
"\u001b[32m oMMMMNc :WMMMMN:\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 .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 .......,cd0WMMNk: c0MMMMMWKkolc:clodc'\u001b[0m\n" +
"\u001b[32m .';loddol:'. ':oxkkOkkxoc,.\u001b[0m\n" + "\u001b[32m .';loddol:'. ':oxkkOkkxoc,.\u001b[0m\n" +
"\u001b[0m\n", DiscImageChef.CommonTypes.Interop.Version.GetVersion(), "\u001b[0m\n", Version.GetVersion(),
#if DEBUG #if DEBUG
"DEBUG" "DEBUG"
#else #else
"RELEASE" "RELEASE"
#endif #endif
, DiscImageChef.CommonTypes.Interop.DetectOS.GetPlatformName(DiscImageChef.CommonTypes.Interop.DetectOS.GetRealPlatformID()), , DetectOS.GetPlatformName(DetectOS.GetRealPlatformID()),
Environment.Is64BitOperatingSystem ? 64 : 32, Environment.Is64BitProcess ? 64 : 32, Environment.Is64BitOperatingSystem ? 64 : 32, Environment.Is64BitProcess ? 64 : 32,
DiscImageChef.CommonTypes.Interop.DetectOS.IsMono ? "Mono" : ".NET Core", DetectOS.IsMono ? "Mono" : ".NET Core",
DiscImageChef.CommonTypes.Interop.DetectOS.IsMono ? DiscImageChef.CommonTypes.Interop.Version.GetMonoVersion() : DiscImageChef.CommonTypes.Interop.Version.GetNetCoreVersion()); DetectOS.IsMono ? Version.GetMonoVersion() : Version.GetNetCoreVersion());
var host = CreateHostBuilder(args).Build(); var host = CreateHostBuilder(args).Build();
@@ -97,15 +94,14 @@ namespace DiscImageChef.Server
context.Database.Migrate(); context.Database.Migrate();
end = DateTime.Now; end = DateTime.Now;
System.Console.WriteLine("\u001b[31;1mTook \u001b[32;1m{0} seconds\u001b[31;1m...\u001b[0m", 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"); 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); System.Console.WriteLine("\u001b[31;1mException: {0}\u001b[0m", ex.Message);
#endif #endif
return; return;
} }
} }
@@ -114,8 +110,10 @@ namespace DiscImageChef.Server
host.Run(); host.Run();
} }
public static IHostBuilder CreateHostBuilder(string[] args) => public static IHostBuilder CreateHostBuilder(string[] args)
Host.CreateDefaultBuilder(args) {
return Host.CreateDefaultBuilder(args)
.ConfigureWebHostDefaults(webBuilder => { webBuilder.UseStartup<Startup>(); }); .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 DiscImageChef.Server.Models;
using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.HttpsPolicy;
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration; using Microsoft.Extensions.Configuration;
@@ -56,8 +51,8 @@ namespace DiscImageChef.Server
app.UseEndpoints(endpoints => app.UseEndpoints(endpoints =>
{ {
endpoints.MapControllerRoute( endpoints.MapControllerRoute(
name: "default", "default",
pattern: "{controller=Home}/{action=Index}/{id?}"); "{controller=Home}/{action=Index}/{id?}");
}); });
} }
} }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -35,23 +35,23 @@
<html> <html>
<meta charset="UTF-8"> <meta charset="UTF-8">
<head> <head>
@switch(DateTime.UtcNow.DayOfYear) @switch (DateTime.UtcNow.DayOfYear)
{ {
// 24th January, Macintosh launch // 24th January, Macintosh launch
case 24: case 24:
<link href="~/css/mac/dicserver.css" <link href="~/css/mac/dicserver.css"
rel="stylesheet" type="text/css" /> rel="stylesheet" type="text/css"/>
<link href="~/css/mac/dicserver_highcharts.css" <link href="~/css/mac/dicserver_highcharts.css"
rel="stylesheet" type="text/css" /> rel="stylesheet" type="text/css"/>
break; break;
default: default:
<link href="~/css/dos/dicserver.css" <link href="~/css/dos/dicserver.css"
rel="stylesheet" type="text/css" /> rel="stylesheet" type="text/css"/>
<link href="~/css/dos/dicserver_highcharts.css" <link href="~/css/dos/dicserver_highcharts.css"
rel="stylesheet" type="text/css" /> rel="stylesheet" type="text/css"/>
break; break;
} }
<meta charset="utf-8" /> <meta charset="utf-8"/>
<title>@ViewBag.Title</title> <title>@ViewBag.Title</title>
<!-- Global site tag (gtag.js) - Google Analytics --> <!-- Global site tag (gtag.js) - Google Analytics -->
<script async <script async
@@ -73,8 +73,8 @@
<a href="http://www.claunia.com" <a href="http://www.claunia.com"
target="_blank"> target="_blank">
Claunia.com Claunia.com
</a><br /> </a><br/>
@switch(DateTime.UtcNow.DayOfYear) @switch (DateTime.UtcNow.DayOfYear)
{ {
// 24th January, Macintosh launch // 24th January, Macintosh launch
case 24: case 24:
@@ -86,7 +86,7 @@
; ;
break; break;
} }
<br /> <br/>
CSS © 2018-2019 CSS © 2018-2019
<a href="https://getbootstrap.com/" <a href="https://getbootstrap.com/"
target="_blank"> 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/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.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 // The Disc Image Chef
@@ -51,7 +46,7 @@
</i> Server version @ViewBag.Version </i> Server version @ViewBag.Version
</header> </header>
<div class="container-fluid mt-3"> <div class="container-fluid mt-3">
@if(ViewBag.repOperatingSystems != null) @if (ViewBag.repOperatingSystems != null)
{ {
<div class="container" <div class="container"
id="divOperatingSystems"> id="divOperatingSystems">
@@ -129,7 +124,7 @@
id="osCollapse"> id="osCollapse">
<div class="card-body"> <div class="card-body">
<table class="table-dark"> <table class="table-dark">
@foreach(NameValueStats os in ViewBag.repOperatingSystems) @foreach (NameValueStats os in ViewBag.repOperatingSystems)
{ {
<tr> <tr>
<td class="text-left"> <td class="text-left">
@@ -142,10 +137,10 @@
</div> </div>
</div> </div>
</div> </div>
<br /> <br/>
</div> </div>
} }
@if(ViewBag.repVersions != null) @if (ViewBag.repVersions != null)
{ {
<div class="container mt-3" <div class="container mt-3"
id="divVersions"> id="divVersions">
@@ -175,7 +170,7 @@
id="versionsCollapse"> id="versionsCollapse">
<div class="card-body"> <div class="card-body">
<table class="table-dark"> <table class="table-dark">
@foreach(NameValueStats version in ViewBag.repVersions) @foreach (NameValueStats version in ViewBag.repVersions)
{ {
<tr> <tr>
<td class="text-left"> <td class="text-left">
@@ -188,10 +183,10 @@
</div> </div>
</div> </div>
</div> </div>
<br /> <br/>
</div> </div>
} }
@if(ViewBag.repCommands != null) @if (ViewBag.repCommands != null)
{ {
<div class="container mt-3" <div class="container mt-3"
id="divCommands"> id="divCommands">
@@ -221,7 +216,7 @@
id="commandsCollapse"> id="commandsCollapse">
<div class="card-body"> <div class="card-body">
<table class="table-dark"> <table class="table-dark">
@foreach(Command command in ViewBag.repCommands) @foreach (Command command in ViewBag.repCommands)
{ {
<tr> <tr>
<td class="text-left"> <td class="text-left">
@@ -234,10 +229,10 @@
</div> </div>
</div> </div>
</div> </div>
<br /> <br/>
</div> </div>
} }
@if(ViewBag.repFilters != null) @if (ViewBag.repFilters != null)
{ {
<div class="container mt-3" <div class="container mt-3"
id="divFilters"> id="divFilters">
@@ -271,7 +266,7 @@
<th class="table-dark-header">Filter</th> <th class="table-dark-header">Filter</th>
<th class="table-dark-header">Times</th> <th class="table-dark-header">Times</th>
</tr> </tr>
@foreach(Filter filter in ViewBag.repFilters) @foreach (Filter filter in ViewBag.repFilters)
{ {
<tr> <tr>
<td class="text-right"> <td class="text-right">
@@ -289,7 +284,7 @@
</div> </div>
</div> </div>
} }
@if(ViewBag.repMediaImages != null) @if (ViewBag.repMediaImages != null)
{ {
<div class="container mt-3" <div class="container mt-3"
id="divMediaImages"> id="divMediaImages">
@@ -323,7 +318,7 @@
<th class="table-dark-header">Media image format</th> <th class="table-dark-header">Media image format</th>
<th class="table-dark-header">Times</th> <th class="table-dark-header">Times</th>
</tr> </tr>
@foreach(MediaFormat format in ViewBag.repMediaImages) @foreach (MediaFormat format in ViewBag.repMediaImages)
{ {
<tr> <tr>
<td class="text-left"> <td class="text-left">
@@ -341,7 +336,7 @@
</div> </div>
</div> </div>
} }
@if(ViewBag.repPartitions != null) @if (ViewBag.repPartitions != null)
{ {
<div class="container mt-3" <div class="container mt-3"
id="divPartitions"> id="divPartitions">
@@ -375,7 +370,7 @@
<th class="table-dark-header">Partitioning scheme</th> <th class="table-dark-header">Partitioning scheme</th>
<th class="table-dark-header">Times</th> <th class="table-dark-header">Times</th>
</tr> </tr>
@foreach(Partition partition in ViewBag.repPartitions) @foreach (Partition partition in ViewBag.repPartitions)
{ {
<tr> <tr>
<td class="text-left"> <td class="text-left">
@@ -393,7 +388,7 @@
</div> </div>
</div> </div>
} }
@if(ViewBag.repFilesystems != null) @if (ViewBag.repFilesystems != null)
{ {
<div class="container mt-3" <div class="container mt-3"
id="divFilesystems"> id="divFilesystems">
@@ -427,7 +422,7 @@
<th class="table-dark-header">Filesystem name</th> <th class="table-dark-header">Filesystem name</th>
<th class="table-dark-header">Times</th> <th class="table-dark-header">Times</th>
</tr> </tr>
@foreach(Filesystem filesystem in ViewBag.repFilesystems) @foreach (Filesystem filesystem in ViewBag.repFilesystems)
{ {
<tr> <tr>
<td class="text-left"> <td class="text-left">
@@ -445,7 +440,7 @@
</div> </div>
</div> </div>
} }
@if(ViewBag.repVirtualMedia != null) @if (ViewBag.repVirtualMedia != null)
{ {
<div class="container mt-3" <div class="container mt-3"
id="divVirtualMedia"> id="divVirtualMedia">
@@ -480,7 +475,7 @@
<th class="table-dark-header">Logical type</th> <th class="table-dark-header">Logical type</th>
<th class="table-dark-header">Times</th> <th class="table-dark-header">Times</th>
</tr> </tr>
@foreach(MediaItem media in ViewBag.repVirtualMedia) @foreach (MediaItem media in ViewBag.repVirtualMedia)
{ {
<tr> <tr>
<td class="text-left"> <td class="text-left">
@@ -501,7 +496,7 @@
</div> </div>
</div> </div>
} }
@if(ViewBag.repRealMedia != null) @if (ViewBag.repRealMedia != null)
{ {
<div class="container mt-3" <div class="container mt-3"
id="divRealMedia"> id="divRealMedia">
@@ -536,7 +531,7 @@
<th class="table-dark-header">Logical type</th> <th class="table-dark-header">Logical type</th>
<th class="table-dark-header">Times</th> <th class="table-dark-header">Times</th>
</tr> </tr>
@foreach(MediaItem media in ViewBag.repRealMedia) @foreach (MediaItem media in ViewBag.repRealMedia)
{ {
<tr> <tr>
<td class="text-left"> <td class="text-left">
@@ -557,7 +552,7 @@
</div> </div>
</div> </div>
} }
@if(ViewBag.repDevices != null) @if (ViewBag.repDevices != null)
{ {
<div class="container mt-3" <div class="container mt-3"
id="divDevices"> id="divDevices">
@@ -623,7 +618,7 @@
<th class="table-dark-header">Bus</th> <th class="table-dark-header">Bus</th>
<th class="table-dark-header">Report</th> <th class="table-dark-header">Report</th>
</tr> </tr>
@foreach(DeviceItem device in ViewBag.repDevices) @foreach (DeviceItem device in ViewBag.repDevices)
{ {
<tr> <tr>
<td> <td>
@@ -639,12 +634,14 @@
@device.Bus @device.Bus
</td> </td>
<td> <td>
@if(device.ReportId != 0) @if (device.ReportId != 0)
{ {
<text>@Html.ActionLink("Yes", "View", "Report", new {id = device.ReportId}, new {target = "_blank"})</text> <text>@Html.ActionLink("Yes", "View", "Report", new {id = device.ReportId}, new {target = "_blank"})</text>
} }
else else
{ <text>No</text> } {
<text>No</text>
}
</td> </td>
</tr> </tr>
} }
@@ -657,7 +654,7 @@
<script src="http://code.highcharts.com/highcharts.js"></script> <script src="http://code.highcharts.com/highcharts.js"></script>
<script src="https://code.highcharts.com/modules/exporting.js"></script> <script src="https://code.highcharts.com/modules/exporting.js"></script>
@{ @{
/* string highChartsTitleColor; /* string highChartsTitleColor;
string highChartsDataLabelColor; string highChartsDataLabelColor;
switch(DateTime.UtcNow.DayOfYear) switch(DateTime.UtcNow.DayOfYear)

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

@@ -1,3 +1,3 @@
@using DiscImageChef.Server @using DiscImageChef.Server
@using DiscImageChef.Server.Models @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"; Layout = "_Layout";
} }