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)); } }