public IEnumerable <string> Format(IAssetEntity asset)
{
yield break;
}
private static bool IsDuplicate(IAssetEntity asset, AssetFile file)
{
return(asset?.FileName == file.FileName && asset.FileSize == file.FileSize);
}
public string GenerateAssetUrl(IAppEntity appEntity, IAssetEntity assetEntity)
{
return(urlsOptions.BuildUrl($"api/assets/{assetEntity.Id}?version={assetEntity.Version}"));
}
public string GenerateAssetSourceUrl(IAppEntity appEntity, IAssetEntity assetEntity)
{
return(assetStore.GenerateSourceUrl(assetEntity.Id.ToString(), assetEntity.FileVersion, null));
}
public string GenerateAssetThumbnailUrl(IAppEntity app, IAssetEntity asset)
{
return($"assets/{asset.Id}?width=100");
}
public string GenerateAssetSourceUrl(IAppEntity app, IAssetEntity asset)
{
return($"assets/source/{asset.Id}");
}
private IActionResult DeliverAsset(IAssetEntity entity, long version, int?width, int?height, int?quality, string mode, int download = 1)
{
if (entity == null || entity.FileVersion < version || width == 0 || height == 0 || quality == 0)
{
return(NotFound());
}
Response.Headers[HeaderNames.ETag] = entity.FileVersion.ToString();
var handler = new Func <Stream, Task>(async bodyStream =>
{
var assetId = entity.Id.ToString();
if (entity.IsImage && (width.HasValue || height.HasValue || quality.HasValue))
{
var assetSuffix = $"{width}_{height}_{mode}";
if (quality.HasValue)
{
assetSuffix += $"_{quality}";
}
try
{
await assetStore.DownloadAsync(assetId, entity.FileVersion, assetSuffix, bodyStream);
}
catch (AssetNotFoundException)
{
using (Profiler.Trace("Resize"))
{
using (var sourceStream = GetTempStream())
{
using (var destinationStream = GetTempStream())
{
using (Profiler.Trace("ResizeDownload"))
{
await assetStore.DownloadAsync(assetId, entity.FileVersion, null, sourceStream);
sourceStream.Position = 0;
}
using (Profiler.Trace("ResizeImage"))
{
await assetThumbnailGenerator.CreateThumbnailAsync(sourceStream, destinationStream, width, height, mode, quality);
destinationStream.Position = 0;
}
using (Profiler.Trace("ResizeUpload"))
{
await assetStore.UploadAsync(assetId, entity.FileVersion, assetSuffix, destinationStream);
destinationStream.Position = 0;
}
await destinationStream.CopyToAsync(bodyStream);
}
}
}
}
}
else
{
await assetStore.DownloadAsync(assetId, entity.FileVersion, null, bodyStream);
}
});
if (download == 1)
{
return(new FileCallbackResult(entity.MimeType, entity.FileName, true, handler));
}
else
{
return(new FileCallbackResult(entity.MimeType, null, true, handler));
}
}
private static bool IsDuplicate(CreateAsset createAsset, IAssetEntity asset)
{
return(asset != null && asset.FileName == createAsset.File.FileName && asset.FileSize == createAsset.File.FileSize);
}
public static AssetDto FromAsset(IAssetEntity asset)
{
return(SimpleMapper.Map(asset, new AssetDto {
FileType = asset.FileName.FileType()
}));
}
public string?GenerateAssetSourceUrl(IAssetEntity asset)
{
return(assetFileStore.GeneratePublicUrl(asset.Id, asset.FileVersion));
}
public string?GenerateAssetSourceUrl(IAppEntity app, IAssetEntity asset)
{
return(assetStore.GeneratePublicUrl(asset.Id.ToString(), asset.FileVersion, null));
}
private async Task ResizeAsync(IAssetEntity asset, string suffix, Stream target, ResizeOptions resizeOptions, bool overwrite,
CancellationToken ct)
{
#pragma warning disable MA0040 // Flow the cancellation token
using var activity = Telemetry.Activities.StartActivity("Resize");
await using var assetOriginal = new TempAssetFile(asset.FileName, asset.MimeType, 0);
await using var assetResized = new TempAssetFile(asset.FileName, asset.MimeType, 0);
using (Telemetry.Activities.StartActivity("Read"))
{
await using (var originalStream = assetOriginal.OpenWrite())
{
await assetFileStore.DownloadAsync(asset.AppId.Id, asset.Id, asset.FileVersion, null, originalStream);
}
}
using (Telemetry.Activities.StartActivity("Resize"))
{
try
{
await using (var originalStream = assetOriginal.OpenRead())
{
await using (var resizeStream = assetResized.OpenWrite())
{
await assetThumbnailGenerator.CreateThumbnailAsync(originalStream, asset.MimeType, resizeStream, resizeOptions);
}
}
}
catch
{
await using (var originalStream = assetOriginal.OpenRead())
{
await using (var resizeStream = assetResized.OpenWrite())
{
await originalStream.CopyToAsync(resizeStream);
}
}
}
}
using (Telemetry.Activities.StartActivity("Save"))
{
try
{
await using (var resizeStream = assetResized.OpenRead())
{
await assetFileStore.UploadAsync(asset.AppId.Id, asset.Id, asset.FileVersion, suffix, resizeStream, overwrite);
}
}
catch (AssetAlreadyExistsException)
{
return;
}
}
using (Telemetry.Activities.StartActivity("Write"))
{
await using (var resizeStream = assetResized.OpenRead())
{
await resizeStream.CopyToAsync(target, ct);
}
}
#pragma warning restore MA0040 // Flow the cancellation token
}
private async Task DownloadAsync(IAssetEntity asset, Stream bodyStream, string?suffix, BytesRange range,
CancellationToken ct)
{
await assetFileStore.DownloadAsync(asset.AppId.Id, asset.Id, asset.FileVersion, suffix, bodyStream, range, ct);
}
private async Task <IEnrichedAssetEntity> TransformAsync(Context context, IAssetEntity asset)
{
var transformed = await TransformCoreAsync(context, Enumerable.Repeat(asset, 1));
return(transformed[0]);
}
private IActionResult DeliverAsset(IAssetEntity asset, AssetQuery query)
{
query = query ?? new AssetQuery();
if (asset == null || asset.FileVersion < query.Version)
{
return(NotFound());
}
var fileVersion = query.Version;
if (fileVersion <= EtagVersion.Any)
{
fileVersion = asset.FileVersion;
}
Response.Headers[HeaderNames.ETag] = fileVersion.ToString();
if (query.CacheDuration > 0)
{
Response.Headers[HeaderNames.CacheControl] = $"public,max-age={query.CacheDuration}";
}
var handler = new Func <Stream, Task>(async bodyStream =>
{
var assetId = asset.Id.ToString();
if (asset.IsImage && query.ShouldResize())
{
var assetSuffix = $"{query.Width}_{query.Height}_{query.Mode}";
if (query.Quality.HasValue)
{
assetSuffix += $"_{query.Quality}";
}
try
{
await assetStore.DownloadAsync(assetId, fileVersion, assetSuffix, bodyStream);
}
catch (AssetNotFoundException)
{
using (Profiler.Trace("Resize"))
{
using (var sourceStream = GetTempStream())
{
using (var destinationStream = GetTempStream())
{
using (Profiler.Trace("ResizeDownload"))
{
await assetStore.DownloadAsync(assetId, fileVersion, null, sourceStream);
sourceStream.Position = 0;
}
using (Profiler.Trace("ResizeImage"))
{
await assetThumbnailGenerator.CreateThumbnailAsync(sourceStream, destinationStream, query.Width, query.Height, query.Mode, query.Quality);
destinationStream.Position = 0;
}
using (Profiler.Trace("ResizeUpload"))
{
await assetStore.UploadAsync(assetId, fileVersion, assetSuffix, destinationStream);
destinationStream.Position = 0;
}
await destinationStream.CopyToAsync(bodyStream);
}
}
}
}
}
else
{
await assetStore.DownloadAsync(assetId, fileVersion, null, bodyStream);
}
});
if (query.Download == 1)
{
return(new FileCallbackResult(asset.MimeType, asset.FileName, true, handler));
}
else
{
return(new FileCallbackResult(asset.MimeType, null, true, handler));
}
}
private static void AssertAsset(IAssetEntity source, IEnrichedAssetEntity?result)
{
Assert.NotNull(result);
Assert.NotSame(source, result);
Assert.Equal(source.AssetId, result?.AssetId);
}
public string GenerateAssetUrl(IAppEntity appEntity, IAssetEntity assetEntity)
{
return($"assets/{assetEntity.Id}");
}
