/// <summary>
/// Executes this command.
/// </summary>
/// <param name="request">A filter to search for specific media items/folders.</param>
/// <returns>A list of tags.</returns>
public MediaManagerItemsViewModel Execute(MediaManagerViewModel request)
{
request.SetDefaultSortingOptions("Title");
var items = GetAllItemsList(request);
var model = new MediaManagerItemsViewModel(items.Item1, request, items.Item2);
model.Path = LoadMediaFolder(request);
return(model);
}
private Tuple <IEnumerable <MediaViewModel>, int> ToResponse(MediaManagerViewModel request, IQueryable <Media> query, bool forceToFuture = false)
{
var count = query.ToRowCountFutureValue();
query = AddOrder(query, request).AddPaging(request);
var items = forceToFuture
? NHibernate.Linq.LinqExtensionMethods.ToFuture(query).ToList().Select(SelectItem).ToList()
: query.Select(SelectItem).ToList();
var totalCount = count.Value;
return(new Tuple <IEnumerable <MediaViewModel>, int>(items, totalCount));
}
/// <summary>
/// Executes this command.
/// </summary>
/// <param name="request">A filter to search for specific media items/folders.</param>
/// <returns>A list of tags.</returns>
public MediaManagerItemsViewModel Execute(MediaManagerViewModel request)
{
request.SetDefaultSortingOptions("Title");
var items = GetAllItemsList(request);
var model = new MediaManagerItemsViewModel(items.Item1, request, items.Item2);
model.Path = LoadMediaFolder(request);
model.Tags = request.Tags;
model.Categories = request.Categories;
model.CategoriesLookupList = CategoryService.GetCategoriesLookupList(MediaFile.CategorizableItemKeyForFiles);
return(model);
}
private bool HasTaggedSubItems(MediaFolder folder, MediaManagerViewModel request)
{
if (folder == null)
{
return(false);
}
var query = Repository
.AsQueryable <Media>()
.Where(m => !m.IsDeleted &&
m.Original == null &&
m.Type == MediaType &&
m.Folder != null && m.Folder.Id == folder.Id &&
(m is MediaFolder || m is TEntity && !((TEntity)m).IsTemporary));
if (!request.IncludeArchivedItems)
{
query = query.Where(m => !m.IsArchived);
}
if (request.Tags != null)
{
foreach (var tagKeyValue in request.Tags)
{
var id = tagKeyValue.Key.ToGuidOrDefault();
query = query.Where(m => m is MediaFolder || m.MediaTags.Any(mt => mt.Tag.Id == id));
}
}
var medias = query.ToList();
if (medias.Any(m => m is TEntity))
{
return(true);
}
foreach (var media in medias)
{
if (HasTaggedSubItems(media as MediaFolder, request))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Loads the media folder.
/// </summary>
/// <returns>Media folder view model</returns>
private MediaPathViewModel LoadMediaFolder(MediaManagerViewModel request)
{
var emptyFolderViewModel = new MediaFolderViewModel {
Id = Guid.Empty, Type = MediaType
};
var model = new MediaPathViewModel
{
CurrentFolder = emptyFolderViewModel
};
var folders = new List <MediaFolderViewModel> {
emptyFolderViewModel
};
if (!request.CurrentFolderId.HasDefaultValue())
{
var mediaFolder = Repository.FirstOrDefault <MediaFolder>(e => e.Id == request.CurrentFolderId && e.Original == null);
model.CurrentFolder = mediaFolder != null
? new MediaFolderViewModel
{
Id = mediaFolder.Id,
Name = mediaFolder.Title,
Version = mediaFolder.Version,
Type = mediaFolder.Type,
ParentFolderId = mediaFolder.Folder != null ? mediaFolder.Folder.Id : Guid.Empty
}
: new MediaFolderViewModel();
while (mediaFolder != null)
{
folders.Insert(
1,
new MediaFolderViewModel
{
Id = mediaFolder.Id,
Name = mediaFolder.Title,
Type = mediaFolder.Type,
ParentFolderId = mediaFolder.Folder != null ? mediaFolder.Folder.Id : Guid.Empty
});
mediaFolder = mediaFolder.Folder;
}
}
model.Folders = folders;
return(model);
}
public ActionResult GetFilesList(MediaManagerViewModel options)
{
var success = true;
if (options == null)
{
options = new MediaManagerViewModel();
}
options.SetDefaultPaging();
var model = GetCommand <GetFilesCommand>().ExecuteCommand(options);
if (model == null)
{
success = false;
}
return(WireJson(success, model));
}
/// <summary>
/// Loads the media folder.
/// </summary>
/// <returns>Media folder view model</returns>
private MediaPathViewModel LoadMediaFolder(MediaManagerViewModel request)
{
var emptyFolderViewModel = new MediaFolderViewModel {
Id = Guid.Empty, Type = MediaType
};
var model = new MediaPathViewModel
{
CurrentFolder = emptyFolderViewModel
};
var folders = new List <MediaFolderViewModel> {
emptyFolderViewModel
};
if (!request.CurrentFolderId.HasDefaultValue())
{
MediaFolder folderAlias = null;
MediaFolderViewModel folderModelAlias = null;
var folder = UnitOfWork.Session
.QueryOver(() => folderAlias)
.Where(() => !folderAlias.IsDeleted && folderAlias.Id == request.CurrentFolderId)
.SelectList(select => select
.Select(() => folderAlias.Id).WithAlias(() => folderModelAlias.Id)
.Select(() => folderAlias.Title).WithAlias(() => folderModelAlias.Name)
.Select(() => folderAlias.Version).WithAlias(() => folderModelAlias.Version)
.Select(() => folderAlias.Type).WithAlias(() => folderModelAlias.Type))
.TransformUsing(Transformers.AliasToBean <MediaFolderViewModel>())
.First <MediaFolderViewModel, MediaFolder>();
model.CurrentFolder = folder ?? new MediaFolderViewModel();
if (folder != null)
{
folders.Add(new MediaFolderViewModel {
Id = folder.Id, Name = folder.Name, Type = folder.Type
});
}
}
model.Folders = folders;
return(model);
}
public ActionResult GetFilesList(MediaManagerViewModel options)
{
var success = true;
if (options == null)
{
options = new MediaManagerViewModel();
}
var model = GetCommand <GetFilesCommand>().ExecuteCommand(options);
if (model == null)
{
success = false;
}
return(Json(new WireJson {
Success = success, Data = model
}));
}
/// <summary>
/// Gets the folders.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>
/// The list with folder view models
/// </returns>
private IList <MediaFolderViewModel> GetFolders(MediaManagerViewModel request)
{
MediaFolder folderAlias = null;
MediaFolderViewModel folderModelAlias = null;
var query = UnitOfWork.Session
.QueryOver(() => folderAlias)
.Where(() => !folderAlias.IsDeleted && folderAlias.Type == MediaType);
if (!string.IsNullOrWhiteSpace(request.SearchQuery))
{
var searchQuery = string.Format("%{0}%", request.SearchQuery);
query = query.Where(Restrictions.InsensitiveLike(Projections.Property(() => folderAlias.Title), searchQuery));
}
if (!request.CurrentFolderId.HasDefaultValue())
{
query = query.Where(() => folderAlias.Folder.Id == request.CurrentFolderId);
}
else
{
query = query.Where(() => folderAlias.Folder == null);
}
query = query.SelectList(select => select
.Select(() => folderAlias.Id).WithAlias(() => folderModelAlias.Id)
.Select(() => folderAlias.Title).WithAlias(() => folderModelAlias.Name)
.Select(() => folderAlias.Version).WithAlias(() => folderModelAlias.Version)
.Select(() => folderAlias.Type).WithAlias(() => folderModelAlias.Type))
.TransformUsing(Transformers.AliasToBean <MediaFolderViewModel>());
var options = new SearchableGridOptions()
{
Direction = request.Direction, Column = "Title"
};
query.AddSortingAndPaging(options);
var folders = query.List <MediaFolderViewModel>();
return(folders);
}
/// <summary>
/// Gets the media items list.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>Media items list</returns>
private IList <TModel> GetItemsList(MediaManagerViewModel request)
{
var query = UnitOfWork.Session
.QueryOver(() => alias)
.Where(() => !alias.IsDeleted && alias.Type == MediaType && !alias.IsTemporary);
if (!string.IsNullOrWhiteSpace(request.SearchQuery))
{
var searchQuery = string.Format("%{0}%", request.SearchQuery);
query = query.Where(Restrictions.InsensitiveLike(Projections.Property(() => alias.Title), searchQuery));
}
if (!request.CurrentFolderId.HasDefaultValue())
{
query = query.Where(() => alias.Folder.Id == request.CurrentFolderId);
}
else
{
query = query.Where(() => alias.Folder == null);
}
query = query
.SelectList(SelectItems)
.TransformUsing(Transformers.AliasToBean <TModel>());
query.AddSortingAndPaging(request);
var items = query.List <TModel>();
// Set processed items as failed, if file processing lasts more than specified timeout
var timeout = Configuration.Storage.ProcessTimeout;
var now = DateTime.Now;
items
.Where(m => m.IsProcessing && m.CreatedOn.Add(timeout) < now)
.ToList()
.ForEach(item => { item.IsProcessing = false; item.IsFailed = true; });
return(items);
}
/// <summary>
/// Executes this command.
/// </summary>
/// <param name="request">A filter to search for specific media items/folders.</param>
/// <returns>A list of tags.</returns>
public MediaManagerItemsViewModel Execute(MediaManagerViewModel request)
{
request.SetDefaultSortingOptions("Title");
IEnumerable <MediaViewModel> results;
var folders = GetFolders(request);
var items = GetItemsList(request);
if (request.Direction == SortDirection.Descending)
{
results = items.Cast <MediaViewModel>().Concat(folders);
}
else
{
results = folders.Cast <MediaViewModel>().Concat(items);
}
var model = new MediaManagerItemsViewModel(results, request, results.Count());
model.Path = LoadMediaFolder(request);
return(model);
}
private Tuple <IEnumerable <MediaViewModel>, int> RemoveEmptyFolders(IQueryable <Media> query, MediaManagerViewModel request)
{
var mediaList = query.ToList();
var result = new List <Media>();
foreach (var media in mediaList)
{
var folder = media as MediaFolder;
if (folder == null)
{
result.Add(media);
}
else
{
if (HasTaggedSubItems(folder, request))
{
result.Add(media);
}
}
}
return(ToResponse(request, result.AsQueryable()));
}
private IQueryable <Media> AttachDeniedMediasFilterIfEnabled(IQueryable <Media> query, MediaManagerViewModel request)
{
if (Configuration.Security.AccessControlEnabled)
{
IEnumerable <Guid> deniedMedias = GetDeniedMedias(request);
if (deniedMedias != null)
{
foreach (var deniedFileId in deniedMedias)
{
var id = deniedFileId;
query = query.Where(f => f.Id != id);
}
}
}
return(query);
}
/// <summary>
/// Gets all items list.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>Media items list</returns>
private Tuple <IEnumerable <MediaViewModel>, int> GetAllItemsList(MediaManagerViewModel request)
{
var query = Repository
.AsQueryable <Media>()
.Where(m => !m.IsDeleted &&
m.Original == null &&
m.Type == MediaType &&
(m is MediaFolder || m is TEntity && !((TEntity)m).IsTemporary));
if (!request.IncludeArchivedItems)
{
query = query.Where(m => !m.IsArchived);
}
var removeEmptyFolders = false;
if (request.Tags != null)
{
foreach (var tagKeyValue in request.Tags)
{
var id = tagKeyValue.Key.ToGuidOrDefault();
query = query.Where(m => m is MediaFolder || m.MediaTags.Any(mt => mt.Tag.Id == id));
removeEmptyFolders = true;
}
}
query = AttachDeniedMediasFilterIfEnabled(query, request);
if (!string.IsNullOrWhiteSpace(request.SearchQuery))
{
var searchQuery = string.Format("%{0}%", request.SearchQuery);
query = query.Where(m => m.Title.Contains(searchQuery) || m.Description.Contains(searchQuery) || m.MediaTags.Any(mt => mt.Tag.Name.Contains(searchQuery)));
query = query.Fetch(f => f.Folder);
var mediaList = query.ToList();
var result = new List <Media>();
foreach (var media in mediaList)
{
if (IsChild(media, request.CurrentFolderId, request.IncludeArchivedItems))
{
result.Add(media);
}
}
return(ToResponse(request, result.AsQueryable()));
}
if (!request.CurrentFolderId.HasDefaultValue())
{
query = query.Where(m => m.Folder.Id == request.CurrentFolderId);
}
else
{
query = query.Where(m => m.Folder == null);
}
return(removeEmptyFolders
? RemoveEmptyFolders(query, request)
: ToResponse(request, query, true));
}
/// <summary>
/// Gets the denied medias for the current principal.
/// </summary>
/// <param name="request">The request.</param>
/// <returns></returns>
protected virtual IEnumerable <Guid> GetDeniedMedias(MediaManagerViewModel request)
{
return(null);
}
/// <summary>
/// Gets all items list.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>Media items list</returns>
private Tuple <IEnumerable <MediaViewModel>, int> GetAllItemsList(MediaManagerViewModel request)
{
var query = Repository
.AsQueryable <Media>()
.Where(m => !m.IsDeleted &&
m.Original == null &&
m.Type == MediaType &&
(m is MediaFolder || m is TEntity && !((TEntity)m).IsTemporary));
if (!request.IncludeArchivedItems)
{
query = query.Where(m => !m.IsArchived);
}
var removeEmptyFolders = false;
if (request.Tags != null)
{
foreach (var tagKeyValue in request.Tags)
{
var id = tagKeyValue.Key.ToGuidOrDefault();
query = query.Where(m => m is MediaFolder || m.MediaTags.Any(mt => mt.Tag.Id == id));
removeEmptyFolders = true;
}
}
if (request.Categories != null)
{
var categories = request.Categories.Select(c => new Guid(c.Key)).Distinct().ToList();
foreach (var category in categories)
{
var childCategories = CategoryService.GetChildCategoriesIds(category).ToArray();
query = query.Where(m => m is MediaFolder || m.Categories.Any(cat => childCategories.Contains(cat.Category.Id) && !cat.IsDeleted && !cat.Category.IsDeleted));
removeEmptyFolders = true;
}
}
query = AttachDeniedMediasFilterIfEnabled(query, request);
if (!string.IsNullOrWhiteSpace(request.SearchQuery))
{
var searchQuery = request.SearchQuery;
const string escapeFormat = "[{0}]";
foreach (var escapeChar in escapeChars)
{
searchQuery = searchQuery.Replace(escapeChar, string.Format(escapeFormat, escapeChar));
}
var predicate = PredicateBuilder.False <Media>();
predicate = predicate.Or(m => m.Title.Contains(searchQuery));
predicate = predicate.Or(m => m.Description.Contains(searchQuery));
predicate = predicate.Or(m => m.MediaTags.Any(mt => mt.Tag.Name.Contains(searchQuery)));
predicate = predicate.Or(m => m.Categories.Any(mt => mt.Category.Name.Contains(searchQuery)));
predicate = AppendSearchFilter(predicate, searchQuery);
if (request.SearchInHistory)
{
query = query.Where(m => m.History.AsQueryable().Any(predicate));
}
else
{
query = query.Where(predicate);
}
query = query.Fetch(f => f.Folder);
var mediaList = query.ToList();
var result = new List <Media>();
foreach (var media in mediaList)
{
if (IsChild(media, request.CurrentFolderId, request.IncludeArchivedItems))
{
result.Add(media);
}
}
return(ToResponse(request, result.AsQueryable()));
}
if (!request.CurrentFolderId.HasDefaultValue())
{
query = query.Where(m => m.Folder.Id == request.CurrentFolderId);
}
else
{
query = query.Where(m => m.Folder == null);
}
return(removeEmptyFolders
? RemoveEmptyFolders(query, request)
: ToResponse(request, query, true));
}
