public override void visit(DvdInfo dvdInfo)
{
this.setTitleBlurb("LB-DVD: " +
dvdInfo.getTitleName() +
", starring " +
dvdInfo.getStar() +
", encoding region: " +
dvdInfo.getEncodingRegion());
}
/*Sets the supplied order as paid and assigns a dvd copy to each orderLine (if possible).*/
public void payOrder(Order selectedOrder)
{
//set the order status to PAID
selectedOrder.orderstatus = new OrderStatusService().getByID("2"); //Throws NoRecordException
new OrderService().updateOrder(selectedOrder);
//assign copies to the orderlines
List <OrderLine> orderLines = new OrderLineService().getByOrder(selectedOrder); //Throws NoRecordException
foreach (OrderLine orderLine in orderLines)
{
if (orderLine.orderLineType.id == 1) //rent copy
{
DvdInfo thisDVD = orderLine.dvdInfo;
//get all unavailable dates starting from TODAY
Dictionary <int, List <DateTime> > dicCopyUnavailableDates = new AvailabilityModel().getAllUnavailableDaysPerCopyForDvdInfo(thisDVD, DateTime.Today); //Throws NoRecordException
Dictionary <int, int> dicDaysFreeForCopy = new Dictionary <int, int>(); //contains the number of free days for the dvdCopy (copy-id, freedays)
int selectedCopyId = -1; //id of the copy that will be assigned to this orderLine
//loop over the list of occupied dates per copy, check how many free dates exist around the chosen period, store that amount in dicDaysFreeForCopy
foreach (KeyValuePair <int, List <DateTime> > entry in dicCopyUnavailableDates)
{
//determine how many days the copy will be rented
int rentPeriodDays = (orderLine.enddate - orderLine.startdate).Days;
bool copyIsAvailable = true;
for (int i = 0; i <= rentPeriodDays; i++)
{
//loop over the occupied days, check if the copy is available on all of the requested dates
if (entry.Value.Contains(orderLine.startdate.AddDays(i)))
{
//one of the requested days is not free, this copy can not be used
copyIsAvailable = false;
}
}
if (copyIsAvailable)
{
//we now know this copy has the needed time available, now to determine the size of this free period
dicDaysFreeForCopy.Add(entry.Key, 0);
//check the amount of free days between start date and the first unavailable date (going backwards)
bool unavailableFound = false;
int offset = 0;
do
{
if (entry.Value.Contains(orderLine.startdate.AddDays(-offset)) || orderLine.startdate.AddDays(-offset) == DateTime.Today)
{
//the copy is reserved on this date, break out of loop
unavailableFound = true;
}
else
{
dicDaysFreeForCopy[entry.Key]++;
offset++;
}
} while (!unavailableFound);
//check the amount of free days between end date and the first unavailable date (going forward)
unavailableFound = false;
offset = 0;
do
{
if (entry.Value.Contains(orderLine.enddate.AddDays(offset)) || orderLine.enddate.AddDays(offset) >= DateTime.Today.AddDays(14))
{
//the copy is reserved on this date, break out of loop
unavailableFound = true;
}
else
{
dicDaysFreeForCopy[entry.Key]++;
offset++;
}
} while (!unavailableFound);
}
}
int daysFree = 1000;
//loop over all copies, select the one with the smallest free window
foreach (KeyValuePair <int, int> entryDays in dicDaysFreeForCopy)
{
if (entryDays.Value < daysFree)
{
daysFree = entryDays.Value;
selectedCopyId = entryDays.Key;
}
}
//assign the copy if it has been found
if (selectedCopyId > 0)
{
try
{
orderLine.dvdCopy = new DvdCopyService().getByID(selectedCopyId.ToString()); //Throws NoRecordException || DALException
}
catch (NoRecordException)
{
//No dvd's were found
}
new OrderLineService().updateOrderLine(orderLine);
//update the amount_sold field of the dvdInfo record
orderLine.dvdInfo.amount_sold = orderLine.dvdInfo.amount_sold + 1;
new DvdInfoService().update(orderLine.dvdInfo); //Throws NoRecordException
}
else
{
//no copies with future orderLines are available for this reservation/rent order
//get all fully available copies (=copies with no orderLines in the future) to assign to this orderline
try
{
List <DvdCopy> dvdCopies = new DvdCopyService().getAllFullyAvailableCopies(thisDVD, orderLine.startdate); //Throws NoRecordException || DALException
//set the first available copy as the copy for this orderline
orderLine.dvdCopy = dvdCopies[0];
//update database
new OrderLineService().updateOrderLine(orderLine);
//update the amount_sold field of the dvdInfo record
dvdCopies[0].dvdinfo.amount_sold += 1;
new DvdInfoService().update(dvdCopies[0].dvdinfo);
}
catch (Exception ex)
{
//no copy can be assigned at this time, this means someone else received the last copy between the time where
//this user added the item to his cart and when he payed for the order.
}
}
}
else if (orderLine.orderLineType.id == 2) //sale copy
{
//get all available copies
//get this list again for every item so you can add a new, available copy to the order
List <DvdCopy> availableCopies = new DvdCopyService().getAllInStockBuyCopiesForDvdInfo(orderLine.dvdInfo); //Throws NoRecordException || DALException
//get the first available copy
//set the found copy as the copy for this orderline
orderLine.dvdCopy = availableCopies[0];
new OrderLineService().updateOrderLine(orderLine);
//update the amount_sold field of the dvdInfo record
DvdInfo dvdInfo = availableCopies[0].dvdinfo;
dvdInfo.amount_sold = dvdInfo.amount_sold + 1;
new DvdInfoService().update(dvdInfo); //Throws NoRecordException
//mark the found copy as NOT in_stock
availableCopies[0].in_stock = false;
if (new DvdCopyService().updateCopy(availableCopies[0])) //Throws NoRecordException || DALException
{
//Success, record updated
}
}
}
}
public void update(DvdInfo dvd)
{
new DvdInfoDAO().update(dvd);
}
public int add(DvdInfo dvdInfo)
{
return(new DvdInfoDAO().add(dvdInfo)); //Throws NoRecordException
}
protected void Page_Load(object sender, EventArgs e)
{
String currency = "€";
wsCurrencyWebService.CurrencyWebService currencyWebService = new wsCurrencyWebService.CurrencyWebService();
dvdInfoLink.NavigateUrl = "~/detail.aspx?id=" + id;
dvdInfoLink2.NavigateUrl = dvdInfoLink.NavigateUrl;
imgDvdCover.ImageUrl = imageUrl;
if (title.Length <= 40)
{
lblTitle.Text = title;
}
else
{
lblTitle.Text = title.Substring(0, 28) + "...";
}
if (Request.QueryString["currency"] == null)
{
if (CookieUtil.CookieExists("currency"))
{
switch (CookieUtil.GetCookieValue("currency"))
{
case "usd":
currency = "$";
buy_price = (float)currencyWebService.convert(buy_price, "usd");
rent_price = (float)currencyWebService.convert(rent_price, "usd");
break;
}
}
}
else
{
switch (Request.QueryString["currency"])
{
case "usd":
currency = "$";
buy_price = (float)currencyWebService.convert(buy_price, "usd");
rent_price = (float)currencyWebService.convert(rent_price, "usd");
break;
}
}
//set buy button color and text
if (AvailabilityModel.isAvailableForBuying(Convert.ToString(id)))
{
btnBuyB.Attributes.Add("Class", "btn btn-success price-box");
}
else
{
btnBuyB.Attributes.Add("Class", "btn btn-warning price-box");
}
btnBuyB.InnerText = "Buy " + currency + " " + buy_price;
//set rent button properties and text
btnRentB.Attributes.Add("CommandArgument", id);
DvdInfoService dvdbll = new DvdInfoService();
try
{
DvdInfo thisDVD = dvdbll.getByID(Convert.ToString(id)); //Throws NoRecordExample
List <DateTime> dates = new AvailabilityModel().getAvailabilities(thisDVD, DateTime.Now); //Throws NoRecordException
if (dates.Count >= 14)
{
//fully available, green button
btnRentB.Attributes.Add("Class", "btn btn-success price-box");
}
else if (dates.Count > 0)
{
//available on some days, orange button
btnRentB.Attributes.Add("Class", "btn btn-warning price-box");
}
else
{
//not available at all, red button
btnRentB.Attributes.Add("Class", "btn btn-danger price-box");
}
}
catch (NoRecordException)
{
}
btnRentB.InnerText = "Rent " + currency + " " + rent_price;
}
public PageVisits getByDvdAndCustomer(Customer customer, DvdInfo dvdInfo)
{
return(new PageVisitsDAO().getByDvdAndCustomer(customer, dvdInfo)); //Throws NoRecordException
}
/**Returns a dictionary with dvd_copy_id, List of dates where the copy is available.*/
public Dictionary <int, List <DateTime> > getAllAvailableDaysPerCopyForDvdInfo(DvdInfo dvd, DateTime startdate)
{
Dictionary <int, List <DateTime> > dicCopyUnavailableDates = new Dictionary <int, List <DateTime> >();
Dictionary <int, List <DateTime> > result = new Dictionary <int, List <DateTime> >();
dicCopyUnavailableDates = getAllUnavailableDaysPerCopyForDvdInfo(dvd, startdate); //Throws NoRecordException
foreach (int i in dicCopyUnavailableDates.Keys)
{
result.Add(i, null);
List <DateTime> bezet = dicCopyUnavailableDates[i];
List <DateTime> freeDates = new List <DateTime>();
for (int j = 0; j < 14; j++)
{
DateTime d = DateTime.Now.Date.AddDays(j);
if (!bezet.Contains(d))
{
freeDates.Add(d);
}
}
result[i] = freeDates;
}
return(result);
}
override public void visit(DvdInfo dvdInfo)
{
this.setTitleBlurb("SB-DVD: " + dvdInfo.getTitleName());
}
public void addCopiesForDvd(DvdInfo dvd)
{
new DvdCopyDAO().addCopiesForDvd(dvd);
}
/*Returns a list of all dvd copies that are available for the full 14 day period, starting today*/
public List <DvdCopy> getAllFullyAvailableCopies(DvdInfo dvd, DateTime startdate)
{
DvdCopyDAO dvdCopyDAO = new DvdCopyDAO();
return(dvdCopyDAO.getAllFullyAvailableCopies(dvd, startdate)); //Throws NoRecordException || DALException
}
public List <DvdCopy> getAllInStockBuyCopiesForDvdInfo(DvdInfo dvdInfo)
{
DvdCopyType type = new DvdCopyTypeService().getByName("Verkoop"); //Throws NoRecordException || DALException
return(new DvdCopyDAO().getAllInStockCopiesForDvdInfo(dvdInfo, type)); //Throws NoRecordException || DALException
}
/*adds buy copy to cart(no dates)*/
public Boolean addByCustomerAndDvd(Customer customer, DvdInfo dvdInfo)
{
return(new ShoppingCartDAO().add(customer, dvdInfo));
}
/**Returns a dictionary with dvd_copy_id, List of dates where the copy is NOT available.*/
public Dictionary <int, List <DateTime> > getAllUnavailableDaysPerCopyForDvdInfo(DvdInfo dvd, DateTime startdate)
{
Dictionary <int, List <DateTime> > dicCopyUnavailableDates = new Dictionary <int, List <DateTime> >();
try
{
List <OrderLine> orders = new OrderLineDAO().getAllByDvdAndStartdate(dvd, startdate); //Throws NoRecordException
foreach (OrderLine order in orders)
{
//add the copy to the list if needed
if (!dicCopyUnavailableDates.ContainsKey(order.dvdCopy.dvd_copy_id))
{
List <DateTime> bezettemomenten = new List <DateTime>();
dicCopyUnavailableDates.Add(order.dvdCopy.dvd_copy_id, bezettemomenten);
}
if (dicCopyUnavailableDates.ContainsKey(order.dvdCopy.dvd_copy_id))
{
for (int i = 0; i < 14; i++)
{
DateTime tempDate = DateTime.Now.Date.AddDays(i);
if (tempDate >= order.startdate && tempDate <= order.enddate)
{
if (!dicCopyUnavailableDates[order.dvdCopy.dvd_copy_id].Contains(tempDate))
{
dicCopyUnavailableDates[order.dvdCopy.dvd_copy_id].Add(tempDate);
}
}
}
}
}
}
catch (NoRecordException ex)
{
}
return(dicCopyUnavailableDates);
}
public abstract void visit(DvdInfo dvdInfo);
public Boolean addDvdGenre(Genre genre, DvdInfo dvdInfo)
{
return(new DvdGenreDAO().add(genre, dvdInfo)); //Throws NoRecordException
}
public ImageInfoViewModel(string imagePath, IFilter filter, IMediaImage imageFormat, Window view)
{
_imagePath = imagePath;
_filter = filter;
_imageFormat = imageFormat;
_view = view;
IAssetLoader assets = AvaloniaLocator.Current.GetService <IAssetLoader>();
MediaTagsList = new ObservableCollection <string>();
SectorTagsList = new ObservableCollection <string>();
Sessions = new ObservableCollection <Session>();
Tracks = new ObservableCollection <Track>();
DumpHardwareList = new ObservableCollection <DumpHardwareModel>();
EntropyCommand = ReactiveCommand.Create(ExecuteEntropyCommand);
VerifyCommand = ReactiveCommand.Create(ExecuteVerifyCommand);
ChecksumCommand = ReactiveCommand.Create(ExecuteChecksumCommand);
ConvertCommand = ReactiveCommand.Create(ExecuteConvertCommand);
CreateSidecarCommand = ReactiveCommand.Create(ExecuteCreateSidecarCommand);
ViewSectorsCommand = ReactiveCommand.Create(ExecuteViewSectorsCommand);
DecodeMediaTagCommand = ReactiveCommand.Create(ExecuteDecodeMediaTagCommand);
var genericHddIcon =
new Bitmap(assets.Open(new Uri("avares://Aaru.Gui/Assets/Icons/oxygen/32x32/drive-harddisk.png")));
var genericOpticalIcon =
new Bitmap(assets.Open(new Uri("avares://Aaru.Gui/Assets/Icons/oxygen/32x32/drive-optical.png")));
var genericFolderIcon =
new Bitmap(assets.Open(new Uri("avares://Aaru.Gui/Assets/Icons/oxygen/32x32/inode-directory.png")));
var mediaResource = new Uri($"avares://Aaru.Gui/Assets/Logos/Media/{imageFormat.Info.MediaType}.png");
MediaLogo = assets.Exists(mediaResource)
? new Bitmap(assets.Open(mediaResource))
: imageFormat.Info.XmlMediaType == XmlMediaType.BlockMedia
? genericHddIcon
: imageFormat.Info.XmlMediaType == XmlMediaType.OpticalDisc
? genericOpticalIcon
: genericFolderIcon;
ImagePathText = $"Path: {imagePath}";
FilterText = $"Filter: {filter.Name}";
ImageIdentifiedText = $"Image format identified by {imageFormat.Name} ({imageFormat.Id}).";
ImageFormatText = !string.IsNullOrWhiteSpace(imageFormat.Info.Version)
? $"Format: {imageFormat.Format} version {imageFormat.Info.Version}"
: $"Format: {imageFormat.Format}";
ImageSizeText = $"Image without headers is {imageFormat.Info.ImageSize} bytes long";
SectorsText =
$"Contains a media of {imageFormat.Info.Sectors} sectors with a maximum sector size of {imageFormat.Info.SectorSize} bytes (if all sectors are of the same size this would be {imageFormat.Info.Sectors * imageFormat.Info.SectorSize} bytes)";
MediaTypeText =
$"Contains a media of type {imageFormat.Info.MediaType} and XML type {imageFormat.Info.XmlMediaType}";
HasPartitionsText = $"{(imageFormat.Info.HasPartitions ? "Has" : "Doesn't have")} partitions";
HasSessionsText = $"{(imageFormat.Info.HasSessions ? "Has" : "Doesn't have")} sessions";
if (!string.IsNullOrWhiteSpace(imageFormat.Info.Application))
{
ApplicationText = !string.IsNullOrWhiteSpace(imageFormat.Info.ApplicationVersion)
? $"Was created with {imageFormat.Info.Application} version {imageFormat.Info.ApplicationVersion}"
: $"Was created with {imageFormat.Info.Application}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.Creator))
{
CreatorText = $"Created by: {imageFormat.Info.Creator}";
}
if (imageFormat.Info.CreationTime != DateTime.MinValue)
{
CreationTimeText = $"Created on {imageFormat.Info.CreationTime}";
}
if (imageFormat.Info.LastModificationTime != DateTime.MinValue)
{
LastModificationTimeText = $"Last modified on {imageFormat.Info.LastModificationTime}";
}
if (imageFormat.Info.MediaSequence != 0 &&
imageFormat.Info.LastMediaSequence != 0)
{
MediaSequenceText =
$"Media is number {imageFormat.Info.MediaSequence} on a set of {imageFormat.Info.LastMediaSequence} medias";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.MediaTitle))
{
MediaTitleText = $"Media title: {imageFormat.Info.MediaTitle}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.MediaManufacturer))
{
MediaManufacturerText = $"Media manufacturer: {imageFormat.Info.MediaManufacturer}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.MediaModel))
{
MediaModelText = $"Media model: {imageFormat.Info.MediaModel}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.MediaSerialNumber))
{
MediaSerialNumberText = $"Media serial number: {imageFormat.Info.MediaSerialNumber}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.MediaBarcode))
{
MediaBarcodeText = $"Media barcode: {imageFormat.Info.MediaBarcode}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.MediaPartNumber))
{
MediaPartNumberText = $"Media part number: {imageFormat.Info.MediaPartNumber}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.DriveManufacturer))
{
DriveManufacturerText = $"Drive manufacturer: {imageFormat.Info.DriveManufacturer}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.DriveModel))
{
DriveModelText = $"Drive model: {imageFormat.Info.DriveModel}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.DriveSerialNumber))
{
DriveSerialNumberText = $"Drive serial number: {imageFormat.Info.DriveSerialNumber}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.DriveFirmwareRevision))
{
DriveFirmwareRevisionText = $"Drive firmware info: {imageFormat.Info.DriveFirmwareRevision}";
}
if (imageFormat.Info.Cylinders > 0 &&
imageFormat.Info.Heads > 0 &&
imageFormat.Info.SectorsPerTrack > 0 &&
imageFormat.Info.XmlMediaType != XmlMediaType.OpticalDisc &&
(!(imageFormat is ITapeImage tapeImage) || !tapeImage.IsTape))
{
MediaGeometryText =
$"Media geometry: {imageFormat.Info.Cylinders} cylinders, {imageFormat.Info.Heads} heads, {imageFormat.Info.SectorsPerTrack} sectors per track";
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Count > 0)
{
foreach (MediaTagType tag in imageFormat.Info.ReadableMediaTags.OrderBy(t => t))
{
MediaTagsList.Add(tag.ToString());
}
}
if (imageFormat.Info.ReadableSectorTags != null &&
imageFormat.Info.ReadableSectorTags.Count > 0)
{
foreach (SectorTagType tag in imageFormat.Info.ReadableSectorTags.OrderBy(t => t))
{
SectorTagsList.Add(tag.ToString());
}
}
PeripheralDeviceTypes scsiDeviceType = PeripheralDeviceTypes.DirectAccess;
byte[] scsiInquiryData = null;
Inquiry?scsiInquiry = null;
Modes.DecodedMode?scsiMode = null;
byte[] scsiModeSense6 = null;
byte[] scsiModeSense10 = null;
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SCSI_INQUIRY))
{
scsiInquiryData = imageFormat.ReadDiskTag(MediaTagType.SCSI_INQUIRY);
scsiDeviceType = (PeripheralDeviceTypes)(scsiInquiryData[0] & 0x1F);
scsiInquiry = Inquiry.Decode(scsiInquiryData);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SCSI_MODESENSE_6))
{
scsiModeSense6 = imageFormat.ReadDiskTag(MediaTagType.SCSI_MODESENSE_6);
scsiMode = Modes.DecodeMode6(scsiModeSense6, scsiDeviceType);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SCSI_MODESENSE_10))
{
scsiModeSense10 = imageFormat.ReadDiskTag(MediaTagType.SCSI_MODESENSE_10);
scsiMode = Modes.DecodeMode10(scsiModeSense10, scsiDeviceType);
}
ScsiInfo = new ScsiInfo
{
DataContext = new ScsiInfoViewModel(scsiInquiryData, scsiInquiry, null, scsiMode, scsiDeviceType,
scsiModeSense6, scsiModeSense10, null, _view)
};
byte[] ataIdentify = null;
byte[] atapiIdentify = null;
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.ATA_IDENTIFY))
{
ataIdentify = imageFormat.ReadDiskTag(MediaTagType.ATA_IDENTIFY);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.ATAPI_IDENTIFY))
{
atapiIdentify = imageFormat.ReadDiskTag(MediaTagType.ATAPI_IDENTIFY);
}
AtaInfo = new AtaInfo
{
DataContext = new AtaInfoViewModel(ataIdentify, atapiIdentify, null, _view)
};
byte[] toc = null;
TOC.CDTOC? decodedToc = null;
byte[] fullToc = null;
FullTOC.CDFullTOC? decodedFullToc = null;
byte[] pma = null;
byte[] atip = null;
ATIP.CDATIP? decodedAtip = null;
byte[] cdtext = null;
CDTextOnLeadIn.CDText?decodedCdText = null;
string mediaCatalogueNumber = null;
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.CD_TOC))
{
toc = imageFormat.ReadDiskTag(MediaTagType.CD_TOC);
if (toc.Length > 0)
{
ushort dataLen = Swapping.Swap(BitConverter.ToUInt16(toc, 0));
if (dataLen + 2 != toc.Length)
{
byte[] tmp = new byte[toc.Length + 2];
Array.Copy(toc, 0, tmp, 2, toc.Length);
tmp[0] = (byte)((toc.Length & 0xFF00) >> 8);
tmp[1] = (byte)(toc.Length & 0xFF);
toc = tmp;
}
decodedToc = TOC.Decode(toc);
}
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.CD_FullTOC))
{
fullToc = imageFormat.ReadDiskTag(MediaTagType.CD_FullTOC);
if (fullToc.Length > 0)
{
ushort dataLen = Swapping.Swap(BitConverter.ToUInt16(fullToc, 0));
if (dataLen + 2 != fullToc.Length)
{
byte[] tmp = new byte[fullToc.Length + 2];
Array.Copy(fullToc, 0, tmp, 2, fullToc.Length);
tmp[0] = (byte)((fullToc.Length & 0xFF00) >> 8);
tmp[1] = (byte)(fullToc.Length & 0xFF);
fullToc = tmp;
}
decodedFullToc = FullTOC.Decode(fullToc);
}
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.CD_PMA))
{
pma = imageFormat.ReadDiskTag(MediaTagType.CD_PMA);
if (pma.Length > 0)
{
ushort dataLen = Swapping.Swap(BitConverter.ToUInt16(pma, 0));
if (dataLen + 2 != pma.Length)
{
byte[] tmp = new byte[pma.Length + 2];
Array.Copy(pma, 0, tmp, 2, pma.Length);
tmp[0] = (byte)((pma.Length & 0xFF00) >> 8);
tmp[1] = (byte)(pma.Length & 0xFF);
pma = tmp;
}
}
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.CD_ATIP))
{
atip = imageFormat.ReadDiskTag(MediaTagType.CD_ATIP);
uint dataLen = Swapping.Swap(BitConverter.ToUInt32(atip, 0));
if (dataLen + 4 != atip.Length)
{
byte[] tmp = new byte[atip.Length + 4];
Array.Copy(atip, 0, tmp, 4, atip.Length);
tmp[0] = (byte)((atip.Length & 0xFF000000) >> 24);
tmp[1] = (byte)((atip.Length & 0xFF0000) >> 16);
tmp[2] = (byte)((atip.Length & 0xFF00) >> 8);
tmp[3] = (byte)(atip.Length & 0xFF);
atip = tmp;
}
decodedAtip = ATIP.Decode(atip);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.CD_TEXT))
{
cdtext = imageFormat.ReadDiskTag(MediaTagType.CD_TEXT);
uint dataLen = Swapping.Swap(BitConverter.ToUInt32(cdtext, 0));
if (dataLen + 4 != cdtext.Length)
{
byte[] tmp = new byte[cdtext.Length + 4];
Array.Copy(cdtext, 0, tmp, 4, cdtext.Length);
tmp[0] = (byte)((cdtext.Length & 0xFF000000) >> 24);
tmp[1] = (byte)((cdtext.Length & 0xFF0000) >> 16);
tmp[2] = (byte)((cdtext.Length & 0xFF00) >> 8);
tmp[3] = (byte)(cdtext.Length & 0xFF);
cdtext = tmp;
}
decodedCdText = CDTextOnLeadIn.Decode(cdtext);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.CD_MCN))
{
byte[] mcn = imageFormat.ReadDiskTag(MediaTagType.CD_MCN);
mediaCatalogueNumber = Encoding.UTF8.GetString(mcn);
}
CompactDiscInfo = new CompactDiscInfo
{
DataContext = new CompactDiscInfoViewModel(toc, atip, null, null, fullToc, pma, cdtext, decodedToc,
decodedAtip, null, decodedFullToc, decodedCdText, null,
mediaCatalogueNumber, null, _view)
};
byte[] dvdPfi = null;
byte[] dvdDmi = null;
byte[] dvdCmi = null;
byte[] hddvdCopyrightInformation = null;
byte[] dvdBca = null;
PFI.PhysicalFormatInformation?decodedPfi = null;
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVD_PFI))
{
dvdPfi = imageFormat.ReadDiskTag(MediaTagType.DVD_PFI);
decodedPfi = PFI.Decode(dvdPfi);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVD_DMI))
{
dvdDmi = imageFormat.ReadDiskTag(MediaTagType.DVD_DMI);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVD_CMI))
{
dvdCmi = imageFormat.ReadDiskTag(MediaTagType.DVD_CMI);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.HDDVD_CPI))
{
hddvdCopyrightInformation = imageFormat.ReadDiskTag(MediaTagType.HDDVD_CPI);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVD_BCA))
{
dvdBca = imageFormat.ReadDiskTag(MediaTagType.DVD_BCA);
}
DvdInfo = new DvdInfo
{
DataContext = new DvdInfoViewModel(imageFormat.Info.MediaType, dvdPfi, dvdDmi, dvdCmi,
hddvdCopyrightInformation, dvdBca, null, decodedPfi, _view)
};
byte[] dvdRamDds = null;
byte[] dvdRamCartridgeStatus = null;
byte[] dvdRamSpareArea = null;
byte[] lastBorderOutRmd = null;
byte[] dvdPreRecordedInfo = null;
byte[] dvdrMediaIdentifier = null;
byte[] dvdrPhysicalInformation = null;
byte[] hddvdrMediumStatus = null;
byte[] dvdrLayerCapacity = null;
byte[] dvdrDlMiddleZoneStart = null;
byte[] dvdrDlJumpIntervalSize = null;
byte[] dvdrDlManualLayerJumpStartLba = null;
byte[] dvdPlusAdip = null;
byte[] dvdPlusDcb = null;
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDRAM_DDS))
{
dvdRamDds = imageFormat.ReadDiskTag(MediaTagType.DVDRAM_DDS);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDRAM_MediumStatus))
{
dvdRamCartridgeStatus = imageFormat.ReadDiskTag(MediaTagType.DVDRAM_MediumStatus);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDRAM_SpareArea))
{
dvdRamSpareArea = imageFormat.ReadDiskTag(MediaTagType.DVDRAM_SpareArea);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDR_RMD))
{
lastBorderOutRmd = imageFormat.ReadDiskTag(MediaTagType.DVDR_RMD);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDR_PreRecordedInfo))
{
dvdPreRecordedInfo = imageFormat.ReadDiskTag(MediaTagType.DVDR_PreRecordedInfo);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDR_MediaIdentifier))
{
dvdrMediaIdentifier = imageFormat.ReadDiskTag(MediaTagType.DVDR_MediaIdentifier);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDR_PFI))
{
dvdrPhysicalInformation = imageFormat.ReadDiskTag(MediaTagType.DVDR_PFI);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.HDDVD_MediumStatus))
{
hddvdrMediumStatus = imageFormat.ReadDiskTag(MediaTagType.HDDVD_MediumStatus);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDDL_LayerCapacity))
{
dvdrLayerCapacity = imageFormat.ReadDiskTag(MediaTagType.DVDDL_LayerCapacity);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDDL_MiddleZoneAddress))
{
dvdrDlMiddleZoneStart = imageFormat.ReadDiskTag(MediaTagType.DVDDL_MiddleZoneAddress);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDDL_JumpIntervalSize))
{
dvdrDlJumpIntervalSize = imageFormat.ReadDiskTag(MediaTagType.DVDDL_JumpIntervalSize);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDDL_ManualLayerJumpLBA))
{
dvdrDlManualLayerJumpStartLba = imageFormat.ReadDiskTag(MediaTagType.DVDDL_ManualLayerJumpLBA);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVD_ADIP))
{
dvdPlusAdip = imageFormat.ReadDiskTag(MediaTagType.DVD_ADIP);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DCB))
{
dvdPlusDcb = imageFormat.ReadDiskTag(MediaTagType.DCB);
}
DvdWritableInfo = new DvdWritableInfo
{
DataContext = new DvdWritableInfoViewModel(imageFormat.Info.MediaType, dvdRamDds, dvdRamCartridgeStatus,
dvdRamSpareArea, lastBorderOutRmd, dvdPreRecordedInfo,
dvdrMediaIdentifier, dvdrPhysicalInformation,
hddvdrMediumStatus, null, dvdrLayerCapacity,
dvdrDlMiddleZoneStart, dvdrDlJumpIntervalSize,
dvdrDlManualLayerJumpStartLba, null, dvdPlusAdip, dvdPlusDcb,
_view)
};
byte[] blurayBurstCuttingArea = null;
byte[] blurayCartridgeStatus = null;
byte[] blurayDds = null;
byte[] blurayDiscInformation = null;
byte[] blurayPowResources = null;
byte[] bluraySpareAreaInformation = null;
byte[] blurayTrackResources = null;
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.BD_BCA))
{
blurayBurstCuttingArea = imageFormat.ReadDiskTag(MediaTagType.BD_BCA);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.BD_CartridgeStatus))
{
blurayCartridgeStatus = imageFormat.ReadDiskTag(MediaTagType.BD_CartridgeStatus);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.BD_DDS))
{
blurayDds = imageFormat.ReadDiskTag(MediaTagType.BD_DDS);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.BD_DI))
{
blurayDiscInformation = imageFormat.ReadDiskTag(MediaTagType.BD_DI);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.MMC_POWResourcesInformation))
{
blurayPowResources = imageFormat.ReadDiskTag(MediaTagType.MMC_POWResourcesInformation);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.BD_SpareArea))
{
bluraySpareAreaInformation = imageFormat.ReadDiskTag(MediaTagType.BD_SpareArea);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.MMC_TrackResourcesInformation))
{
bluraySpareAreaInformation = imageFormat.ReadDiskTag(MediaTagType.MMC_TrackResourcesInformation);
}
BlurayInfo = new BlurayInfo
{
DataContext = new BlurayInfoViewModel(blurayDiscInformation, blurayBurstCuttingArea, blurayDds,
blurayCartridgeStatus, bluraySpareAreaInformation,
blurayPowResources, blurayTrackResources, null, null, _view)
};
byte[] xboxDmi = null;
byte[] xboxSecuritySector = null;
SS.SecuritySector?decodedXboxSecuritySector = null;
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.Xbox_DMI))
{
xboxDmi = imageFormat.ReadDiskTag(MediaTagType.Xbox_DMI);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.Xbox_SecuritySector))
{
xboxSecuritySector = imageFormat.ReadDiskTag(MediaTagType.Xbox_SecuritySector);
decodedXboxSecuritySector = SS.Decode(xboxSecuritySector);
}
XboxInfo = new XboxInfo
{
DataContext = new XboxInfoViewModel(null, xboxDmi, xboxSecuritySector, decodedXboxSecuritySector, _view)
};
byte[] pcmciaCis = null;
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.PCMCIA_CIS))
{
pcmciaCis = imageFormat.ReadDiskTag(MediaTagType.PCMCIA_CIS);
}
PcmciaInfo = new PcmciaInfo
{
DataContext = new PcmciaInfoViewModel(pcmciaCis, _view)
};
DeviceType deviceType = DeviceType.Unknown;
byte[] cid = null;
byte[] csd = null;
byte[] ocr = null;
byte[] extendedCsd = null;
byte[] scr = null;
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SD_CID))
{
cid = imageFormat.ReadDiskTag(MediaTagType.SD_CID);
deviceType = DeviceType.SecureDigital;
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SD_CSD))
{
csd = imageFormat.ReadDiskTag(MediaTagType.SD_CSD);
deviceType = DeviceType.SecureDigital;
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SD_OCR))
{
ocr = imageFormat.ReadDiskTag(MediaTagType.SD_OCR);
deviceType = DeviceType.SecureDigital;
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SD_SCR))
{
scr = imageFormat.ReadDiskTag(MediaTagType.SD_SCR);
deviceType = DeviceType.SecureDigital;
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.MMC_CID))
{
cid = imageFormat.ReadDiskTag(MediaTagType.MMC_CID);
deviceType = DeviceType.MMC;
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.MMC_CSD))
{
csd = imageFormat.ReadDiskTag(MediaTagType.MMC_CSD);
deviceType = DeviceType.MMC;
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.MMC_OCR))
{
ocr = imageFormat.ReadDiskTag(MediaTagType.MMC_OCR);
deviceType = DeviceType.MMC;
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.MMC_ExtendedCSD))
{
extendedCsd = imageFormat.ReadDiskTag(MediaTagType.MMC_ExtendedCSD);
deviceType = DeviceType.MMC;
}
SdMmcInfo = new SdMmcInfo
{
DataContext = new SdMmcInfoViewModel(deviceType, cid, csd, ocr, extendedCsd, scr)
};
if (imageFormat is IOpticalMediaImage opticalMediaImage)
{
try
{
if (opticalMediaImage.Sessions != null &&
opticalMediaImage.Sessions.Count > 0)
{
foreach (Session session in opticalMediaImage.Sessions)
{
Sessions.Add(session);
}
}
}
catch
{
// ignored
}
try
{
if (opticalMediaImage.Tracks != null &&
opticalMediaImage.Tracks.Count > 0)
{
foreach (Track track in opticalMediaImage.Tracks)
{
Tracks.Add(track);
}
}
}
catch
{
// ignored
}
}
if (imageFormat.DumpHardware is null)
{
return;
}
foreach (DumpHardwareType dump in imageFormat.DumpHardware)
{
foreach (ExtentType extent in dump.Extents)
{
DumpHardwareList.Add(new DumpHardwareModel
{
Manufacturer = dump.Manufacturer, Model = dump.Model, Serial = dump.Serial,
SoftwareName = dump.Software.Name, SoftwareVersion = dump.Software.Version,
OperatingSystem = dump.Software.OperatingSystem, Start = extent.Start, End = extent.End
});
}
}
}
public abstract void visit(DvdInfo dvdInfo);
public MediaInfoViewModel(ScsiInfo scsiInfo, string devicePath, Window view)
{
_view = view;
SaveReadMediaSerialCommand = ReactiveCommand.Create(ExecuteSaveReadMediaSerialCommand);
SaveReadCapacityCommand = ReactiveCommand.Create(ExecuteSaveReadCapacityCommand);
SaveReadCapacity16Command = ReactiveCommand.Create(ExecuteSaveReadCapacity16Command);
SaveGetConfigurationCommand = ReactiveCommand.Create(ExecuteSaveGetConfigurationCommand);
SaveRecognizedFormatLayersCommand = ReactiveCommand.Create(ExecuteSaveRecognizedFormatLayersCommand);
SaveWriteProtectionStatusCommand = ReactiveCommand.Create(ExecuteSaveWriteProtectionStatusCommand);
SaveDensitySupportCommand = ReactiveCommand.Create(ExecuteSaveDensitySupportCommand);
SaveMediumSupportCommand = ReactiveCommand.Create(ExecuteSaveMediumSupportCommand);
DumpCommand = ReactiveCommand.Create(ExecuteDumpCommand);
ScanCommand = ReactiveCommand.Create(ExecuteScanCommand);
IAssetLoader assets = AvaloniaLocator.Current.GetService <IAssetLoader>();
_devicePath = devicePath;
_scsiInfo = scsiInfo;
var mediaResource = new Uri($"avares://Aaru.Gui/Assets/Logos/Media/{scsiInfo.MediaType}.png");
MediaLogo = assets.Exists(mediaResource) ? new Bitmap(assets.Open(mediaResource)) : null;
MediaType = scsiInfo.MediaType.ToString();
if (scsiInfo.Blocks != 0 &&
scsiInfo.BlockSize != 0)
{
MediaSize =
$"Media has {scsiInfo.Blocks} blocks of {scsiInfo.BlockSize} bytes/each. (for a total of {scsiInfo.Blocks * scsiInfo.BlockSize} bytes)";
}
if (scsiInfo.MediaSerialNumber != null)
{
var sbSerial = new StringBuilder();
for (int i = 4; i < scsiInfo.MediaSerialNumber.Length; i++)
{
sbSerial.AppendFormat("{0:X2}", scsiInfo.MediaSerialNumber[i]);
}
MediaSerial = sbSerial.ToString();
}
SaveReadMediaSerialVisible = scsiInfo.MediaSerialNumber != null;
SaveReadCapacityVisible = scsiInfo.ReadCapacity != null;
SaveReadCapacity16Visible = scsiInfo.ReadCapacity16 != null;
SaveGetConfigurationVisible = scsiInfo.MmcConfiguration != null;
SaveRecognizedFormatLayersVisible = scsiInfo.RecognizedFormatLayers != null;
SaveWriteProtectionStatusVisible = scsiInfo.WriteProtectionStatus != null;
MmcVisible = SaveGetConfigurationVisible || SaveRecognizedFormatLayersVisible ||
SaveWriteProtectionStatusVisible;
if (scsiInfo.DensitySupportHeader.HasValue)
{
DensitySupport = Decoders.SCSI.SSC.DensitySupport.PrettifyDensity(scsiInfo.DensitySupportHeader);
}
if (scsiInfo.MediaTypeSupportHeader.HasValue)
{
MediumSupport = Decoders.SCSI.SSC.DensitySupport.PrettifyMediumType(scsiInfo.MediaTypeSupportHeader);
}
SaveDensitySupportVisible = scsiInfo.DensitySupport != null;
SaveMediumSupportVisible = scsiInfo.MediaTypeSupport != null;
SscVisible = SaveDensitySupportVisible || SaveMediumSupportVisible;
CompactDiscInfo = new CompactDiscInfo
{
DataContext = new CompactDiscInfoViewModel(scsiInfo.Toc, scsiInfo.Atip, scsiInfo.DiscInformation,
scsiInfo.Session, scsiInfo.RawToc, scsiInfo.Pma,
scsiInfo.CdTextLeadIn, scsiInfo.DecodedToc,
scsiInfo.DecodedAtip, scsiInfo.DecodedSession,
scsiInfo.FullToc, scsiInfo.DecodedCdTextLeadIn,
scsiInfo.DecodedDiscInformation, scsiInfo.Mcn,
scsiInfo.Isrcs, _view)
};
DvdInfo = new DvdInfo
{
DataContext = new DvdInfoViewModel(scsiInfo.MediaType, scsiInfo.DvdPfi, scsiInfo.DvdDmi,
scsiInfo.DvdCmi, scsiInfo.HddvdCopyrightInformation, scsiInfo.DvdBca,
scsiInfo.DvdAacs, scsiInfo.DecodedPfi, _view)
};
XboxInfo = new XboxInfo
{
DataContext = new XboxInfoViewModel(scsiInfo.XgdInfo, scsiInfo.DvdDmi, scsiInfo.XboxSecuritySector,
scsiInfo.DecodedXboxSecuritySector, _view)
};
DvdWritableInfo = new DvdWritableInfo
{
DataContext = new DvdWritableInfoViewModel(scsiInfo.MediaType, scsiInfo.DvdRamDds,
scsiInfo.DvdRamCartridgeStatus, scsiInfo.DvdRamSpareArea,
scsiInfo.LastBorderOutRmd, scsiInfo.DvdPreRecordedInfo,
scsiInfo.DvdrMediaIdentifier,
scsiInfo.DvdrPhysicalInformation,
scsiInfo.HddvdrMediumStatus, scsiInfo.HddvdrLastRmd,
scsiInfo.DvdrLayerCapacity, scsiInfo.DvdrDlMiddleZoneStart,
scsiInfo.DvdrDlJumpIntervalSize,
scsiInfo.DvdrDlManualLayerJumpStartLba,
scsiInfo.DvdrDlRemapAnchorPoint, scsiInfo.DvdPlusAdip,
scsiInfo.DvdPlusDcb, _view)
};
BlurayInfo = new BlurayInfo
{
DataContext = new BlurayInfoViewModel(scsiInfo.BlurayDiscInformation, scsiInfo.BlurayBurstCuttingArea,
scsiInfo.BlurayDds, scsiInfo.BlurayCartridgeStatus,
scsiInfo.BluraySpareAreaInformation, scsiInfo.BlurayPowResources,
scsiInfo.BlurayTrackResources, scsiInfo.BlurayRawDfl,
scsiInfo.BlurayPac, _view)
};
}
public override void visit(DvdInfo dvdInfo)
{
this.setTitleBlurb("SB-DVD: " + dvdInfo.getTitleName());
}
