public static AddBoxWizardViewModel BuildFromStyleId(IUnitOfWork db,
long styleId)
{
var model = new AddBoxWizardViewModel();
var style = db.Styles.GetByStyleIdAsDto(styleId);
model.StyleString = style.StyleID;
model.StyleId = styleId;
model.Price = db.OpenBoxes.GetByStyleId(styleId).OrderBy(b => b.Id).Select(b => b.Price).FirstOrDefault();
model.BoxQuantity = 1;
model.Owned = true;
var styleItems = db.StyleItems.GetByStyleIdWithSizeGroupAsDto(styleId).ToList();
model.Sizes = styleItems
.OrderBy(si => SizeHelper.GetSizeIndex(si.Size))
.ThenBy(si => si.Color)
.Select(si => new BoxSizeWizardViewModel(si))
.ToList();
model.SetDefaultBreakdowns(model.Sizes.ToList());
model.CreateDate = DateHelper.GetAppNowTime().Date;
model.BoxBarcode = db.SealedBoxes.GetDefaultBoxNameForBothType(styleId, model.CreateDate.Value);
return(model);
}
/// <summary>
/// Initialize with buffer and basic info about the FS
/// </summary>
/// <param name="buffer"></param>
/// <param name="name"></param>
/// <param name="directory"></param>
public RDB(Span <byte> buffer, string name, string directory)
{
Name = name;
Header = MemoryMarshal.Read <RDBHeader>(buffer);
RDBDirectory = directory;
DataDirectory = buffer.Slice(SizeHelper.SizeOf <RDBHeader>(), Header.HeaderSize - SizeHelper.SizeOf <RDBHeader>()).ReadString() ?? string.Empty;
Directory = Path.Combine(directory, DataDirectory);
var offset = Header.HeaderSize;
for (var i = 0; i < Header.Count; ++i)
{
var(entry, typeblob, data) = ReadRDBEntry(buffer.Slice(offset));
var fileEntry = entry.GetValueOrDefault();
offset += (int)fileEntry.EntrySize.Align(4);
Entries.Add((fileEntry, typeblob, DecodeOffset(((Span <byte>)data).ReadString() ?? "0")));
KTIDToEntryId[fileEntry.FileKTID] = i;
}
if (!KTIDToEntryId.TryGetValue(Header.NameDatabaseKTID, out var nameDatabaseId))
{
return;
}
var nameBuffer = ReadEntry(nameDatabaseId);
if (nameBuffer.Length == 0)
{
return;
}
NameDatabase = new NDB(nameBuffer.Span);
}
private IList <StyleItemInfoCacheEntry> GetStyleItemInfoList(IList <long> styleIdList, bool keepImage)
{
var styleItemQuery = from si in unitOfWork.GetSet <StyleItem>()
join st in unitOfWork.GetSet <Style>() on si.StyleId equals st.Id
join siCache in unitOfWork.GetSet <StyleItemCache>() on si.Id equals siCache.Id into withStCache
from siCache in withStCache.DefaultIfEmpty()
where !st.Deleted &&
styleIdList.Contains(st.Id)
select new StyleItemInfoCacheEntry()
{
Id = si.Id,
StyleId = si.StyleId,
StyleString = st.StyleID,
StyleOnHold = st.OnHold,
StyleSize = si.Size,
StyleColor = si.Color,
StyleItemId = si.Id,
OnHold = si.OnHold,
RemainingQuantity = siCache.RemainingQuantity,
Image = keepImage ? st.Image : null,
MarketplacesInfo = siCache.MarketplacesInfo,
};
var styleItems = styleItemQuery.AsNoTracking().ToList();
styleItems = styleItems.OrderBy(si => SizeHelper.GetSizeIndex(si.StyleSize)).ToList();
return(styleItems);
}
/// <summary>
/// Initialize from a blob
/// </summary>
/// <param name="blob"></param>
/// <param name="platform"></param>
public NamedSounds(Span <byte> blob, DataPlatform platform)
{
FullBuffer = new Memory <byte>(blob.ToArray());
Header = MemoryMarshal.Read <NamedSoundHeader>(blob);
Logger.Assert(Header.Count == 1, "Header.Count == 1");
var offset = SizeHelper.SizeOf <NamedSoundHeader>();
Filenames = new List <string?>(Header.Count);
for (var i = 0; i < Header.Count; ++i)
{
var pointer = MemoryMarshal.Read <int>(blob.Slice(offset));
Filenames.Add(blob.Slice(pointer).ReadString());
offset += 4;
}
offset = Header.PointersTablePointer;
for (var i = 0; i < Header.Count; ++i)
{
var name = blob.Slice(offset).ReadStringNonNull();
offset += (name?.Length ?? 0) + 1;
Filenames.Add(name);
}
var pointers = MemoryMarshal.Cast <byte, int>(blob.Slice(Header.PointersTablePointer, 4 * Header.Count));
foreach (var pointer in pointers)
{
Sections.Add(SoundResource.DecodeSection(blob.Slice(pointer), platform));
}
}
private void cmbMinSize_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (!string.IsNullOrWhiteSpace(txtMinSize.Text))
{
searchInfo.MinSize = SizeHelper.GetSizeInBytes(txtMinSize.Text, ((ContentControl)cmbMinSize.SelectedValue).Content as string);
}
}
private void NewUpdateDialog_Load(object sender, EventArgs e)
{
_lp = LocalizationHelper.GetLocalizationProperties(Updater.LanguageCulture, Updater.CultureFilePaths);
headerLabel.Text =
string.Format(
Updater.PackageConfigurations.Count() > 1
? _lp.NewUpdateDialogMultipleUpdatesHeader
: _lp.NewUpdateDialogSingleUpdateHeader, Updater.PackageConfigurations.Count());
infoLabel.Text = string.Format(_lp.NewUpdateDialogInfoText, Application.ProductName);
var availableVersions =
Updater.PackageConfigurations.Select(item => new UpdateVersion(item.LiteralVersion)).ToArray();
newestVersionLabel.Text = string.Format(_lp.NewUpdateDialogAvailableVersionsText,
Updater.PackageConfigurations.Count() <= 2
? string.Join(", ", availableVersions.Select(item => item.FullText))
: $"{UpdateVersion.GetLowestUpdateVersion(availableVersions).FullText} - {UpdateVersion.GetHighestUpdateVersion(availableVersions).FullText}");
currentVersionLabel.Text = string.Format(_lp.NewUpdateDialogCurrentVersionText, Updater.CurrentVersion.FullText);
changelogLabel.Text = _lp.NewUpdateDialogChangelogText;
cancelButton.Text = _lp.CancelButtonText;
installButton.Text = _lp.InstallButtonText;
var size = SizeHelper.ConvertSize(Updater.TotalSize);
updateSizeLabel.Text = $"{string.Format(_lp.NewUpdateDialogSizeText, size.Item1)} {size.Item2}";
Icon = _appIcon;
Text = Application.ProductName;
iconPictureBox.Image = _appIcon.ToBitmap();
iconPictureBox.BackgroundImageLayout = ImageLayout.Center;
foreach (var updateConfiguration in Updater.PackageConfigurations)
{
var versionText = new UpdateVersion(updateConfiguration.LiteralVersion).FullText;
var changelogText = updateConfiguration.Changelog.ContainsKey(Updater.LanguageCulture)
? updateConfiguration.Changelog.First(item => Equals(item.Key, Updater.LanguageCulture)).Value
: updateConfiguration.Changelog.First(item => item.Key.Name == "en").Value;
if (Updater.TotalSize > GB)
{
changelogTextBox.Text += _lp.NewUpdateDialogBigPackageWarning;
}
changelogTextBox.Text +=
string.Format(string.IsNullOrEmpty(changelogTextBox.Text) ? "{0}:\n{1}" : "\n\n{0}:\n{1}",
versionText, changelogText);
}
AddShieldToButton(installButton);
if (OperationAreas == null || OperationAreas.Count == 0)
{
accessLabel.Text = $"{_lp.NewUpdateDialogAccessText} -";
_allowCancel = true;
return;
}
accessLabel.Text =
$"{_lp.NewUpdateDialogAccessText} {string.Join(", ", LocalizationHelper.GetLocalizedEnumerationValues(_lp, OperationAreas.Cast<object>().GroupBy(item => item).Select(item => item.First()).ToArray()))}";
_allowCancel = true;
}
/// <summary>
/// Write to G1M span using just SectionsRoot
/// </summary>
/// <returns></returns>
public Span <byte> WriteFromRoot()
{
var sectionHeaderSize = SizeHelper.SizeOf <ResourceSectionHeader>();
var size = SizeHelper.SizeOf <ModelHeader>() + sectionHeaderSize + SectionRoot.Sections.Sum(x => x.Length);
var buffer = new Span <byte>(new byte[size]);
var modelSectionHeader = Section;
modelSectionHeader.Size = size;
MemoryMarshal.Write(buffer, ref modelSectionHeader);
var offset = sectionHeaderSize;
var modelHeader = new ModelHeader
{
HeaderSize = sectionHeaderSize + SizeHelper.SizeOf <ModelHeader>(),
Reserved = 0,
SectionCount = SectionRoot.Sections.Count
};
MemoryMarshal.Write(buffer.Slice(offset), ref modelHeader);
offset = modelHeader.HeaderSize;
foreach (var data in SectionRoot.Sections)
{
data.Span.CopyTo(buffer.Slice(offset));
offset += data.Length;
}
return(buffer);
}
private void InitStyleItems(IUnitOfWork db, long?styleId)
{
if (styleId.HasValue)
{
var styleItemList = (from si in db.StyleItems.GetAll()
join sic in db.StyleItemCaches.GetAll() on si.Id equals sic.Id into withCache
from sic in withCache.DefaultIfEmpty()
where si.StyleId == styleId
select new StyleItemCountingViewModel()
{
Id = si.Id,
Size = si.Size,
Color = si.Color,
RemainingQuantity = sic.RemainingQuantity,
CountingDate = si.LiteCountingDate,
CountingName = si.LiteCountingName,
CountingStatus = si.LiteCountingStatus,
StyleId = si.StyleId,
}).ToList();
StyleItems = styleItemList.OrderBy(si => SizeHelper.GetSizeIndex(si.Size))
.ToList();
}
}
// Deallocates storage for the given vector and updates the memory
// tracking accordingly. Returns false if the current operation should be
// cancelled.
public /*inline*/ bool Clear <T>(List <T> v)
{
var old_capacity = v.Capacity;
v.Clear();
return(Tally(-old_capacity * SizeHelper.SizeOf(typeof(T))));
}
public void StructContainer()
{
Assert.False(SizeHelper.IsPersistent(typeof(string)));
Assert.False(SizeHelper.IsPersistent(typeof(StructWithRefField)));
Assert.True(SizeHelper.IsPersistent(typeof(int)));
Assert.True(SizeHelper.IsPersistent(typeof(DateTime)));
Assert.True(SizeHelper.IsPersistent(typeof(decimal)));
}
/// <summary>
/// Parse Dissidia Save Data
/// </summary>
/// <param name="data"></param>
/// <param name="key"></param>
public DFFNTSave(Span <byte> data, Span <byte> key)
{
var decrypted = CompressionEncryption.CryptAESCBC(data.Slice(0x18), key, Span <byte> .Empty);
decrypted.CopyTo(data.Slice(0x18));
Header = MemoryMarshal.Read <DFFNTSaveHeader>(data);
SaveData = data.Slice(SizeHelper.SizeOf <DFFNTSaveHeader>()).ReadString() ?? "{}";
TailByte = data[^ 1];
public void MatchSize_WhenMatchbyRangeFindSingleSizeTest()
{
var sizeLists = SizeHelper.MatchSize(SizeStandartWomenWear.Rus, "48-50", SizeUsePlace.Сlothes);
Assert.That(sizeLists.Any(x => x.Size == "48-50" && x.StandardCode == SizeHelper.GetSizeStdCode(SizeStandartWomenWear.Rus)), "Нет 48-50");
Assert.That(sizeLists.Any(x => x.Size == "50" && x.StandardCode == SizeHelper.GetSizeStdCode(SizeStandartWomenWear.Rus)), "Нет 50");
Assert.That(sizeLists.Any(x => x.Size == "48" && x.StandardCode == SizeHelper.GetSizeStdCode(SizeStandartWomenWear.Rus)), "Нет 48");
}
private IList <SizePriceViewModel> BuildSizes(
IList <StyleItemDTO> styleItems,
IList <StyleItemCacheDTO> styleItemCaches,
IList <StyleItemSaleDTO> styleItemSales,
IList <StyleItemSaleToMarketDTO> saleToMarkets,
IList <StyleItemSaleToListingDTO> saleToListings,
IList <StyleItemActionHistoryDTO> recentPermanentPriceChangeByStyleItem,
IList <ItemDTO> itemPriceByStyleItem)
{
var resultSizes = new List <SizePriceViewModel>();
foreach (var styleItem in styleItems)
{
var styleItemSale = styleItemSales.OrderByDescending(si => si.CreateDate).FirstOrDefault(sic => sic.StyleItemId == styleItem.StyleItemId);
var styleItemCache = styleItemCaches.FirstOrDefault(sc => sc.Id == styleItem.StyleItemId);
var recentPermanentPriceChange = recentPermanentPriceChangeByStyleItem.FirstOrDefault(sc => sc.StyleItemId == styleItem.StyleItemId);
var itemPrice = itemPriceByStyleItem.FirstOrDefault(i => i.StyleItemId == styleItem.StyleItemId);
var size = new SizePriceViewModel();
size.StyleItemId = styleItem.StyleItemId;
size.SizeGroupName = styleItem.SizeGroupName;
size.Size = styleItem.Size;
size.Color = styleItem.Color;
size.Weight = styleItem.Weight;
size.MinPrice = styleItem.MinPrice;
size.MaxPrice = styleItem.MaxPrice;
size.LastChangeDate = recentPermanentPriceChange?.CreateDate;
size.MinListingPrice = itemPrice?.MinPrice;
size.MaxListingPrice = itemPrice?.MaxPrice;
if (styleItemCache != null)
{
size.RemainingQuantity = styleItemCache.RemainingQuantity;
}
if (styleItemSale != null)
{
size.SaleId = styleItemSale.Id;
size.SaleStartDate = styleItemSale.SaleStartDate;
size.SaleEndDate = styleItemSale.SaleEndDate;
size.MaxPiecesOnSale = styleItemSale.MaxPiecesOnSale;
size.MaxPiecesMode = styleItemSale.MaxPiecesMode;
size.PiecesSoldOnSale = styleItemSale.PiecesSoldOnSale;
size.SaleToMarkets = saleToMarkets
.Where(m => m.SaleId == styleItemSale.Id)
.Select(m => new MarketPriceViewViewModel(m))
.ToList();
}
resultSizes.Add(size);
}
return(resultSizes
.OrderBy(s => SizeHelper.GetSizeIndex(s.Size))
.ThenBy(s => s.Color)
.ToList());
}
/// <summary>
///
/// </summary>
/// <param name="db"></param>
/// <param name="dtoItem"></param>
/// <param name="canCreate"></param>
/// <returns></returns>
public StyleItemDTO FindOrCreateStyleAndStyleItemForItem(IUnitOfWork db,
int itemTypeId,
ItemDTO dtoItem,
bool canCreate,
bool noVariation)
{
var styleString = dtoItem.StyleString;
var styleId = dtoItem.StyleId;
Style style = null;
if (styleId.HasValue)
{
style = db.Styles.GetAllActive().FirstOrDefault(s => s.Id == styleId.Value);
}
if (style == null && !String.IsNullOrEmpty(styleString))
{
style = db.Styles.GetAllActive().FirstOrDefault(s => s.StyleID == styleString);
}
if (style == null &&
!String.IsNullOrEmpty(styleString) &&
canCreate)
{
_log.Info("Style create, from ItemId=" + dtoItem.Id + ", ASIN=" + dtoItem.ASIN + ", MarketplaceId=" + dtoItem.MarketplaceId);
_log.Info("New style info, styleId=" + styleString + ", itemTypeId=" + itemTypeId + ", name=" + dtoItem.Name + ", imageUrl=" + dtoItem.ImageUrl);
style = db.Styles.Store(styleString,
itemTypeId,
SizeHelper.ExcludeSizeInfo(dtoItem.Name),
dtoItem.ImageUrl,
_time.GetAppNowTime());
}
if (style != null)
{
var foundStyleItem = db.StyleItems.FindOrCreateForItem(style.Id,
itemTypeId,
dtoItem,
canCreate,
SizeMode.MappingNaming,
_time.GetAppNowTime());
//NOTE: Can be null, in this case take only styleId
if (foundStyleItem == null)
{
_log.Info("FindOrCreateForItem, Size=" + dtoItem.Size + " is empty");
return(new StyleItemDTO()
{
StyleId = style.Id,
});
}
else
{
return(foundStyleItem);
}
}
return(null);
}
public async Task <MagnetSearchResult> SearchAsync(string query, int page, CancellationToken cancellationToken = default)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
if (page <= 0)
{
throw new ArgumentOutOfRangeException(nameof(page));
}
var url = $"http://www.sobt5.pw/q/{HttpUtility.UrlEncode(query)}.html?sort=rel&page={page}";
var httpClient = _httpClientFactory.CreateClient();
var html = await httpClient.GetStringAsync(url);
var context = BrowsingContext.New();
var document = await context.OpenAsync(request => request.Content(html), cancel : cancellationToken);
var items = new List <MagnetItem>();
foreach (var element in document.QuerySelectorAll <IHtmlDivElement>("div.search-item"))
{
var anchor = element.QuerySelector <IHtmlAnchorElement>("div.item-title a");
var strings = anchor.Href.Split('/', '.');
var hash = strings[strings.Length - 2];
var size = element.QuerySelector(".item-bar > span:nth-last-child(2) > b").Text();
var date = element.QuerySelector("div.item-bar b").Text();
var item = new MagnetItem
{
Name = anchor.Text,
Magnet = "magnet:?xt=urn:btih:" + hash,
Size = SizeHelper.GetSize(size),
Date = DateTime.Parse(date)
};
items.Add(item);
}
var lastPage = 0;
var lastPageAnchor = document.QuerySelector <IHtmlAnchorElement>(".pagination > .last_p > a");
if (lastPageAnchor != null)
{
var queryString = HttpUtility.ParseQueryString(new Uri(lastPageAnchor.Href, UriKind.RelativeOrAbsolute).Query);
int.TryParse(queryString["page"], out lastPage);
}
return(new MagnetSearchResult
{
Items = items.ToArray(),
LastPage = lastPage
});
}
private void chkMaxSize_Checked(object sender, RoutedEventArgs e)
{
txtMaxSize.IsEnabled = true;
cmbMaxSize.IsEnabled = true;
if (!string.IsNullOrWhiteSpace(txtMaxSize.Text))
{
searchInfo.MaxSize = SizeHelper.GetSizeInBytes(txtMaxSize.Text, ((ContentControl)cmbMaxSize.SelectedValue).Content as string);
}
}
private void onProgressChanged(object sender, HttpProgressEventArgs e)
{
UploadProgress = e.ProgressPercentage;
BytesTransferedString = SizeHelper.Suffix(e.BytesTransferred);
if (e.TotalBytes != null)
{
BytesTotalString = SizeHelper.Suffix(e.TotalBytes.Value);
}
}
/// <summary>
/// Initialize with given buffer
/// </summary>
/// <param name="buffer"></param>
public StructTable(Span <byte> buffer)
{
var header = MemoryMarshal.Read <StructTableHeader>(buffer);
for (var i = 0; i < header.Count; ++i)
{
Entries.Add(buffer.Slice(SizeHelper.SizeOf <StructTableHeader>() + i * header.Size, header.Size).ToArray());
}
}
public async Task <MagnetSearchResult> SearchAsync(string query, int page, CancellationToken cancellationToken = default)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
if (page <= 0)
{
throw new ArgumentOutOfRangeException(nameof(page));
}
var url = $"https://www.torrentkitty.app/search/{HttpUtility.UrlEncode(query)}/{page}";
var httpClient = _httpClientFactory.CreateClient();
var html = await httpClient.GetStringAsync(url);
var context = BrowsingContext.New();
var document = await context.OpenAsync(request => request.Content(html), cancel : cancellationToken);
var items = new List <MagnetItem>();
foreach (var row in document.QuerySelectorAll <IHtmlTableRowElement>("#archiveResult tr:not(:first-child)"))
{
var name = row.QuerySelector <IHtmlTableDataCellElement>("td.name");
var size = row.QuerySelector <IHtmlTableDataCellElement>("td.size");
var date = row.QuerySelector <IHtmlTableDataCellElement>("td.date");
var magnet = row.QuerySelector <IHtmlAnchorElement>("td.action > a[rel='magnet']");
var item = new MagnetItem
{
Name = name.Text(),
Magnet = magnet.Href,
Size = SizeHelper.GetSize(size.Text()),
Date = DateTime.Parse(date.Text())
};
items.Add(item);
}
int lastPage = 0;
var pageAnchors = document.QuerySelectorAll <IHtmlAnchorElement>(".pagination > a").ToList();
if (pageAnchors.Any())
{
lastPage = pageAnchors.Select(temp =>
{
var text = temp.Text();
int.TryParse(text, out var i);
return(i);
}).Max();
}
return(new MagnetSearchResult()
{
Items = items.ToArray(),
LastPage = lastPage
});
}
public static ItemExportViewModel FromParentASIN(IUnitOfWork db,
string asin,
int market,
string marketplaceId,
out IList <MessageString> messages)
{
messages = new List <MessageString>();
var parentItem = db.ParentItems.GetAllAsDto().FirstOrDefault(s => s.ASIN == asin &&
s.Market == market &&
s.MarketplaceId == marketplaceId);
if (parentItem == null)
{
messages.Add(MessageString.Error("Parent ASIN was not found"));
return(null);
}
var items = db.Items.GetAllViewAsDto().Where(i => i.ParentASIN == parentItem.ASIN &&
!i.IsFBA &&
i.Market == parentItem.Market &&
i.MarketplaceId == parentItem.MarketplaceId)
.ToList();
foreach (var item in items)
{
item.BrandName = item.BrandName ?? parentItem.BrandName;
}
var model = new ItemExportViewModel();
var mainItem = items.FirstOrDefault();
StyleEntireDto style = mainItem != null && mainItem.StyleId.HasValue
? db.Styles.GetByStyleIdAsDto(mainItem.StyleId.Value)
: null;
var firstStyleString = items.Any() ? items.First().StyleString : "";
model.ASIN = parentItem.ASIN;
model.Id = parentItem.Id;
model.Market = (int)market;
model.MarketplaceId = marketplaceId;
model.Name = parentItem.AmazonName;
model.PictureSourceType = PictureSourceTypes.FromStyle; //NOTE: always generate excel with fresh images
model.ListingImage = mainItem?.ImageUrl;
model.StyleImage = style?.Image;
model.VariationList = items
.OrderBy(i => i.StyleId)
.ThenBy(i => SizeHelper.GetSizeIndex(i.StyleSize))
.Select(i => new ItemVariationExportViewModel(i)).ToList();
return(model);
}
public ChangelogViewModel(UpdateManager manager)
{
UpdateManager = manager;
DoInstall = new RelayCommand(o => DoInstall_Execute(), o => true);
Abort = new RelayCommand(o => Abort_Execute(), o => true);
LocProperties = LocalizationHelper.GetLocalizationProperties(UpdateManager.LanguageCulture,
UpdateManager.CultureFilePaths);
Header = string.Format(
UpdateManager.PackageConfigurations.Count() > 1
? LocProperties.NewUpdateDialogMultipleUpdatesHeader
: LocProperties.NewUpdateDialogSingleUpdateHeader, UpdateManager.PackageConfigurations.Count());
WindowIcon = GetIcon(_appIcon);
WindowTitle = string.Format(LocProperties.NewUpdateDialogSingleUpdateHeader,
UpdateManager.PackageConfigurations.Count());
InfoText = string.Format(LocProperties.NewUpdateDialogInfoText, Application.ProductName);
var availableVersions =
UpdateManager.PackageConfigurations.Select(item => new UpdateVersion(item.LiteralVersion)).ToArray();
AviableVersionText = string.Format(LocProperties.NewUpdateDialogAvailableVersionsText,
UpdateManager.PackageConfigurations.Count() <= 2
? string.Join(", ", availableVersions.Select(item => item.FullText))
: $"{UpdateVersion.GetLowestUpdateVersion(availableVersions).FullText} - {UpdateVersion.GetHighestUpdateVersion(availableVersions).FullText}");
CurrentVersionText = string.Format(LocProperties.NewUpdateDialogCurrentVersionText,
UpdateManager.CurrentVersion.FullText);
var size = SizeHelper.ConvertSize((long)UpdateManager.TotalSize);
UpdateSizeText = $"{string.Format(LocProperties.NewUpdateDialogSizeText, size)}";
foreach (var updateConfiguration in UpdateManager.PackageConfigurations)
{
var versionText = new UpdateVersion(updateConfiguration.LiteralVersion).FullText;
var changelogText = updateConfiguration.Changelog.ContainsKey(UpdateManager.LanguageCulture)
? updateConfiguration.Changelog.First(item => Equals(item.Key, UpdateManager.LanguageCulture)).Value
: updateConfiguration.Changelog.First(item => item.Key.Name == "en").Value;
ChangelogText +=
string.Format(string.IsNullOrEmpty(ChangelogText) ? "{0}:\n{1}" : "\n\n{0}:\n{1}",
versionText, changelogText);
}
if (OperationAreas == null || OperationAreas.Count == 0)
{
AccessesText = $"{LocProperties.NewUpdateDialogAccessText} -";
return;
}
AccessesText =
$"{LocProperties.NewUpdateDialogAccessText} {string.Join(", ", LocalizationHelper.GetLocalizedEnumerationValues(LocProperties, OperationAreas.Cast<object>().GroupBy(item => item).Select(item => item.First()).ToArray()))}";
}
public async Task <MagnetSearchResult> SearchAsync(string query, int page, CancellationToken cancellationToken = default)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
if (page <= 0)
{
throw new ArgumentOutOfRangeException(nameof(page));
}
var url = $"https://btos.pw/search/{HttpUtility.UrlEncode(query)}/page/{page}";
var httpClient = _httpClientFactory.CreateClient();
httpClient.DefaultRequestHeaders.Add("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Safari/537.36");
httpClient.DefaultRequestHeaders.Add("accept-language", "zh-CN,zh;q=0.9,ja;q=0.8");
var html = await httpClient.GetStringAsync(url);
var context = BrowsingContext.New();
var document = await context.OpenAsync(request => request.Content(html), cancel : cancellationToken);
var items = new List <MagnetItem>();
foreach (var row in document.QuerySelectorAll <IHtmlDivElement>("div.data-list > div.row:not(.hidden-xs)"))
{
var anchor = row.QuerySelector <IHtmlAnchorElement>("a");
var hash = anchor.Href.Split('/').Last();
var size = row.QuerySelector("div.size").Text();
var date = row.QuerySelector("div.date").Text();
var item = new MagnetItem
{
Name = anchor.Title,
Magnet = "magnet:?xt=urn:btih:" + hash,
Size = SizeHelper.GetSize(size),
Date = DateTime.Parse(date)
};
items.Add(item);
}
var lastPageAnchor = document.QuerySelectorAll <IHtmlAnchorElement>("ul.pagination a[name='numbar']").LastOrDefault();
var lastPage = 0;
if (lastPageAnchor != null)
{
int.TryParse(lastPageAnchor.Href.Split('/').LastOrDefault(), out lastPage);
}
return(new MagnetSearchResult
{
Items = items.ToArray(),
LastPage = lastPage
});
}
protected override void OnMouseMove(System.Windows.Input.MouseEventArgs e)
{
base.OnMouseMove(e);
var popup = GetPopupTipWindow();
if (popup.IsOpen)
{
popup.Hide();
}
if (bitmapInvalidated)
{
return;
}
Point p = e.GetPosition(this);
Point dp = p.ScreenToData(Plotter2D.Transform);
var tooltip = GetTooltipForPoint(p, completedRequest.Visible, completedRequest.Output);
if (tooltip == null)
{
return;
}
popup.VerticalOffset = p.Y + 20;
popup.HorizontalOffset = p.X;
popup.ShowDelayed(new TimeSpan(0, 0, 1));
Grid grid = new Grid();
Rectangle rect = new Rectangle
{
Stroke = Brushes.Black,
Fill = SystemColors.InfoBrush
};
StackPanel sp = new StackPanel();
sp.Orientation = Orientation.Vertical;
sp.Children.Add(tooltip);
sp.Margin = new Thickness(4, 2, 4, 2);
var tb = new TextBlock();
tb.Text = String.Format("Location: {0:F2}, {1:F2}", dp.X, dp.Y);
tb.Foreground = SystemColors.GrayTextBrush;
sp.Children.Add(tb);
grid.Children.Add(rect);
grid.Children.Add(sp);
grid.Measure(SizeHelper.CreateInfiniteSize());
popup.Child = grid;
}
public ItemInfoViewModel(ItemInfoDTO itemInfo)
{
ASIN = itemInfo.ASIN;
Size = itemInfo.Size;
ColorVariation = itemInfo.ColorVariation;
FormattedSize = SizeHelper.FormatSize(Size);
Color = itemInfo.Color;
StyleId = itemInfo.StyleId;
StyleString = itemInfo.StyleString;
StyleItemId = itemInfo.StyleItemId;
StyleSize = itemInfo.StyleSize;
StyleColor = itemInfo.StyleColor;
IsFBA = itemInfo.IsFBA;
CurrentPrice = itemInfo.CurrentPrice;
AmazonCurrentPrice = itemInfo.AmazonCurrentPrice;
FBAFee = itemInfo.FBAFee;
SalePrice = itemInfo.SalePrice;
SaleStartDate = itemInfo.SaleStartDate;
SaleEndDate = itemInfo.SaleEndDate;
RealQuantity = itemInfo.RealQuantity;
DisplayQuantity = itemInfo.DisplayQuantity;
AmazonRealQuantity = itemInfo.AmazonRealQuantity;
InventoryQuantity = itemInfo.InventoryQuantity;
ListingSoldQuantity = itemInfo.ListingSoldQuantity;
MarketSoldQuantity = itemInfo.MarketSoldQuantity;
ScannedSoldQuantity = itemInfo.ScannedSoldQuantity;
SpecialCaseSoldQuantity = itemInfo.SpecialCaseQuantity;
RemainingQuantity = itemInfo.RemainingQuantity < 0 ? 0 : itemInfo.RemainingQuantity;
TotalMarketSoldQuantity = itemInfo.TotalMarketSoldQuantity;
TotalScannedSoldQuantity = itemInfo.TotalScannedSoldQuantity;
TotalSpecialCaseSoldQuantity = itemInfo.TotalSpecialCaseQuantity;
LastOrder = itemInfo.LastOrder;
LinkedListingCount = itemInfo.LinkedListingCount;
OpenDate = itemInfo.OpenDate ?? itemInfo.CreateDate;
SizeIndex = SizeHelper.GetSizeIndex(Size);
if (itemInfo.ListingDefects != null)
{
ListingDefects = itemInfo.ListingDefects
.Select(d => new ListingDefectViewModel(d))
.ToList();
}
}
private static IEnumerable <Tuple <string, long> > GetSizes(Session session, JET_DBID db, Action <string> progress, CancellationToken token)
{
progress("Calculating total db size");
int dbPages;
Api.JetGetDatabaseInfo(session, db, out dbPages, JET_DbInfo.Filesize);
var dbTotalSize = (long)dbPages * SystemParameters.DatabasePageSize;
yield return(Tuple.Create("Total db size: " + SizeHelper.Humane(dbTotalSize), dbTotalSize));
token.ThrowIfCancellationRequested();
foreach (var tableName in Api.GetTableNames(session, db))
{
using (var tbl = new Table(session, db, tableName, OpenTableGrbit.None))
{
token.ThrowIfCancellationRequested();
progress("Computing stats for table: " + tableName);
Api.JetComputeStats(session, tbl);
JET_OBJECTINFO result;
Api.JetGetTableInfo(session, tbl, out result, JET_TblInfo.Default);
var sb = new StringBuilder(tableName).AppendLine();
var usedSize = (long)result.cPage * SystemParameters.DatabasePageSize;
int ownedPages;
Api.JetGetTableInfo(session, tbl, out ownedPages, JET_TblInfo.SpaceOwned);
sb.Append("\tOwned Size: ")
.Append(SizeHelper.Humane((long)ownedPages * SystemParameters.DatabasePageSize))
.AppendLine();
sb.Append("\tUsed Size: ")
.Append(SizeHelper.Humane(usedSize))
.AppendLine();
sb.Append("\tRecords: ").AppendFormat("{0:#,#;;0}", result.cRecord).AppendLine();
sb.Append("\tIndexes:").AppendLine();
foreach (var index in Api.GetTableIndexes(session, tbl))
{
token.ThrowIfCancellationRequested();
sb.Append("\t\t")
.Append(index.Name)
.Append(": ")
.Append(SizeHelper.Humane((long)index.Pages * (SystemParameters.DatabasePageSize)))
.AppendLine();
}
yield return(Tuple.Create(sb.ToString(), (long)ownedPages * SystemParameters.DatabasePageSize));
}
}
}
public HttpResponseMessage DatabaseSize()
{
var totalSizeOnDisk = Database.GetTotalSizeOnDisk();
return(GetMessageWithObject(new
{
DatabaseSize = totalSizeOnDisk,
DatabaseSizeHumane = SizeHelper.Humane(totalSizeOnDisk)
}));
}
private void SetWindowMinSize()
{
float minWindowWidth = (float)(double)Resources["AppMinWindowWidth"];
float minWindowHeight = (float)(double)Resources["AppMinWindowHeight"];
Size minWindowSize = SizeHelper.FromDimensions(minWindowWidth, minWindowHeight);
var appView = ApplicationView.GetForCurrentView();
appView.SetPreferredMinSize(minWindowSize);
}
/// <summary>
/// Initialize with given buffer
/// </summary>
/// <param name="buffer"></param>
public ECB(Span <byte> buffer)
{
Header = MemoryMarshal.Read <ECBHeader>(buffer);
for (var i = 0; i < Header.EntryCount; ++i)
{
Entries.Add(buffer.Slice(SizeHelper.SizeOf <ECBHeader>().Align(0x10) + i * Header.Stride, Header.Stride).ToArray());
}
DynamicData = buffer.Slice(Header.DynamicDataPointer, Header.TotalSize - Header.DynamicDataPointer).ToArray();
}
/// <summary>
/// Initialize with a stream
/// </summary>
/// <param name="stream"></param>
/// <param name="a18">set to true if the PAKs are from Atelier Sophie or a newer Atelier</param>
public PAK(Stream stream, bool a18 = true)
{
Is64Bit = a18;
BaseStream = stream;
EnsureCanRead();
var blob = new Span <byte>(new byte[SizeHelper.SizeOf <PAKHeader>()]);
BaseStream.Read(blob);
Header = MemoryMarshal.Read <PAKHeader>(blob);
Logger.Assert(Header.Version == 0x20000, "Header.Version == 0x20000", "Version mismatch");
Logger.Assert(Header.HeaderSize == 0x10, "Header.HeaderSize != 0x10", "Signature mismatch");
Logger.Assert(Header.Flags == 0x0D, "Header.Flags == 0x0D", "Flags mismatch");
Logger.Assert(Header.FileCount <= 0x4000, "Header.FileCount <= 0x4000", "Too many files");
Entries = new List <PAKEntry>(Header.FileCount);
var entrySize = Is64Bit ? 0xA8 : 0xA0;
blob = new Span <byte>(new byte[entrySize * Header.FileCount]);
BaseStream.Read(blob);
DataStart = BaseStream.Position;
var cursor = 0;
for (var i = 0; i < Header.FileCount; ++i)
{
var entryBlob = blob.Slice(cursor, entrySize);
cursor += entrySize;
var filenameBlob = entryBlob.Slice(0, 0x80);
var size = MemoryMarshal.Read <int>(entryBlob.Slice(0x80));
var key = entryBlob.Slice(0x84, 20).ToArray();
var infoBlob = entryBlob.Slice(0x98);
var info = Is64Bit ? MemoryMarshal.Cast <byte, long>(infoBlob).ToArray() : MemoryMarshal.Cast <byte, uint>(infoBlob).ToArray().Select(x => (long)x).ToArray();
var encrypted = key.Any(x => x != 0);
if (encrypted)
{
Recode(filenameBlob, key);
}
var filename = filenameBlob.ReadStringNonNull();
Entries.Add(new PAKEntry
{
Filename = filename,
Size = size,
Key = key,
Offset = info[0],
Flags = info[1],
IsEncrypted = encrypted
});
}
}
public static void IoTest(GenericPerformanceTestRequest request)
{
DiskPerformanceResult result;
using (var tester = AbstractDiskPerformanceTester.ForRequest(request, Console.WriteLine))
{
tester.DescribeTestParameters();
tester.TestDiskIO();
result = tester.Result;
}
var hasReads = request.OperationType == OperationType.Read || request.OperationType == OperationType.Mix;
var hasWrites = request.OperationType == OperationType.Write || request.OperationType == OperationType.Mix;
if (hasReads)
{
var sb = new StringBuilder();
sb.AppendLine(string.Format("Total read: {0}", SizeHelper.Humane(result.TotalRead)));
sb.AppendLine(string.Format("Average read: {0}/s", SizeHelper.Humane(result.TotalRead / request.TimeToRunInSeconds)));
sb.AppendLine("Read latency");
sb.AppendLine(string.Format("\tMin: {0:#,#.##;;0}", result.ReadLatency.Min));
sb.AppendLine(string.Format("\tMean: {0:#,#.##;;0}", result.ReadLatency.Mean));
sb.AppendLine(string.Format("\tMax: {0:#,#.##;;0}", result.ReadLatency.Max));
sb.AppendLine(string.Format("\tStdev: {0:#,#.##;;0}", result.ReadLatency.Stdev));
sb.AppendLine("Read latency percentiles");
foreach (var percentile in result.ReadLatency.Percentiles)
{
sb.AppendLine(string.Format("\t{0}: {1:#,#.##;;0}", percentile.Key, percentile.Value));
}
sb.AppendLine();
Console.WriteLine(sb.ToString());
}
if (hasWrites)
{
var sb = new StringBuilder();
sb.AppendLine(string.Format("Total write: {0}", SizeHelper.Humane(result.TotalWrite)));
sb.AppendLine(string.Format("Average write: {0}/s", SizeHelper.Humane(result.TotalWrite / request.TimeToRunInSeconds)));
sb.AppendLine("Write latency");
sb.AppendLine(string.Format("\tMin: {0:#,#.##;;0}", result.WriteLatency.Min));
sb.AppendLine(string.Format("\tMean: {0:#,#.##;;0}", result.WriteLatency.Mean));
sb.AppendLine(string.Format("\tMax: {0:#,#.##;;0}", result.WriteLatency.Max));
sb.AppendLine(string.Format("\tStdev: {0:#,#.##;;0}", result.WriteLatency.Stdev));
sb.AppendLine("Write latency percentiles");
foreach (var percentile in result.WriteLatency.Percentiles)
{
sb.AppendLine(string.Format("\t{0}: {1:#,#.##;;0}", percentile.Key, percentile.Value));
}
sb.AppendLine();
Console.WriteLine(sb.ToString());
}
}
