public FileOverviewViewModel(FileOverview fileOverview, IServiceProvider serviceProvider)
{
serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
_fileOverview = fileOverview ?? throw new ArgumentNullException(nameof(fileOverview));
_brushesProvider = serviceProvider.GetRequiredService <IBrushesProvider>();
VerifyNcasHeaderSignatureCommand = serviceProvider.GetRequiredService <IVerifyNcasHeaderSignatureCommand>();
VerifyNcasHashCommand = serviceProvider.GetRequiredService <IVerifyNcasHashCommand>();
CopyMissingKeysCommand = new RelayCommand(CopyMissingKeys);
_fileOverview.PropertyChanged += OnFileOverviewPropertyChanged;
_fileOverview.MissingKeys.CollectionChanged += (_, _) =>
{
UpdateMissingKeys();
};
foreach (var cnmtContainerViewModel in _fileOverview.CnmtContainers.Select((contentOverview, i) => new CnmtContainerViewModel(contentOverview, i + 1, serviceProvider)))
{
CnmtContainers.Add(cnmtContainerViewModel);
}
SelectedCnmtContainer = CnmtContainers.FirstOrDefault();
UpdateMissingKeys();
UpdateNcasHashExceptions();
UpdateNcasHeadersSignatureExceptions();
}
public NxFile(string path, IItem rootItem, FileOverview overview)
{
Path = path;
RootItem = rootItem;
Overview = overview;
FileName = System.IO.Path.GetFileName(path);
}
private static PackageType DeterminePackageType(FileOverview fileOverview, CnmtContainer[] cnmtContainers)
{
PackageType packageType;
if (cnmtContainers.Length > 1)
{
var rootItemType = fileOverview.RootItem.GetType();
if (rootItemType == typeof(XciItem))
{
packageType = PackageType.SuperXCI;
}
else if (rootItemType == typeof(NspItem))
{
packageType = PackageType.SuperNSP;
}
else
{
packageType = PackageType.Unknown;
}
}
else
{
packageType = PackageType.Normal;
}
return(packageType);
}
void CreateFavoritesOverviews(FavoritesPageResJson filePageResJson)
{
foreach (FileJson fileJson in filePageResJson.files)
{
GameObject fileOverviewPanel = Instantiate(fileOverviewPanelPrefab, FavoritesScrollViewContent.transform);
FileOverview fileOverview = fileOverviewPanel.GetComponent <FileOverview>();
fileOverview.Init(fileJson);
}
}
private FileOverview FillOverview(FileOverview fileOverview, PartitionFileSystemItemBase partitionItem)
{
var cnmtContainers = BuildCnmtContainers(partitionItem).ToArray();
var packageType = DeterminePackageType(fileOverview, cnmtContainers);
fileOverview.PackageType = packageType;
fileOverview.CnmtContainers.AddRange(cnmtContainers);
return(fileOverview);
}
void CreateFileOverviews(FilePageResJson filePageResJson)
{
foreach (FileJson fileJson in filePageResJson.file_list)
{
if (email != null && !email.Equals(WebReq.email) && fileJson.anonymous)
{
continue;
}
GameObject fileOverviewPanel = Instantiate(fileOverviewPanelPrefab, filePanel.transform);
FileOverview fileOverview = fileOverviewPanel.GetComponent <FileOverview>();
fileOverview.Init(fileJson);
}
}
public void init(FileOverview fileOverview)
{
fileCoverImage.sprite = fileOverview.fileCoverImage.sprite;
authorName.text = fileOverview.authorName.text;
description.text = fileOverview.description.text;
downloads.text = fileOverview.downloads.text;
likes.text = fileOverview.likes.text;
date.text = fileOverview.date.text;
DownloadKey = fileOverview.key;
rateText.text = fileOverview.rateText.text;
rateImage.fillAmount = fileOverview.rateImage.fillAmount;
fileName.text = fileOverview.fileName.text;
WorkShopEvents.loginEvent.AddListener(RequestComments);
WorkShopEvents.logoutEvent.AddListener(RequestComments);
string filePath = Application.dataPath + "/StreamingAssets/DownloadedGameFiles";
DirectoryInfo d = new DirectoryInfo(filePath);
if (WebReq.email != null && DownloadKey.Contains(WebReq.email))
{
// NOTHING
}
else
{
foreach (var currDirectory in d.GetDirectories())
{
Debug.Log(currDirectory.Name);
string filename = Regex.Replace(DownloadKey, @"[^0-9a-zA-Z]+", "");
if (currDirectory.Name.Equals(filename))
{
// Then there's a match
denominator.gameObject.SetActive(true);
personalRatingText.gameObject.SetActive(true);
visibleUserRating.gameObject.SetActive(true);
rateOneButton.SetActive(true);
rateTwoButton.SetActive(true);
rateThreeButton.SetActive(true);
rateFourButton.SetActive(true);
rateFiveButton.SetActive(true);
break;
}
// Hello Moto
}
}
RequestComments();
//likeToggle.isOn = false;
}
public FileOverview CreateXciOverview(XciItem xciItem)
{
// NOTE: the secure partition of an XCI is equivalent to an NSP
var securePartitionItem = xciItem.ChildItems.FirstOrDefault(partition => partition.XciPartitionType == XciPartitionType.Secure);
var fileOverview = new FileOverview(xciItem);
if (securePartitionItem == null)
{
var message = LocalizationManager.Instance.Current.Keys.LoadingError_XciSecurePartitionNotFound;
xciItem.Errors.Add(message);
_logger.LogError(message);
return(fileOverview);
}
return(FillOverview(fileOverview, securePartitionItem));
}
public IEnumerator AnonmyousAuthorPasses()
{
// Use the Assert class to test conditions.
// Use yield to skip a frame.
loginAndSignUp.loginEmailInput.text = "*****@*****.**";
loginAndSignUp.loginPasswordInput.text = "12";
loginAndSignUp.RequestLogin();
yield return(new WaitForSeconds(5f));
adminFilePage.Init(WebReq.email);
yield return(new WaitForSeconds(5f));
FileOverview fileOverview = adminFilePage.filePanel.transform.GetChild(2).GetComponent <FileOverview>();
Assert.IsTrue(fileOverview.authorName.text.Equals("anonymous"));
yield return(null);
}
public void Setup()
{
GameObject o = new GameObject("cavasObj");
o.AddComponent <Canvas>();
GameObject fileOverviewPanel = Object.Instantiate((GameObject)Resources.Load("Prefabs/File overview Panel"), o.transform);
fileOverview = fileOverviewPanel.GetComponent <FileOverview>();
Debug.Log(fileOverview);
FileJson fileJson = new FileJson();
fileJson.anonymous = false;
fileJson.email = "*****@*****.**";
fileJson.dateUpdated = "1561736000534";
fileJson.fileName = "";
fileJson.infoDownloadUrl = new InfoDownloadUrl();
fileJson.infoDownloadUrl.status = 200;
fileJson.infoDownloadUrl.URL = "";
fileJson.key = "[email protected]|SpangeBob";
fileOverview.Init(fileJson);
}
private void VerifyHashes(IProgressReporter progressReporter, FileOverview fileOverview, CancellationToken cancellationToken)
{
fileOverview.NcasHashExceptions = null;
// Build the list of all CnmtContentEntry with their corresponding CnmtItem
// The CnmtContentEntry contains a reference to an NCA with the expected Sha256 hash
var itemsToProcess = new List <Tuple <CnmtContentEntry, CnmtItem> >();
foreach (var cnmtItem in fileOverview.CnmtContainers.Select(container => container.CnmtItem))
{
itemsToProcess.AddRange(cnmtItem.Cnmt.ContentEntries.Select(cnmtContentEntry =>
{
cnmtItem.Errors.RemoveAll(NCA_HASH_CATEGORY);
return(new Tuple <CnmtContentEntry, CnmtItem>(cnmtContentEntry, cnmtItem));
}));
}
if (itemsToProcess.Count <= 0)
{
fileOverview.NcasHashValidity = NcasValidity.NoNca;
return;
}
var occurredExceptions = new List <Exception>();
var allValid = true;
var operationCanceled = false;
try
{
fileOverview.NcasHashValidity = NcasValidity.InProgress;
var processedItem = 0;
foreach (var(cnmtContentEntry, cnmtItem) in itemsToProcess)
{
cancellationToken.ThrowIfCancellationRequested();
progressReporter.SetPercentage(0.0);
var progressText = LocalizationManager.Instance.Current.Keys.NcaHash_ProgressText.SafeFormat(++processedItem, itemsToProcess.Count);
progressReporter.SetText(progressText);
var expectedNcaHash = cnmtContentEntry.Hash;
var expectedNcaId = cnmtContentEntry.NcaId.ToStrId();
// Search for the referenced NCA
var ncaItem = fileOverview.NcaItems.FirstOrDefault(item => item.FileName.StartsWith(expectedNcaId + ".", StringComparison.OrdinalIgnoreCase));
if (ncaItem == null)
{
cnmtItem.Errors.Add(NCA_HASH_CATEGORY, LocalizationManager.Instance.Current.Keys.NcaHash_CnmtItem_Error_NcaMissing.SafeFormat(expectedNcaId));
continue;
}
try
{
ncaItem.Errors.RemoveAll(NCA_HASH_CATEGORY);
//=============================================//
//===============> Verify Hash <===============//
VerifyFileHash(progressReporter, ncaItem.File, _appSettings.ProgressBufferSize, expectedNcaHash, cancellationToken, out var hashValid);
//===============> Verify Hash <===============//
//=============================================//
if (!hashValid)
{
allValid = false;
ncaItem.Errors.Add(NCA_HASH_CATEGORY, LocalizationManager.Instance.Current.Keys.NcaHash_NcaItem_Invalid);
_logger.LogError(LocalizationManager.Instance.Current.Keys.NcaHash_Invalid_Log.SafeFormat(ncaItem.DisplayName));
}
else
{
_logger.LogInformation(LocalizationManager.Instance.Current.Keys.NcaHash_Valid_Log.SafeFormat(ncaItem.DisplayName));
}
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
allValid = false;
occurredExceptions.Add(ex);
ncaItem.Errors.Add(NCA_HASH_CATEGORY, LocalizationManager.Instance.Current.Keys.NcaHash_NcaItem_Exception.SafeFormat(ex.Message));
_logger.LogError(ex, LocalizationManager.Instance.Current.Keys.NcaHash_Exception_Log.SafeFormat(ncaItem.DisplayName, ex.Message));
}
}
}
catch (OperationCanceledException)
{
_logger.LogWarning(LocalizationManager.Instance.Current.Keys.Log_NcaHashCanceled);
operationCanceled = true;
}
catch (Exception ex)
{
allValid = false;
occurredExceptions.Add(ex);
_logger.LogError(ex, LocalizationManager.Instance.Current.Keys.NcasHash_Error_Log.SafeFormat(ex.Message));
}
if (operationCanceled)
{
fileOverview.NcasHashValidity = NcasValidity.Unchecked;
}
else if (occurredExceptions.Count > 0)
{
fileOverview.NcasHashExceptions = occurredExceptions;
fileOverview.NcasHashValidity = NcasValidity.Error;
}
else
{
fileOverview.NcasHashValidity = allValid ? NcasValidity.Valid : NcasValidity.Invalid;
}
}
public void Setup(FileOverview fileOverview)
{
_fileOverview = fileOverview ?? throw new ArgumentNullException(nameof(fileOverview));
}
private void VerifySignatures(IProgressReporter progressReporter, FileOverview fileOverview)
{
fileOverview.NcasHeadersSignatureExceptions = null;
var ncaItems = fileOverview.NcaItems;
if (ncaItems.Count <= 0)
{
fileOverview.NcasHeadersSignatureValidity = NcasValidity.NoNca;
return;
}
fileOverview.NcasHeadersSignatureValidity = NcasValidity.InProgress;
var allValid = true;
var occurredExceptions = new List <Exception>();
try
{
progressReporter.SetPercentage(0);
var i = 0;
foreach (var ncaItem in ncaItems)
{
ncaItem.Errors.RemoveAll(NCA_HEADER_SIGNATURE_CATEGORY);
try
{
//=============================================//
//===============> Verify Hash <===============//
var validity = ncaItem.Nca.VerifyHeaderSignature();
//===============> Verify Hash <===============//
//=============================================//
ncaItem.HeaderSignatureValidity = validity;
if (validity != Validity.Valid)
{
allValid = false;
ncaItem.Errors.Add(NCA_HEADER_SIGNATURE_CATEGORY, LocalizationManager.Instance.Current.Keys.NcaHeaderSignature_Invalid.SafeFormat(validity.ToString()));
_logger.LogError(LocalizationManager.Instance.Current.Keys.NcaHeaderSignature_Invalid_Log.SafeFormat(ncaItem.DisplayName, validity.ToString()));
}
else
{
_logger.LogInformation(LocalizationManager.Instance.Current.Keys.NcaHeaderSignature_Valid_Log.SafeFormat(ncaItem.DisplayName, validity.ToString()));
}
}
catch (Exception ex)
{
allValid = false;
occurredExceptions.Add(ex);
ncaItem.Errors.Add(NCA_HEADER_SIGNATURE_CATEGORY, LocalizationManager.Instance.Current.Keys.NcaHeaderSignature_Error.SafeFormat(ex.Message));
_logger.LogError(ex, LocalizationManager.Instance.Current.Keys.NcaHeaderSignature_Error_log.SafeFormat(ncaItem.DisplayName, ex.Message));
}
progressReporter.SetPercentage(++i / (double)ncaItems.Count);
}
progressReporter.SetPercentage(1);
}
catch (Exception ex)
{
allValid = false;
occurredExceptions.Add(ex);
_logger.LogError(ex, LocalizationManager.Instance.Current.Keys.NcasHeaderSignature_Error_Log.SafeFormat(ex.Message));
}
if (occurredExceptions.Count > 0)
{
fileOverview.NcasHeadersSignatureExceptions = occurredExceptions;
fileOverview.NcasHeadersSignatureValidity = NcasValidity.Error;
}
else
{
fileOverview.NcasHeadersSignatureValidity = allValid ? NcasValidity.Valid : NcasValidity.Invalid;
}
}
public FileOverview CreateNspOverview(NspItem nspItem)
{
var fileOverview = new FileOverview(nspItem);
return(FillOverview(fileOverview, nspItem));
}
