public static RuleEventsDto FromRuleEvents(IResultList <IRuleEventEntity> ruleEvents, ApiController controller, string app)
{
var result = new RuleEventsDto
{
Total = ruleEvents.Total,
Items = ruleEvents.Select(x => RuleEventDto.FromRuleEvent(x, controller, app)).ToArray()
};
return(result.CreateLinks(controller, app));
}
public static AssetsDto FromDomain(IResultList <IEnrichedAssetEntity> assets, Resources resources)
{
var result = new AssetsDto
{
Total = assets.Total,
Items = assets.Select(x => AssetDto.FromDomain(x, resources)).ToArray()
};
return(result.CreateLinks(resources));
}
public static RuleEventsDto FromRuleEvents(IResultList <IRuleEventEntity> ruleEvents, Resources resources)
{
var result = new RuleEventsDto
{
Total = ruleEvents.Total,
Items = ruleEvents.Select(x => RuleEventDto.FromRuleEvent(x, resources)).ToArray()
};
return(result.CreateLinks(resources));
}
public static AssetsDto FromAssets(IResultList <IEnrichedAssetEntity> assets, ApiController controller, string app)
{
var response = new AssetsDto
{
Total = assets.Total,
Items = assets.Select(x => AssetDto.FromAsset(x, controller, app)).ToArray()
};
return(CreateLinks(response, controller, app));
}
public static AssetFoldersDto FromAssets(IResultList <IAssetFolderEntity> assetFolders, Resources resources)
{
var response = new AssetFoldersDto
{
Total = assetFolders.Total,
Items = assetFolders.Select(x => AssetFolderDto.FromAssetFolder(x, resources)).ToArray()
};
return(CreateLinks(response, resources));
}
public static AssetFoldersDto FromDomain(IResultList <IAssetFolderEntity> assetFolders, IEnumerable <IAssetFolderEntity> path, Resources resources)
{
var result = new AssetFoldersDto
{
Total = assetFolders.Total,
Items = assetFolders.Select(x => AssetFolderDto.FromDomain(x, resources)).ToArray()
};
result.Path = path.Select(x => AssetFolderDto.FromDomain(x, resources)).ToArray();
return(result.CreateLinks(resources));
}
public static async Task <ContentsDto> FromContentsAsync(IResultList <IEnrichedContentEntity> contents, Context context, ApiController controller, ISchemaEntity schema, IContentWorkflow workflow)
{
var result = new ContentsDto
{
Total = contents.Total,
Items = contents.Select(x => ContentDto.FromContent(context, x, controller)).ToArray()
};
await result.AssignStatusesAsync(workflow, schema);
return(result.CreateLinks(controller, schema.AppId.Name, schema.SchemaDef.Name));
}
internal SpotifyPlaylist(MetadataFactory factory, PartialPlaylistResult result, WebApi webApi)
{
this.factory = factory;
this.uri = result.uri;
this.name = result.name;
var trackHref = result.tracks.href;
var wrap = new PagingWrapper <ISong, PlaylistTrackResult>(trackHref, webApi, false);
this.page1 = wrap;
}
public bool MoveNext()
{
++pos;
while (pos >= allElements.Count)
{
if (currentList.HasNextPage)
{
currentList = currentList.NextPage;
allElements.AddRange(currentList.Items);
}
else
{
return(false);
}
}
return(true);
}
internal SpotifyPlaylist(MetadataFactory factory, PlaylistResult result, WebApi webApi)
{
this.factory = factory;
this.uri = result.uri;
this.name = result.name;
PagingObjectResult <PlaylistTrackResult> tracks = result.tracks;
var wrap = new PagingWrapper <ISong, PlaylistTrackResult>(tracks, webApi, false);
this.page1 = wrap;
// Submit items for caching
foreach (var playlistTrack in tracks.items)
{
this.factory.CacheSubmit(playlistTrack);
}
}
public static async Task <ContentsDto> FromContentsAsync(IResultList <IEnrichedContentEntity> contents, Resources resources,
ISchemaEntity?schema, IContentWorkflow workflow)
{
var result = new ContentsDto
{
Total = contents.Total,
Items = contents.Select(x => ContentDto.FromContent(x, resources)).ToArray()
};
if (schema != null)
{
await result.AssignStatusesAsync(workflow, schema);
result.CreateLinks(resources, schema.SchemaDef.Name);
}
return(result);
}
/// <summary>
/// The function to handle when search command (generally via keyboard search button) is sent to the search bar
/// Takes in the text value from the search bar, searches with the music service, and updates the SongViewModel
/// </summary>
public void SearchForSong(string text)
{
resultsLabel.Text = "";
List <ISong> noSongs = new List <ISong>();
IResultList <ISong> results = controller.musicService.SearchSong(text);
if (results == null || results.Items == null || results.Items.Count == 0)
{
resultsLabel.Text = "No Results.";
model.SetAll(noSongs);
}
else
{
model.SetAll(results.Items);
}
}
private (ISchemaEntity Schema, IResultList <IContentEntity> Contents) TransformContents(ClaimsPrincipal user, ISchemaEntity schema, IResultList <IContentEntity> contents)
{
var transformed = TransformContent(user, schema, contents);
return(schema, ResultList.Create(transformed, contents.Total));
}
private static IResultList <IAssetEntity> Sort(IResultList <IAssetEntity> assets, IReadOnlyList <Guid> ids)
{
return(assets.SortSet(x => x.Id, ids));
}
private IResultList<IContentEntity> TransformContents(QueryContext context, ISchemaEntity schema, bool checkType, IResultList<IContentEntity> contents)
{
var transformed = TransformContents(context, schema, checkType, (IEnumerable<IContentEntity>)contents);
return ResultList.Create(transformed, contents.Total);
}
private static IResultList <IContentEntity> SortSet(IResultList <IContentEntity> contents, IReadOnlyList <Guid> ids)
{
return(ResultList.Create(contents.Total, SortList(contents, ids)));
}
private IResultList <IContentEntity> Transform(QueryContext context, ISchemaEntity schema, IResultList <IContentEntity> contents)
{
var transformed = TransformCore(context, schema, contents);
return(ResultList.Create(contents.Total, transformed));
}
private IResultList <IContentEntity> Sort(IResultList <IContentEntity> contents, IList <Guid> ids)
{
var sorted = ids.Select(id => contents.FirstOrDefault(x => x.Id == id)).Where(x => x != null);
return(ResultList.Create(contents.Total, sorted));
}
private static IResultList <IAssetEntity> Sort(IResultList <IAssetEntity> assets, IReadOnlyList <Guid> ids)
{
var sorted = ids.Select(id => assets.FirstOrDefault(x => x.Id == id)).Where(x => x != null);
return(ResultList.Create(assets.Total, sorted));
}
private async Task <IResultList <IEnrichedAssetEntity> > TransformAsync(Context context, IResultList <IAssetEntity> assets,
CancellationToken ct)
{
var transformed = await TransformCoreAsync(context, assets, ct);
return(ResultList.Create(assets.Total, transformed));
}
public ResultListWrapper(IResultList <T> resultList)
{
this.resultList = resultList;
}
public ResultListEnumerator(IResultList <T> resultList)
{
this.currentList = resultList;
this.allElements = new List <T>();
this.allElements.AddRange(resultList.Items);
}
public static IResultList <T> SortSet <T, TKey>(this IResultList <T> input, Func <T, TKey> idProvider, IReadOnlyList <TKey> ids) where T : class
{
return(ResultList.Create(input.Total, SortList(input, idProvider, ids)));
}
private async Task <IResultList <IEnrichedContentEntity> > TransformAsync(Context context, IResultList <IContentEntity> contents)
{
var transformed = await TransformCoreAsync(context, contents);
return(ResultList.Create(contents.Total, transformed));
}
public static AssetsDto FromAssets(IResultList <IAssetEntity> assets)
{
return(new AssetsDto {
Total = assets.Total, Items = assets.Select(AssetDto.FromAsset).ToArray()
});
}
