public override async Task ProcessActivityAsync(IStatus status)
{
var cleanupTask = await statusController.CreateAsync(status, $"Cleanup {context}");
var expectedItems = await itemizeAllExpectedItemsAsyncDelegate.ItemizeAllAsync(status);
var actualItems = await itemizeAllActualItemsAsyncDelegate.ItemizeAllAsync(status);
var unexpectedItems = actualItems.Except(expectedItems);
var cleanupItems = new List <string>();
foreach (var unexpectedItem in unexpectedItems)
{
foreach (var detailedItem in itemizeDetailsDelegate.Itemize(unexpectedItem))
{
cleanupItems.Add(detailedItem);
cleanupItems.Add(formatSupplementaryItemDelegate.Format(detailedItem));
}
}
var moveToRecycleBinTask = await statusController.CreateAsync(status, "Move unexpected items to recycle bin");
var current = 0;
foreach (var item in cleanupItems)
{
await statusController.UpdateProgressAsync(
moveToRecycleBinTask,
++current,
cleanupItems.Count,
item);
recycleDelegate.Recycle(item);
}
// check if any of the directories are left empty and delete
var emptyDirectories = new List <string>();
foreach (var item in cleanupItems)
{
var directory = Path.GetDirectoryName(item);
if (!emptyDirectories.Contains(directory) &&
!directoryController.EnumerateFiles(directory).Any() &&
!directoryController.EnumerateDirectories(directory).Any())
{
emptyDirectories.Add(directory);
}
}
foreach (var directory in emptyDirectories)
{
directoryController.Delete(directory);
}
await statusController.CompleteAsync(moveToRecycleBinTask);
}
public override async Task ProcessActivityAsync(IStatus status)
{
var updateProductsTask = await statusController.CreateAsync(status, $"Update {updateTypeDescription}");
// We'll limit detail updates to user specified ids.
// if user didn't provide a list of ids - we'll use the details gaps
// (ids that exist in master list, but not detail) and updated
var productsUpdateList = await itemizeUserRequestedOrDefaultAsyncDelegate.ItemizeAllAsync(updateProductsTask);
var currentProduct = 0;
foreach (var id in productsUpdateList)
{
var product = await masterDataController.GetByIdAsync(id, updateProductsTask);
if (product == null)
{
continue;
}
await statusController.UpdateProgressAsync(
updateProductsTask,
++currentProduct,
productsUpdateList.Count(),
product.Title);
var updateIdentity = getUpdateIdentityDelegate.GetUpdateIdentity(product);
if (string.IsNullOrEmpty(updateIdentity))
{
continue;
}
var uri = string.Format(
getUpdateUriDelegate.GetUpdateUri(context),
updateIdentity);
var data = await getDeserializedDelegate.GetDeserializedAsync(updateProductsTask, uri);
if (data != null)
{
fillGapsDelegate?.FillGaps(data, product);
await detailDataController.UpdateAsync(data, updateProductsTask);
}
}
await detailDataController.CommitAsync(updateProductsTask);
await statusController.CompleteAsync(updateProductsTask);
}
public async Task <IDictionary <long, IList <string> > > GetDownloadSourcesAsync(IStatus status)
{
var getDownloadSourcesStatus = await statusController.CreateAsync(status, "Get download sources");
var productImageSources = new Dictionary <long, IList <string> >();
var productIds = await itemizeAllProductsAsyncDelegate.ItemizeAllAsync(getDownloadSourcesStatus);
var current = 0;
foreach (var id in productIds)
{
await statusController.UpdateProgressAsync(
getDownloadSourcesStatus,
++current,
productIds.Count(),
id.ToString());
var productCore = await dataController.GetByIdAsync(id, getDownloadSourcesStatus);
// not all updated products can be found with all dataControllers
if (productCore == null)
{
continue;
}
var imageSources = new List <string> {
formatImagesUriDelegate.Format(
getImageUriDelegate.GetImageUri(productCore))
};
if (!productImageSources.ContainsKey(id))
{
productImageSources.Add(id, new List <string>());
}
foreach (var source in imageSources)
{
productImageSources[id].Add(source);
}
}
await statusController.CompleteAsync(getDownloadSourcesStatus);
return(productImageSources);
}
public async Task <IEnumerable <long> > ItemizeAllAsync(IStatus status)
{
var userRequestedIds = await itemizeUserRequestedIdsAsyncDelegate.ItemizeAllAsync(status);
if (userRequestedIds != null || userRequestedIds.Any())
{
return(userRequestedIds);
}
var otherIds = new List <long>();
foreach (var enumerableDelegate in itemizeDefaultIdsDelegates)
{
otherIds.AddRange(await enumerableDelegate.ItemizeAllAsync(status));
}
return(otherIds);
}
public override async Task ProcessActivityAsync(IStatus status)
{
var validateProductsStatus = await statusController.CreateAsync(status, "Validate products");
var current = 0;
var validateProductsList = await itemizeAllProductsAsyncDelegate.ItemizeAllAsync(validateProductsStatus);
var validateProductsCount = validateProductsList.Count();
foreach (var id in validateProductsList)
{
var gameDetails = await gameDetailsDataController.GetByIdAsync(id, validateProductsStatus);
var validationResults = await validationResultsDataController.GetByIdAsync(id, validateProductsStatus);
if (validationResults == null)
{
validationResults = new ValidationResult
{
Id = id,
Title = gameDetails.Title
}
}
;
await statusController.UpdateProgressAsync(validateProductsStatus,
++current,
validateProductsCount,
gameDetails.Title);
var localFiles = new List <string>();
var getLocalFilesTask = await statusController.CreateAsync(validateProductsStatus, "Enumerate local product files");
foreach (var manualUrl in
await itemizeGameDetailsManualUrlsAsyncDelegate.ItemizeAsync(gameDetails, getLocalFilesTask))
{
var resolvedUri = await routingController.TraceRouteAsync(id, manualUrl, getLocalFilesTask);
// use directory from source and file from resolved URI
var localFile = Path.Combine(
productFileDirectoryDelegate.GetDirectory(manualUrl),
productFileFilenameDelegate.GetFilename(resolvedUri));
localFiles.Add(localFile);
}
await statusController.CompleteAsync(getLocalFilesTask);
// check if current validation results allow us to skip validating current product
// otherwise - validate all the files again
// ...
var fileValidationResults = new List <IFileValidationResult>(localFiles.Count);
var validateFilesTask = await statusController.CreateAsync(
validateProductsStatus,
"Validate product files");
var currentFile = 0;
foreach (var localFile in localFiles)
{
await statusController.UpdateProgressAsync(validateFilesTask,
++currentFile,
localFiles.Count,
localFile);
var validationFile = formatValidationFileDelegate.Format(localFile);
try
{
fileValidationResults.Add(await fileValidationController.ValidateFileAsync(
localFile,
validationFile,
validateFilesTask));
}
catch (Exception ex)
{
await statusController.FailAsync(validateProductsStatus,
$"{localFile}: {ex.Message}");
}
}
await statusController.CompleteAsync(validateFilesTask);
validationResults.Files = fileValidationResults.ToArray();
var updateValidationResultsTask = await statusController.CreateAsync(
validateProductsStatus,
"Update validation results");
await validationResultsDataController.UpdateAsync(validationResults, validateProductsStatus);
await statusController.CompleteAsync(updateValidationResultsTask);
}
await statusController.CompleteAsync(validateProductsStatus);
}
}
