public IDeliveryQuotation GetAssetsDeliveryQuotations(IAssetsContainer assetsContainer, IDestination destination)
{
Dictionary <string, IOrderedEnumerable <IDelivery> > assetsQuotes = new Dictionary <string, IOrderedEnumerable <IDelivery> >();
Dictionary <string, Exception> assetsExceptions = new Dictionary <string, Exception>();
foreach (var asset in assetsContainer.Assets)
{
try
{
string relPath = null;
if (assetsContainer.Uri != null && assetsContainer.Uri.IsAbsoluteUri)
{
var relUri = assetsContainer.Uri.MakeRelativeUri(asset.Value.Uri);
// Use the relative path only if a sub-directory
if (!relUri.IsAbsoluteUri && !relUri.ToString().StartsWith(".."))
{
relPath = Path.GetDirectoryName(relUri.ToString());
}
}
var assetsDeliveryQuotations = GetSingleDeliveryQuotations(asset.Value, destination.To(asset.Value, relPath));
assetsQuotes.Add(asset.Key, assetsDeliveryQuotations);
}
catch (Exception e)
{
logger.LogDebug("Cannot quote delivery for {0}: {1}", asset.Value.Uri, e.Message);
assetsExceptions.Add(asset.Key, e);
}
}
return(new DeliveryQuotation(assetsQuotes, assetsExceptions));
}
public FilteredAssetContainer(IAssetsContainer assetsContainer, AssetFilters assetFilters)
{
if (assetsContainer == null)
{
throw new ArgumentNullException("assetsContainer");
}
this.assetsContainer = assetsContainer;
this.assetFilters = assetFilters;
}
public static void MergeAssets(this StacItem stacItem, IAssetsContainer assetContainer, bool removeIfNotInContainer = false)
{
if (removeIfNotInContainer)
{
stacItem.Assets.Clear();
}
foreach (var asset in assetContainer.Assets)
{
if (stacItem.Assets.ContainsKey(asset.Key))
{
stacItem.Assets.Remove(asset.Key);
}
stacItem.Assets.Add(asset.Key, asset.Value.CreateStacAsset(stacItem));
}
}
public async Task <IResource> Process(IResource route, IDestination destination, string suffix = null)
{
IItem item = route as IItem;
if (item == null)
{
return(route);
}
IAssetsContainer assetsContainer = route as IAssetsContainer;
Dictionary <string, IAsset> newAssets = new Dictionary <string, IAsset>();
foreach (var asset in assetsContainer.Assets)
{
try
{
if (!IsArchive(asset.Value))
{
newAssets.Add(asset.Key, asset.Value);
continue;
}
}
catch (Exception e)
{
logger.LogWarning("Impossible to identify asset {0} as an archive: {1}", asset.Key, e.Message);
continue;
}
logger.LogInformation("Extracting asset {0}...", asset.Value.Uri);
IAssetsContainer extractedAssets = await ExtractArchive(asset, destination);
int i = 0;
foreach (var extractedAsset in extractedAssets.Assets)
{
newAssets.Add(extractedAsset.Key, extractedAsset.Value);
i++;
}
if (options.Value.KeepArchive)
{
newAssets.Add(asset.Key, asset.Value);
}
}
if (newAssets == null || newAssets.Count == 0)
{
return(route);
}
return(new ContainerNode(route as IItem, newAssets, suffix));
}
public async Task <AssetImportReport> ImportAssets(IAssetsContainer assetsContainer, IDestination destination, AssetFilters assetsFilters)
{
if (assetsContainer.Assets.Count() == 0)
{
return(new AssetImportReport(null, destination));
}
logger.LogDebug("Importing {0} assets to {1}", assetsContainer.Assets.Count(), destination);
IDeliveryQuotation deliveryQuotation = QuoteAssetsDelivery(assetsContainer, destination, assetsFilters);
AssetImportReport report = new AssetImportReport(deliveryQuotation, destination);
logger.LogDebug("Delivery quotation for {0} assets ({1} exceptions)", deliveryQuotation.AssetsDeliveryQuotes.Count, deliveryQuotation.AssetsExceptions.Count);
CheckDelivery(deliveryQuotation);
foreach (var assetDeliveries in deliveryQuotation.AssetsDeliveryQuotes)
{
if (assetDeliveries.Value.Count() == 0)
{
report.AssetsExceptions.Add(assetDeliveries.Key, new AssetImportException("No delivery possible"));
continue;
}
IResource importedResource = null;
try
{
importedResource = await Import(assetDeliveries.Key, assetDeliveries.Value);
if (importedResource == null)
{
throw new AssetImportException("Imported asset is null");
}
}
catch (AggregateException ae)
{
report.AssetsExceptions.Add(assetDeliveries.Key, ae);
}
// OK
if (importedResource != null)
{
IAsset importedAsset = MakeAsset(importedResource, (IAsset)assetDeliveries.Value.First().Route);
report.ImportedAssets.Add(assetDeliveries.Key, importedAsset);
}
}
return(report);
}
public async Task <AssetDeleteReport> DeleteAssets(IAssetsContainer assetsContainer, AssetFilters assetsFilters)
{
AssetDeleteReport assetDeleteReport = new AssetDeleteReport();
logger.LogDebug("Deleting {0} assets of {1}", assetsContainer.Assets.Count(), assetsContainer.Uri.ToString());
foreach (var asset in assetsContainer.Assets)
{
try {
WebRoute assetRoute = WebRoute.Create(asset.Value.Uri, 0, credentials);
await assetRoute.Remove();
}
catch (Exception e)
{
logger.LogWarning("Cannot delete asset {0}({2}) : {1}", asset.Key, e.Message, asset.Value.Uri);
assetDeleteReport.AssetsExceptions.Add(asset.Key, e);
}
}
return(assetDeleteReport);
}
public bool CanProcess(IResource route, IDestination destination)
{
IAssetsContainer assetsContainer = route as IAssetsContainer;
return(assetsContainer != null && assetsContainer.Assets != null && assetsContainer.Assets.Any(asset => IsArchive(asset.Value)));
}
private IDeliveryQuotation QuoteAssetsDelivery(IAssetsContainer assetsContainer, IDestination destination, AssetFilters assetFilters)
{
FilteredAssetContainer filteredAssetContainer = new FilteredAssetContainer(assetsContainer, assetFilters);
return(carrierManager.GetAssetsDeliveryQuotations(filteredAssetContainer, destination));
}
