public async Task FilterAssetsReturnsTheExpectedNumberOfAssetsAsync()
{
// Arrange
var numOfAssets = 10;
var id = 6687602007296940;
var query = new AssetQuery()
{
Limit = numOfAssets,
Filter = new AssetFilter()
{
RootIds = new List <Identity>()
{
Identity.Create(id)
}
}
};
// Act
var res = await ReadClient.Assets.ListAsync(query);
// Assert
var resCount = res.Items.Count();
Assert.True(numOfAssets == resCount, $"Expected {query.Limit} assets but got {resCount}");
}
public void ThenTheResultIsAsExpected()
{
var query = new AssetQuery {
Owner = "user1", TeamAsset = true
};
var pageInfo = new PageInfo(
2,
2,
new OrderBy(AssetRepository.CREATED_BY_COLUMN, Order.DESCENDING));
var actual = _sut.PagedQuery(pageInfo, query);
// Simulate the paging on the in-memory collection.
var expected = _assets
.Where(x => x.Owner == "user1" && x.TeamAsset)
.OrderByDescending(x => x.CreatedBy)
.Skip(2)
.Take(2)
.ToList();
Assert.AreEqual(pageInfo, actual.PageInfo);
Assert.AreEqual(4, actual.TotalCount);
Assert.AreEqual(2, actual.Result.Count());
foreach (var expectedDto in expected)
{
var actualDto = actual.Result.Single(x => x.Id == expectedDto.Id);
Assert.AreEqual(expectedDto, actualDto);
}
}
public async Task <QueryResult <Asset> > GetAssetsAsync(AssetQuery assetQuery)
{
IQueryable <MongoAsset> query = Assets.AsQueryable();
if (assetQuery.Folder != null)
{
query = query.Where(x => x.Folder == assetQuery.Folder.Value);
}
if (string.IsNullOrEmpty(assetQuery.Pattern) == false)
{
query = query.Where(x => x.Name !.Contains(assetQuery.Pattern));
}
QueryResult <Asset> queryResult = new QueryResult <Asset>();
queryResult.Items = query
.OrderByDescending(x => x.CreatedAt)
.Take(assetQuery.Take)
.ToList()
.Select(x => x.FromMongo())
.ToList();
queryResult.Offset = assetQuery.Take;
queryResult.Count = queryResult.Items.Count;
queryResult.TotalCount = 0;
return(queryResult);
}
// Post: ManageAssets
public ActionResult Index(AssetQuery query)
{
var assets = service.searchAssets(query);
ViewBag.AssetModelId = new SelectList(db.AssetModels, "Id", "Name");
ViewBag.AssetTypeId = new SelectList(db.AssetTypes, "Id", "Type");
return(View(assets));
}
/// <summary>
/// Retrieves list of assets matching query.
/// </summary>
/// <param name="query">The query filter to use.</param>
/// <param name="token">Optional cancellation token to use.</param>
/// <returns>List of assets matching given filters and optional cursor</returns>
public async Task <ItemsWithCursor <Asset> > ListAsync(AssetQuery query, CancellationToken token = default)
{
if (query is null)
{
throw new ArgumentNullException(nameof(query));
}
var req = Assets.list <ItemsWithCursor <Asset> >(query);
return(await RunAsync(req, token).ConfigureAwait(false));
}
/// <summary>
/// Retrieves number of assets matching query.
/// </summary>
/// <param name="query">The query filter to use.</param>
/// <param name="token">Optional cancellation token to use.</param>
/// <returns>Number of assets matching given filters and optional cursor</returns>
public async Task <Int32> CountAsync(AssetQuery query, CancellationToken token = default)
{
if (query is null)
{
throw new ArgumentNullException(nameof(query));
}
var req = Assets.count <Int32>(query);
return(await RunAsync(req, token).ConfigureAwait(false));
}
static async Task <Asset> GetAssetsExample(Client client, string assetName)
{
var query = new AssetQuery
{
Filter = new AssetFilter {
Name = assetName
}
};
var result = await client.Assets.ListAsync(query).ConfigureAwait(false);
var asset = result.Items.FirstOrDefault();
return(asset);
}
public async Task ListingAssetsRespectsLimitAsync()
{
// Arrange
const int limit = 10;
var option = new AssetQuery
{
Limit = limit
};
// Act
var res = await ReadClient.Assets.ListAsync(option);
// Assert
Assert.True(limit == res.Items.Count(), "Expected the number of assets to be the same as the Limit value");
}
public async Task CountAssetsWithNoMatchesReturnZeroAsync()
{
// Arrange
var option = new AssetQuery {
Filter = new AssetFilter()
{
Metadata = new Dictionary <string, string> {
{ "ThisMetaDataFilterhasNoMatches", "ThereIsNoSpoon" }
}
}
};
// Act
var count = await ReadClient.Assets.AggregateAsync(option);
// Assert
Assert.True(count == 0);
}
public async Task CountAssetsReturnIntAsync()
{
// Arrange
var option = new AssetQuery {
Filter = new AssetFilter()
{
Metadata = new Dictionary <string, string> {
{ "WMT_SAFETYCRITICALELEMENT_ID", "1060" }
}
}
};
// Act
var count = await ReadClient.Assets.AggregateAsync(option);
// Assert
Assert.True(count > 0);
}
private void FilterAssets()
{
if (!NeedRequery())
{
return;
}
if (ShouldUpdateAssetLibraryDatabase())
{
EnumerateUnityPackageFiles();
}
if (results.DataSource == FilteredAssets_B)
{
FilteredAssets = FilteredAssets_A;
}
else
{
FilteredAssets = FilteredAssets_B;
}
FilteredAssets.Clear();
var query = new AssetQuery(textQuery.Text);
foreach (AssetMetaData a in AllAssets)
{
if (a.Match(query))
{
FilteredAssets.Add(a);
}
}
results.DataSource = FilteredAssets;
if (isFirstTime)
{
isFirstTime = false;
results.Columns[0].MinimumWidth = 300;
results.Columns[1].MinimumWidth = 250;
results.Columns[2].MinimumWidth = 250;
}
File.WriteAllText(Settings.LocalHtmlPath, GenerateHTML());
// browser.Url = Settings.LocalHtmlUri;
}
public virtual async Task <IResultList <IEnrichedAssetEntity> > QueryAssetsAsync(Q q,
CancellationToken ct)
{
IResultList <IEnrichedAssetEntity> assets;
await maxRequests.WaitAsync(ct);
try
{
assets = await AssetQuery.QueryAsync(Context, null, q, ct);
}
finally
{
maxRequests.Release();
}
AssetCache.SetMany(assets.Select(x => (x.Id, x)) !);
return(assets);
}
public async Task InvokeAsync(
HttpContext context,
IAssetStorage assetStore,
JsonService jsonService)
{
AssetQuery query = await jsonService.Deserialize <AssetQuery>(context.Request.Body);
QueryResult <Asset> assets = await assetStore.GetAssetsAsync(query);
QueryResult <RestAsset> queryResult = new QueryResult <RestAsset>();
queryResult.Offset = assets.Offset;
queryResult.Count = assets.Count;
queryResult.TotalCount = assets.TotalCount;
queryResult.Items = assets.Items.Select(x => x.ToRest()).ToList();
string json = jsonService.Serialize(queryResult);
await context.Response.WriteAsync(json);
}
public virtual async Task <IReadOnlyList <IEnrichedAssetEntity> > GetReferencedAssetsAsync(IEnumerable <DomainId> ids,
CancellationToken ct)
{
Guard.NotNull(ids);
return(await AssetCache.CacheOrQueryAsync(ids, async pendingIds =>
{
await maxRequests.WaitAsync(ct);
try
{
var q = Q.Empty.WithIds(pendingIds).WithoutTotal();
return await AssetQuery.QueryAsync(Context, null, q, ct);
}
finally
{
maxRequests.Release();
}
}));
}
private void FilterAssets()
{
if (!NeedRequery())
{
return;
}
if (ShouldUpdateAssetLibraryDatabase())
{
EnumerateUnityPackageFiles();
}
if (Results == FilteredAssets_B)
{
FilteredAssets = FilteredAssets_A;
}
else
{
FilteredAssets = FilteredAssets_B;
}
FilteredAssets.Clear();
var query = new AssetQuery(Query);
foreach (var a in AllAssets)
{
if (a.Match(query))
{
FilteredAssets.Add(a);
}
}
Results = FilteredAssets;
//File.WriteAllText(Settings.LocalHtmlPath, GenerateHTML());
//// browser.Url = Settings.LocalHtmlUri;
}
public static async Task <AssetsDto> GetAllAssetsAsync(this IAssetsClient assetClient, string app, int batchSize = 200)
{
var query = new AssetQuery {
Top = batchSize, Skip = 0
};
var assetItems = new List <AssetDto>();
long total;
do
{
var getResult = await assetClient.GetAssetsAsync(app, query);
total = getResult.Total;
assetItems.AddRange(getResult.Items);
query.Skip = assetItems.Count;
}while (query.Skip < assetItems.Count);
return(new AssetsDto {
Total = total, Items = assetItems
});
}
private IActionResult DeliverAsset(IAssetEntity?asset, AssetQuery query)
{
query ??= new AssetQuery();
if (asset == null || asset.FileVersion < query.Version)
{
return(NotFound());
}
if (asset.IsProtected && !this.HasPermission(Permissions.AppAssetsRead))
{
return(StatusCode(403));
}
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 =>
{
if (asset.Type == AssetType.Image && query.ShouldResize())
{
var resizedAsset = $"{asset.Id}_{asset.FileVersion}_{query.Width}_{query.Height}_{query.Mode}";
if (query.Quality.HasValue)
{
resizedAsset += $"_{query.Quality}";
}
try
{
await assetStore.DownloadAsync(resizedAsset, bodyStream);
}
catch (AssetNotFoundException)
{
using (Profiler.Trace("Resize"))
{
using (var sourceStream = GetTempStream())
{
using (var destinationStream = GetTempStream())
{
using (Profiler.Trace("ResizeDownload"))
{
await assetFileStore.DownloadAsync(asset.Id, fileVersion, 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(resizedAsset, destinationStream);
destinationStream.Position = 0;
}
await destinationStream.CopyToAsync(bodyStream);
}
}
}
}
}
else
{
await assetFileStore.DownloadAsync(asset.Id, fileVersion, bodyStream);
}
});
if (query.Download == 1)
{
return(new FileCallbackResult(asset.MimeType, asset.FileName, true, handler));
}
else
{
return(new FileCallbackResult(asset.MimeType, null, true, handler));
}
}
public async Task <IActionResult> GetAssetContentBySlug(string app, string idOrSlug, string more, [FromQuery] AssetQuery query)
{
IAssetEntity?asset;
if (Guid.TryParse(idOrSlug, out var guid))
{
asset = await assetRepository.FindAssetAsync(guid);
}
else
{
asset = await assetRepository.FindAssetBySlugAsync(App.Id, idOrSlug);
}
return(DeliverAsset(asset, query));
}
public async Task <IActionResult> GetAssetContent(Guid id, [FromQuery] AssetQuery query)
{
var asset = await assetRepository.FindAssetAsync(id);
return(DeliverAsset(asset, query));
}
/// <summary>
/// Asynchronously retrieve a list of assets matching query.
/// </summary>
/// <param name="query">The query filter to use.</param>
/// <param name="token">Optional cancellation token to use.</param>
/// <returns>List of assets matching given filters and optional cursor</returns>
public async Task <ItemsWithCursor <Asset> > ListAsync(AssetQuery query, CancellationToken token = default)
{
return((ItemsWithCursor <Asset>) await ListAsync <Asset>(query, token).ConfigureAwait(false));
}
public async Task <QueryResult <Asset> > GetAssetsAsync(AssetQuery assetQuery)
{
var response = await Client.PostAsJson($"api/asset/query", assetQuery);
return(await response.Content.ParseJsonAsync <QueryResult <Asset> >());
}
public async Task Import(ImportArguments arguments)
{
var session = configuration.StartSession(arguments.App);
var assets = session.Assets;
using (var fs = await FileSystems.CreateAsync(arguments.Path, session.WorkingDirectory))
{
var folders = new FolderTree(session);
var assetQuery = new AssetQuery();
foreach (var file in fs.GetFiles(FilePath.Root, ".*"))
{
var targetFolder = file.LocalFolderPath();
if (!string.IsNullOrWhiteSpace(arguments.TargetFolder))
{
targetFolder = Path.Combine(arguments.TargetFolder, targetFolder);
}
assetQuery.ParentId = await folders.GetIdAsync(targetFolder);
assetQuery.Filter = $"fileName eq '{file.Name}'";
var existings = await assets.GetAssetsAsync(session.App, assetQuery);
var existing = existings.Items.FirstOrDefault();
var fileHash = file.GetFileHash();
try
{
var fileParameter = new FileParameter(file.OpenRead(), file.Name, MimeTypesMap.GetMimeType(file.Name));
log.WriteLine($"Uploading: {file.FullName}");
if (existings.Items.Any(x => string.Equals(x.FileHash, fileHash, StringComparison.Ordinal)))
{
log.StepSkipped("Same hash.");
}
else if (existings.Items.Count > 1)
{
log.StepSkipped("Multiple candidates found.");
}
else if (existing != null)
{
await assets.PutAssetContentAsync(session.App, existing.Id, fileParameter);
log.StepSuccess("Existing Asset");
}
else
{
var result = await assets.PostAssetAsync(session.App, assetQuery.ParentId, null, arguments.Duplicate, fileParameter);
if (result._meta?.IsDuplicate == "true")
{
log.StepSkipped("duplicate.");
}
else
{
log.StepSuccess("New Asset");
}
}
}
catch (Exception ex)
{
LogExtensions.HandleException(ex, error => log.WriteLine("Error: {0}", error));
}
finally
{
log.WriteLine();
}
}
log.WriteLine("> Import completed");
}
}
private IActionResult DeliverAsset(IAssetEntity?asset, AssetQuery query)
{
query ??= new AssetQuery();
if (asset == null || asset.FileVersion < query.Version)
{
return(NotFound());
}
if (asset.IsProtected && !this.HasPermission(Permissions.AppAssetsRead))
{
return(StatusCode(403));
}
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 resizeOptions = query.ToResizeOptions(asset);
if (asset.Type == AssetType.Image && resizeOptions.IsValid)
{
var resizedAsset = $"{asset.Id}_{asset.FileVersion}_{resizeOptions}";
if (query.ForceResize)
{
await ResizeAsync(asset, bodyStream, resizedAsset, fileVersion, resizeOptions, true);
}
else
{
try
{
await assetStore.DownloadAsync(resizedAsset, bodyStream);
}
catch (AssetNotFoundException)
{
await ResizeAsync(asset, bodyStream, resizedAsset, fileVersion, resizeOptions, false);
}
}
}
else
{
await assetFileStore.DownloadAsync(asset.Id, fileVersion, bodyStream);
}
});
if (query.Download == 1 || asset.Type != AssetType.Image)
{
return(new FileCallbackResult(asset.MimeType, asset.FileName, true, handler));
}
else
{
return(new FileCallbackResult(asset.MimeType, null, true, handler));
}
}
