public async Task <MediaFileInfo> GetFileByIdAsync(int id, MediaLoadFlags flags = MediaLoadFlags.None)
{
if (id <= 0)
{
return(null);
}
MediaFile entity = null;
if (flags == MediaLoadFlags.None)
{
entity = await _db.MediaFiles.FindByIdAsync(id);
}
else
{
var query = _db.MediaFiles.Where(x => x.Id == id);
entity = await _searcher.ApplyLoadFlags(query, flags).FirstOrDefaultAsync();
}
if (entity != null)
{
await EnsureMetadataResolvedAsync(entity, true);
return(ConvertMediaFile(entity, _folderService.FindNode(entity)?.Value));
}
return(null);
}
public async Task <List <MediaFileInfo> > GetFilesByIdsAsync(int[] ids, MediaLoadFlags flags = MediaLoadFlags.AsNoTracking)
{
Guard.NotNull(ids, nameof(ids));
var query = _db.MediaFiles.Where(x => ids.Contains(x.Id));
var result = await _searcher.ApplyLoadFlags(query, flags).ToListAsync();
return(result.OrderBySequence(ids).Select(ConvertMediaFile).ToList());
}
public IList <MediaFileInfo> GetFilesByIds(int[] ids, MediaLoadFlags flags = MediaLoadFlags.AsNoTracking)
{
Guard.NotNull(ids, nameof(ids));
var query = _fileRepo.Table.Where(x => ids.Contains(x.Id));
var result = _searcher.ApplyLoadFlags(query, flags).ToList();
return(result.OrderBySequence(ids).Select(ConvertMediaFile).ToList());
}
public virtual Multimap <int, ProductMediaFile> GetProductPicturesByProductIds(
int[] productIds,
int?maxPicturesPerProduct = null,
MediaLoadFlags flags = MediaLoadFlags.None)
{
if (!(productIds?.Any() ?? false))
{
return(new Multimap <int, ProductMediaFile>());
}
var take = maxPicturesPerProduct ?? int.MaxValue;
var query = _productFileRepository.TableUntracked
.Where(pf => productIds.Contains(pf.ProductId))
.GroupBy(pf => pf.ProductId, x => x)
.SelectMany(pf => pf.OrderBy(x => x.DisplayOrder).Take(take));
// For eager loading apply Include() after GroupBy().
if (flags == MediaLoadFlags.None)
{
query = query.Include(pp => pp.MediaFile);
}
else
{
if (flags.HasFlag(MediaLoadFlags.WithBlob))
{
query = query.Include(pp => pp.MediaFile.MediaStorage);
}
if (flags.HasFlag(MediaLoadFlags.WithFolder))
{
query = query.Include(pp => pp.MediaFile.Folder);
}
if (flags.HasFlag(MediaLoadFlags.WithTags))
{
query = query.Include(pp => pp.MediaFile.Tags);
}
if (flags.HasFlag(MediaLoadFlags.WithTracks))
{
query = query.Include(pp => pp.MediaFile.Tracks);
}
}
var map = query
.ToList()
.ToMultimap(x => x.ProductId, x => x);
return(map);
}
public async Task <MediaSearchResult> SearchFilesAsync(
MediaSearchQuery query,
Func <IQueryable <MediaFile>, IQueryable <MediaFile> > queryModifier,
MediaLoadFlags flags = MediaLoadFlags.AsNoTracking)
{
Guard.NotNull(query, nameof(query));
var files = _searcher.SearchFiles(query, flags);
if (queryModifier != null)
{
files.ModifyQuery(queryModifier);
}
return(new MediaSearchResult(await files.LoadAsync(), ConvertMediaFile));
}
public MediaSearchResult SearchFiles(
MediaSearchQuery query,
Func <IQueryable <MediaFile>, IQueryable <MediaFile> > queryModifier,
MediaLoadFlags flags = MediaLoadFlags.AsNoTracking)
{
Guard.NotNull(query, nameof(query));
var files = _searcher.SearchFiles(query, flags);
if (queryModifier != null)
{
files.AlterQuery(queryModifier);
}
return(new MediaSearchResult(files.Load(), ConvertMediaFile));
}
public MediaFileInfo GetFileByName(int folderId, string fileName, MediaLoadFlags flags = MediaLoadFlags.None)
{
Guard.IsPositive(folderId, nameof(folderId));
Guard.NotEmpty(fileName, nameof(fileName));
var query = _fileRepo.Table.Where(x => x.Name == fileName && x.FolderId == folderId);
var entity = _searcher.ApplyLoadFlags(query, flags).FirstOrDefault();
if (entity != null)
{
EnsureMetadataResolved(entity, true);
var dir = _folderService.FindNode(entity)?.Value?.Path;
return(ConvertMediaFile(entity, _folderService.FindNode(entity)?.Value));
}
return(null);
}
public MediaFileInfo GetFileById(int id, MediaLoadFlags flags = MediaLoadFlags.None)
{
if (id <= 0)
{
return(null);
}
var query = _fileRepo.Table.Where(x => x.Id == id);
var entity = _searcher.ApplyLoadFlags(query, flags).FirstOrDefault();
if (entity != null)
{
EnsureMetadataResolved(entity, true);
return(ConvertMediaFile(entity, _folderService.FindNode(entity)?.Value));
}
return(null);
}
public MediaFileInfo GetFileByPath(string path, MediaLoadFlags flags = MediaLoadFlags.None)
{
Guard.NotEmpty(path, nameof(path));
if (_helper.TokenizePath(path, false, out var tokens))
{
var table = _searcher.ApplyLoadFlags(_fileRepo.Table, flags);
var entity = table.FirstOrDefault(x => x.FolderId == tokens.Folder.Id && x.Name == tokens.FileName);
if (entity != null)
{
EnsureMetadataResolved(entity, true);
return(ConvertMediaFile(entity, tokens.Folder));
}
}
return(null);
}
public async Task <MediaFileInfo> GetFileByPathAsync(string path, MediaLoadFlags flags = MediaLoadFlags.None)
{
Guard.NotEmpty(path, nameof(path));
if (_helper.TokenizePath(path, false, out var tokens))
{
var table = _searcher.ApplyLoadFlags(_db.MediaFiles, flags);
var entity = await table.FirstOrDefaultAsync(x => x.FolderId == tokens.Folder.Id && x.Name == tokens.FileName);
if (entity != null)
{
await EnsureMetadataResolvedAsync(entity, true);
return(ConvertMediaFile(entity, tokens.Folder));
}
}
return(null);
}
public async Task <MediaFileInfo> GetFileByNameAsync(int folderId, string fileName, MediaLoadFlags flags = MediaLoadFlags.None)
{
Guard.IsPositive(folderId, nameof(folderId));
Guard.NotEmpty(fileName, nameof(fileName));
var query = _db.MediaFiles.Where(x => x.Name == fileName && x.FolderId == folderId);
var entity = await _searcher.ApplyLoadFlags(query, flags).FirstOrDefaultAsync();
if (entity != null)
{
await EnsureMetadataResolvedAsync(entity, true);
var node = _folderService.FindNode(entity);
var dir = node?.Value?.Path;
return(ConvertMediaFile(entity, node?.Value));
}
return(null);
}
public virtual IQueryable <MediaFile> PrepareQuery(MediaSearchQuery query, MediaLoadFlags flags)
{
Guard.NotNull(query, nameof(query));
var q = _fileRepo.Table;
bool?shouldIncludeDeleted = false;
// Folder
if (query.FolderId > 0)
{
if (query.DeepSearch)
{
var folderIds = _folderService.Value.GetNodesFlattened(query.FolderId.Value, true).Select(x => x.Id).ToArray();
q = q.Where(x => x.FolderId != null && folderIds.Contains(x.FolderId.Value));
}
else
{
q = q.Where(x => x.FolderId == query.FolderId);
}
}
else if (query.FolderId < 0)
{
// Special folders
if (query.FolderId == (int)SpecialMediaFolder.AllFiles)
{
shouldIncludeDeleted = null;
}
else if (query.FolderId == (int)SpecialMediaFolder.Trash)
{
shouldIncludeDeleted = true;
}
else if (query.FolderId == (int)SpecialMediaFolder.Orphans)
{
// Get ids of untrackable folders, 'cause no orphan check can be made for them.
var untrackableFolderIds = _folderService.Value.GetRootNode()
.SelectNodes(x => !x.Value.CanDetectTracks)
.Select(x => x.Value.Id)
.ToArray();
q = q.Where(x => x.FolderId > 0 && !untrackableFolderIds.Contains(x.FolderId.Value) && !x.Tracks.Any());
}
else if (query.FolderId == (int)SpecialMediaFolder.TransientFiles)
{
q = q.Where(x => x.IsTransient);
}
else if (query.FolderId == (int)SpecialMediaFolder.UnassignedFiles)
{
q = q.Where(x => x.FolderId == null);
}
}
else
{
// (perf) Composite index
q = q.Where(x => x.FolderId == null || x.FolderId.HasValue);
}
q = ApplyFilterQuery(query, q);
if (query.Deleted == null && shouldIncludeDeleted.HasValue)
{
q = q.Where(x => x.Deleted == shouldIncludeDeleted.Value);
}
// Sorting
var ordering = query.SortBy.NullEmpty() ?? "Id";
if (query.SortDesc)
{
ordering += " descending";
}
q = q.OrderBy(ordering);
return(ApplyLoadFlags(q, flags));
}
public virtual IPagedList <MediaFile> SearchFiles(MediaSearchQuery query, MediaLoadFlags flags = MediaLoadFlags.AsNoTracking)
{
var q = PrepareQuery(query, flags);
return(new PagedList <MediaFile>(q, query.PageIndex, query.PageSize));
}
public virtual IQueryable <MediaFile> ApplyLoadFlags(IQueryable <MediaFile> query, MediaLoadFlags flags)
{
if (flags == MediaLoadFlags.None)
{
return(query);
}
if (flags.HasFlag(MediaLoadFlags.AsNoTracking))
{
query = query.AsNoTracking();
}
if (flags.HasFlag(MediaLoadFlags.WithBlob))
{
query = query.Include(x => x.MediaStorage);
}
if (flags.HasFlag(MediaLoadFlags.WithFolder))
{
query = query.Include(x => x.Folder);
}
if (flags.HasFlag(MediaLoadFlags.WithTags))
{
query = query.Include(x => x.Tags);
}
if (flags.HasFlag(MediaLoadFlags.WithTracks))
{
query = query.Include(x => x.Tracks);
}
return(query);
}
public static async Task <MediaSearchResult> SearchFilesAsync(this IMediaService service, MediaSearchQuery query, MediaLoadFlags flags = MediaLoadFlags.AsNoTracking)
{
return(await service.SearchFilesAsync(query, null, flags));
}
public static MediaSearchResult SearchFiles(this IMediaService service, MediaSearchQuery query, MediaLoadFlags flags = MediaLoadFlags.AsNoTracking)
{
return(service.SearchFiles(query, null, flags));
}
