public override async Task <IEnumerable <MediaItem> > GetAllMediaItems()
{
IContentDirectory cd = ServiceRegistration.Get <IServerConnectionManager>().ContentDirectory;
if (cd == null)
{
return(new List <MediaItem>());
}
UserProfile userProfile = null;
IUserManagement userProfileDataManagement = ServiceRegistration.Get <IUserManagement>();
if (userProfileDataManagement != null && userProfileDataManagement.IsValidUser)
{
userProfile = userProfileDataManagement.CurrentUser;
}
MediaItemQuery query = new MediaItemQuery(
_necessaryMIATypeIds,
_optionalMIATypeIds,
UserHelper.GetUserRestrictionFilter(_necessaryMIATypeIds, userProfile, new BooleanCombinationFilter(BooleanOperator.And,
new IFilter[]
{
new RelationalFilter(ProviderResourceAspect.ATTR_SYSTEM_ID, RelationalOperator.EQ, _systemId),
new LikeFilter(ProviderResourceAspect.ATTR_RESOURCE_ACCESSOR_PATH, SqlUtils.LikeEscape(_basePath.Serialize(), '\\') + "%", '\\', true)
})));
bool showVirtual = VirtualMediaHelper.ShowVirtualMedia(_necessaryMIATypeIds);
return(await cd.SearchAsync(query, false, userProfile?.ProfileId, showVirtual));
}
protected static async Task FillListAsync(IContentDirectory contentDirectory, Guid[] necessaryMIATypeIds, ItemsList list, MediaItemToListItemAction converterAction)
{
MediaItemQuery query = new MediaItemQuery(necessaryMIATypeIds, null)
{
Limit = QUERY_LIMIT, // Last 5 imported items
SortInformation = new List <ISortInformation> {
new AttributeSortInformation(ImporterAspect.ATTR_DATEADDED, SortDirection.Descending)
}
};
Guid? userProfile = null;
IUserManagement userProfileDataManagement = ServiceRegistration.Get <IUserManagement>();
if (userProfileDataManagement != null && userProfileDataManagement.IsValidUser)
{
userProfile = userProfileDataManagement.CurrentUser.ProfileId;
}
bool showVirtual = VirtualMediaHelper.ShowVirtualMedia(necessaryMIATypeIds);
var items = await contentDirectory.SearchAsync(query, false, userProfile, showVirtual);
list.Clear();
foreach (MediaItem mediaItem in items)
{
PlayableMediaItem listItem = converterAction(mediaItem);
listItem.Command = new MethodDelegateCommand(() => PlayItemsModel.CheckQueryPlayAction(listItem.MediaItem));
list.Add(listItem);
}
list.FireChange();
}
public override async Task <ICollection <FilterValue> > GetAvailableValuesAsync(IEnumerable <Guid> necessaryMIATypeIds, IFilter selectAttributeFilter, IFilter filter)
{
IContentDirectory cd = ServiceRegistration.Get <IServerConnectionManager>().ContentDirectory;
if (cd == null)
{
throw new NotConnectedException("The MediaLibrary is not connected");
}
IUserManagement userProfileDataManagement = ServiceRegistration.Get <IUserManagement>();
if (!userProfileDataManagement.IsValidUser)
{
return(new List <FilterValue>());
}
IFilter unwatchedFilter = new RelationalUserDataFilter(userProfileDataManagement.CurrentUser.ProfileId, UserDataKeysKnown.KEY_PLAY_PERCENTAGE, RelationalOperator.EQ, UserDataKeysKnown.GetSortablePlayPercentageString(0), true);
IFilter watchedFilter = new RelationalUserDataFilter(userProfileDataManagement.CurrentUser.ProfileId, UserDataKeysKnown.KEY_PLAY_PERCENTAGE, RelationalOperator.GT, UserDataKeysKnown.GetSortablePlayPercentageString(0));
bool showVirtual = VirtualMediaHelper.ShowVirtualMedia(necessaryMIATypeIds);
var taskUnwatched = cd.CountMediaItemsAsync(necessaryMIATypeIds, BooleanCombinationFilter.CombineFilters(BooleanOperator.And, filter, unwatchedFilter), true, showVirtual);
var taskWatched = cd.CountMediaItemsAsync(necessaryMIATypeIds, BooleanCombinationFilter.CombineFilters(BooleanOperator.And, filter, watchedFilter), true, showVirtual);
var counts = await Task.WhenAll(taskUnwatched, taskWatched);
return(new List <FilterValue>(new FilterValue[]
{
new FilterValue(Consts.RES_VALUE_UNWATCHED, unwatchedFilter, null, counts[0], this),
new FilterValue(Consts.RES_VALUE_WATCHED, watchedFilter, null, counts[1], this),
}.Where(fv => !fv.NumItems.HasValue || fv.NumItems.Value > 0)));
}
protected internal override void ReLoadItemsAndSubViewSpecifications(out IList <MediaItem> mediaItems, out IList <ViewSpecification> subViewSpecifications)
{
mediaItems = null;
subViewSpecifications = new List <ViewSpecification>();
IContentDirectory cd = ServiceRegistration.Get <IServerConnectionManager>().ContentDirectory;
if (cd == null)
{
return;
}
Guid? userProfile = null;
IUserManagement userProfileDataManagement = ServiceRegistration.Get <IUserManagement>();
if (userProfileDataManagement != null && userProfileDataManagement.IsValidUser)
{
userProfile = userProfileDataManagement.CurrentUser.ProfileId;
}
bool showVirtual = VirtualMediaHelper.ShowVirtualMedia(_necessaryMIATypeIds);
try
{
MediaItemQuery query = new MediaItemQuery(_necessaryMIATypeIds, _optionalMIATypeIds, _filter)
{
Limit = Consts.MAX_NUM_ITEMS_VISIBLE
};
mediaItems = cd.SearchAsync(query, true, userProfile, showVirtual).Result;
}
catch (UPnPRemoteException e)
{
ServiceRegistration.Get <ILogger>().Error("SimpleTextSearchViewSpecification.ReLoadItemsAndSubViewSpecifications: Error requesting server", e);
mediaItems = new List <MediaItem>();
}
}
public override async Task <ICollection <FilterValue> > GetAvailableValuesAsync(IEnumerable <Guid> necessaryMIATypeIds, IFilter selectAttributeFilter, IFilter filter)
{
IContentDirectory cd = ServiceRegistration.Get <IServerConnectionManager>().ContentDirectory;
if (cd == null)
{
throw new NotConnectedException("The MediaLibrary is not connected");
}
bool showVirtual = VirtualMediaHelper.ShowVirtualMedia(necessaryMIATypeIds);
IFilter emptyFilter = new EmptyFilter(AudioAlbumAspect.ATTR_COMPILATION);
IFilter compiledFilter = new RelationalFilter(AudioAlbumAspect.ATTR_COMPILATION, RelationalOperator.EQ, true);
IFilter uncompiledFilter = new RelationalFilter(AudioAlbumAspect.ATTR_COMPILATION, RelationalOperator.EQ, false);
var taskEmpty = cd.CountMediaItemsAsync(necessaryMIATypeIds, emptyFilter, true, showVirtual);
var taskCompiled = cd.CountMediaItemsAsync(necessaryMIATypeIds, compiledFilter, true, showVirtual);
var taskUncompiled = cd.CountMediaItemsAsync(necessaryMIATypeIds, uncompiledFilter, true, showVirtual);
var counts = await Task.WhenAll(taskEmpty, taskCompiled, taskUncompiled);
return(new List <FilterValue>(new FilterValue[]
{
new FilterValue(Consts.RES_VALUE_EMPTY_TITLE, emptyFilter, null, counts[0], this),
new FilterValue(Consts.RES_COMPILATION_FILTER_COMPILED, compiledFilter, null, counts[1], this),
new FilterValue(Consts.RES_COMPILATION_FILTER_UNCOMPILED, uncompiledFilter, null, counts[2], this),
}.Where(fv => !fv.NumItems.HasValue || fv.NumItems.Value > 0)));
}
public override async Task <ICollection <FilterValue> > GetAvailableValuesAsync(IEnumerable <Guid> necessaryMIATypeIds, IFilter selectAttributeFilter, IFilter filter)
{
IContentDirectory cd = ServiceRegistration.Get <IServerConnectionManager>().ContentDirectory;
if (cd == null)
{
throw new NotConnectedException("The MediaLibrary is not connected");
}
Guid? userProfile = null;
IUserManagement userProfileDataManagement = ServiceRegistration.Get <IUserManagement>();
if (userProfileDataManagement != null && userProfileDataManagement.IsValidUser)
{
userProfile = userProfileDataManagement.CurrentUser.ProfileId;
}
IEnumerable <Guid> mias = _necessaryMIATypeIds ?? necessaryMIATypeIds;
IEnumerable <Guid> optMias = _optionalMIATypeIds != null?_optionalMIATypeIds.Except(mias) : null;
bool showVirtual = VirtualMediaHelper.ShowVirtualMedia(necessaryMIATypeIds);
IFilter queryFilter = new FilteredRelationshipFilter(_role, _linkedRole, filter);
MediaItemQuery query = new MediaItemQuery(mias, optMias, queryFilter);
if (_sortInformation != null)
{
query.SortInformation = new List <ISortInformation> {
_sortInformation
}
}
;
IList <MediaItem> items = await cd.SearchAsync(query, true, userProfile, showVirtual);
CertificationHelper.ConvertCertifications(items);
IList <FilterValue> result = new List <FilterValue>(items.Count);
foreach (MediaItem item in items)
{
string name;
MediaItemAspect.TryGetAttribute(item.Aspects, MediaAspect.ATTR_TITLE, out name);
result.Add(new FilterValue(name,
new FilterTreePath(_role),
null,
item,
this));
}
//ToDo: Add support for an empty entry for all filtered items that don't have this relationship
//The below works OK in simple cases but results in an extra, relatively long running query. Maybe this should be handled
//at the server for all relationship queries...
//IFilter emptyRelationshipFilter = new NotFilter(new RelationshipFilter(_linkedRole, _role, Guid.Empty));
//queryFilter = filter != null ? BooleanCombinationFilter.CombineFilters(BooleanOperator.And, filter, emptyRelationshipFilter) : emptyRelationshipFilter;
//int numEmptyEntries = cd.CountMediaItems(necessaryMIATypeIds, queryFilter, true, showVirtual);
//if(numEmptyEntries > 0)
// result.Insert(0, new FilterValue(Consts.RES_VALUE_EMPTY_TITLE, emptyRelationshipFilter, null, this));
return(result);
}
public override async Task <ICollection <FilterValue> > GetAvailableValuesAsync(IEnumerable <Guid> necessaryMIATypeIds, IFilter selectAttributeFilter, IFilter filter)
{
IServerConnectionManager serverConnectionManager = ServiceRegistration.Get <IServerConnectionManager>();
IServerController serverController = serverConnectionManager.ServerController;
if (serverController == null)
{
throw new NotConnectedException("The MediaLibrary is not connected");
}
IDictionary <string, string> systemNames = new Dictionary <string, string>();
foreach (MPClientMetadata client in serverController.GetAttachedClients())
{
systemNames.Add(client.SystemId, client.LastClientName);
}
systemNames.Add(serverConnectionManager.HomeServerSystemId, serverConnectionManager.LastHomeServerName);
IContentDirectory cd = ServiceRegistration.Get <IServerConnectionManager>().ContentDirectory;
if (cd == null)
{
return(new List <FilterValue>());
}
bool showVirtual = VirtualMediaHelper.ShowVirtualMedia(necessaryMIATypeIds);
HomogenousMap valueGroups = await cd.GetValueGroupsAsync(ProviderResourceAspect.ATTR_SYSTEM_ID, null, ProjectionFunction.None, necessaryMIATypeIds, filter, true, showVirtual);
IList <FilterValue> result = new List <FilterValue>(valueGroups.Count);
int numEmptyEntries = 0;
foreach (KeyValuePair <object, object> group in valueGroups)
{
string name = group.Key as string ?? string.Empty;
name = name.Trim();
if (name == string.Empty)
{
numEmptyEntries += (int)group.Value;
}
else
{
string systemName;
if (systemNames.TryGetValue(name, out systemName) && !string.IsNullOrEmpty(systemName))
{
name = systemName;
}
result.Add(new FilterValue(name,
new RelationalFilter(ProviderResourceAspect.ATTR_SYSTEM_ID, RelationalOperator.EQ, group.Key), null, (int)group.Value, this));
}
}
if (numEmptyEntries > 0)
{
result.Insert(0, new FilterValue(Consts.RES_VALUE_EMPTY_TITLE, new EmptyFilter(ProviderResourceAspect.ATTR_SYSTEM_ID), null, numEmptyEntries, this));
}
return(result);
}
protected internal override void ReLoadItemsAndSubViewSpecifications(out IList <MediaItem> mediaItems, out IList <ViewSpecification> subViewSpecifications)
{
mediaItems = null;
subViewSpecifications = null;
IContentDirectory cd = ServiceRegistration.Get <IServerConnectionManager>().ContentDirectory;
if (cd == null)
{
return;
}
Guid? userProfile = null;
IUserManagement userProfileDataManagement = ServiceRegistration.Get <IUserManagement>();
if (userProfileDataManagement != null && userProfileDataManagement.IsValidUser)
{
userProfile = userProfileDataManagement.CurrentUser.ProfileId;
}
try
{
bool showVirtual = VirtualMediaHelper.ShowVirtualMedia(_necessaryMIATypeIds);
mediaItems = new List <MediaItem>(cd.BrowseAsync(_directoryId, _necessaryMIATypeIds, _optionalMIATypeIds, userProfile, showVirtual).Result);
ICollection <MediaItem> childDirectories = cd.BrowseAsync(_directoryId, DIRECTORY_MIA_ID_ENUMERATION, EMPTY_ID_ENUMERATION, userProfile, showVirtual).Result;
subViewSpecifications = new List <ViewSpecification>(childDirectories.Count);
foreach (MediaItem childDirectory in childDirectories)
{
SingleMediaItemAspect ma = null;
MediaItemAspect.TryGetAspect(childDirectory.Aspects, MediaAspect.Metadata, out ma);
IList <MultipleMediaItemAspect> pras = null;
MediaItemAspect.TryGetAspects(childDirectory.Aspects, ProviderResourceAspect.Metadata, out pras);
foreach (MultipleMediaItemAspect pra in pras)
{
MediaLibraryBrowseViewSpecification subViewSpecification = new MediaLibraryBrowseViewSpecification(
(string)ma.GetAttributeValue(MediaAspect.ATTR_TITLE), childDirectory.MediaItemId,
(string)pra.GetAttributeValue(ProviderResourceAspect.ATTR_SYSTEM_ID),
ResourcePath.Deserialize((string)pra.GetAttributeValue(ProviderResourceAspect.ATTR_RESOURCE_ACCESSOR_PATH)),
_necessaryMIATypeIds, _optionalMIATypeIds);
subViewSpecifications.Add(subViewSpecification);
}
}
}
catch (UPnPRemoteException e)
{
ServiceRegistration.Get <ILogger>().Error("SimpleTextSearchViewSpecification.ReLoadItemsAndSubViewSpecifications: Error requesting server", e);
mediaItems = null;
subViewSpecifications = null;
}
}
public override async Task <ICollection <FilterValue> > GetAvailableValuesAsync(IEnumerable <Guid> necessaryMIATypeIds, IFilter selectAttributeFilter, IFilter filter)
{
IContentDirectory cd = ServiceRegistration.Get <IServerConnectionManager>().ContentDirectory;
if (cd == null)
{
throw new NotConnectedException("The MediaLibrary is not connected");
}
IFilter emptyFilter = BooleanCombinationFilter.CombineFilters(BooleanOperator.Or,
new EmptyFilter(ImageAspect.ATTR_WIDTH),
new RelationalFilter(ImageAspect.ATTR_WIDTH, RelationalOperator.EQ, 0),
new EmptyFilter(ImageAspect.ATTR_HEIGHT),
new RelationalFilter(ImageAspect.ATTR_HEIGHT, RelationalOperator.EQ, 0));
IFilter simpleSmallFilter = BooleanCombinationFilter.CombineFilters(BooleanOperator.And,
new RelationalFilter(ImageAspect.ATTR_WIDTH, RelationalOperator.LT, Consts.SMALL_SIZE_THRESHOLD),
new RelationalFilter(ImageAspect.ATTR_HEIGHT, RelationalOperator.LT, Consts.SMALL_SIZE_THRESHOLD));
IFilter smallFilter = BooleanCombinationFilter.CombineFilters(BooleanOperator.And,
simpleSmallFilter,
new NotFilter(BooleanCombinationFilter.CombineFilters(BooleanOperator.Or,
new RelationalFilter(ImageAspect.ATTR_WIDTH, RelationalOperator.EQ, 0),
new RelationalFilter(ImageAspect.ATTR_HEIGHT, RelationalOperator.EQ, 0))));
IFilter bigFilter = BooleanCombinationFilter.CombineFilters(BooleanOperator.Or,
new RelationalFilter(ImageAspect.ATTR_WIDTH, RelationalOperator.GT, Consts.BIG_SIZE_THRESHOLD),
new RelationalFilter(ImageAspect.ATTR_HEIGHT, RelationalOperator.GT, Consts.BIG_SIZE_THRESHOLD));
IFilter mediumFilter = BooleanCombinationFilter.CombineFilters(BooleanOperator.And,
new NotFilter(simpleSmallFilter),
new NotFilter(bigFilter));
bool showVirtual = VirtualMediaHelper.ShowVirtualMedia(necessaryMIATypeIds);
var taskEmpty = cd.CountMediaItemsAsync(necessaryMIATypeIds, emptyFilter, true, showVirtual);
var taskSmall = cd.CountMediaItemsAsync(necessaryMIATypeIds, smallFilter, true, showVirtual);
var taskMedium = cd.CountMediaItemsAsync(necessaryMIATypeIds, mediumFilter, true, showVirtual);
var taskBig = cd.CountMediaItemsAsync(necessaryMIATypeIds, bigFilter, true, showVirtual);
var counts = await Task.WhenAll(taskEmpty, taskSmall, taskMedium, taskBig);
return(new List <FilterValue>(new FilterValue[]
{
new FilterValue(Consts.RES_VALUE_EMPTY_TITLE, emptyFilter, null, counts[0], this),
new FilterValue(Consts.RES_IMAGE_FILTER_SMALL, smallFilter, null, counts[1], this),
new FilterValue(Consts.RES_IMAGE_FILTER_MEDIUM, mediumFilter, null, counts[2], this),
new FilterValue(Consts.RES_IMAGE_FILTER_BIG, bigFilter, null, counts[3], this),
}.Where(fv => !fv.NumItems.HasValue || fv.NumItems.Value > 0)));
}
public override async Task <ICollection <FilterValue> > GroupValuesAsync(ICollection <Guid> necessaryMIATypeIds, IFilter selectAttributeFilter, IFilter filter)
{
if (_groupByAttributeType == null)
{
return(null);
}
IContentDirectory cd = ServiceRegistration.Get <IServerConnectionManager>().ContentDirectory;
if (cd == null)
{
throw new NotConnectedException("The MediaLibrary is not connected");
}
bool showVirtual = VirtualMediaHelper.ShowVirtualMedia(necessaryMIATypeIds);
if (_necessaryMIATypeIds != null)
{
necessaryMIATypeIds = _necessaryMIATypeIds.ToList();
}
IList <MLQueryResultGroup> valueGroups = await cd.GroupValueGroupsAsync(_groupByAttributeType, selectAttributeFilter, ProjectionFunction.None,
necessaryMIATypeIds, filter, true, GroupingFunction.FirstCharacter, showVirtual).ConfigureAwait(false);
IList <FilterValue> result = new List <FilterValue>(valueGroups.Count);
int numEmptyEntries = 0;
foreach (MLQueryResultGroup group in valueGroups)
{
string name = string.Format("{0}", group.GroupKey);
name = name.Trim();
if (name == string.Empty)
{
numEmptyEntries += group.NumItemsInGroup;
}
else
{
result.Add(new FilterValue(name, new FilterTreePath(_role), group.AdditionalFilter, group.NumItemsInGroup, this));
}
}
if (numEmptyEntries > 0)
{
result.Insert(0, new FilterValue(Consts.RES_VALUE_EMPTY_TITLE, new EmptyFilter(_groupByAttributeType), null, numEmptyEntries, this));
}
return(result);
}
public override async Task <ICollection <FilterValue> > GetAvailableValuesAsync(IEnumerable <Guid> necessaryMIATypeIds, IFilter selectAttributeFilter, IFilter filter)
{
IContentDirectory cd = ServiceRegistration.Get <IServerConnectionManager>().ContentDirectory;
if (cd == null)
{
throw new NotConnectedException("The MediaLibrary is not connected");
}
bool showVirtual = VirtualMediaHelper.ShowVirtualMedia(necessaryMIATypeIds);
HomogenousMap valueGroups = await cd.GetValueGroupsAsync(MediaAspect.ATTR_RECORDINGTIME, null, ProjectionFunction.DateToYear,
necessaryMIATypeIds, filter, true, showVirtual);
IList <FilterValue> result = new List <FilterValue>(valueGroups.Count);
int numEmptyEntries = 0;
foreach (KeyValuePair <object, object> group in valueGroups)
{
int?year = (int?)group.Key;
if (year.HasValue)
{
result.Add(new FilterValue(year.Value.ToString(),
new BooleanCombinationFilter(BooleanOperator.And, new IFilter[]
{
new RelationalFilter(MediaAspect.ATTR_RECORDINGTIME, RelationalOperator.GE, new DateTime(year.Value, 1, 1)),
new RelationalFilter(MediaAspect.ATTR_RECORDINGTIME, RelationalOperator.LT, new DateTime(year.Value + 1, 1, 1)),
}), null, (int)group.Value, this));
}
else
{
numEmptyEntries += (int)group.Value;
}
}
if (numEmptyEntries > 0)
{
result.Insert(0, new FilterValue(Consts.RES_VALUE_EMPTY_TITLE, new EmptyFilter(MediaAspect.ATTR_RECORDINGTIME), null, numEmptyEntries, this));
}
return(result);
}
public override async Task <IEnumerable <MediaItem> > GetAllMediaItems()
{
IContentDirectory cd = ServiceRegistration.Get <IServerConnectionManager>().ContentDirectory;
if (cd == null)
{
return(new List <MediaItem>());
}
Guid? userProfile = null;
IUserManagement userProfileDataManagement = ServiceRegistration.Get <IUserManagement>();
if (userProfileDataManagement != null && userProfileDataManagement.IsValidUser)
{
userProfile = userProfileDataManagement.CurrentUser.ProfileId;
}
bool showVirtual = VirtualMediaHelper.ShowVirtualMedia(_query.NecessaryRequestedMIATypeIDs);
IList <MediaItem> mediaItems = await cd.SearchAsync(_query, _onlyOnline, userProfile, showVirtual);
CertificationHelper.ConvertCertifications(mediaItems);
return(mediaItems);
}
// We produce hardcoded titles for this filter criterion like "< 1950", "1950-1960", ... Should we use language
// resources for them?
#region Base overrides
public override async Task <ICollection <FilterValue> > GetAvailableValuesAsync(IEnumerable <Guid> necessaryMIATypeIds, IFilter selectAttributeFilter, IFilter filter)
{
// We'll do the grouping here at the client. We could also implement a grouping function for decades at the server,
// but that seems to be not better since it increases the server code size, the server workload, it complicates the
// call structure and it doesn't bring us an advantage
IContentDirectory cd = ServiceRegistration.Get <IServerConnectionManager>().ContentDirectory;
if (cd == null)
{
throw new NotConnectedException("The MediaLibrary is not connected");
}
bool showVirtual = VirtualMediaHelper.ShowVirtualMedia(necessaryMIATypeIds);
HomogenousMap valueGroups = await cd.GetValueGroupsAsync(MediaAspect.ATTR_RECORDINGTIME, null, ProjectionFunction.DateToYear,
necessaryMIATypeIds, filter, true, showVirtual);
IList <FilterValue> result = new List <FilterValue>(valueGroups.Count);
int numEmptyEntries = 0;
IDictionary <int, int> decadesToNumItems = new Dictionary <int, int>();
foreach (KeyValuePair <object, object> group in valueGroups)
{
int?year = (int?)group.Key;
if (year.HasValue)
{
int yearVal = year.Value;
int decade = yearVal / 10;
int numItems;
if (!decadesToNumItems.TryGetValue(decade, out numItems))
{
numItems = 0;
}
decadesToNumItems[decade] = numItems + (int)group.Value;
}
else
{
numEmptyEntries += (int)group.Value;
}
}
if (numEmptyEntries > 0)
{
result.Insert(0, new FilterValue(Consts.RES_VALUE_EMPTY_TITLE, new EmptyFilter(MediaAspect.ATTR_RECORDINGTIME), null, numEmptyEntries, this));
}
for (int decade = 0; decade < 300; decade++)
{
int year = decade * 10;
int numItems;
if (!decadesToNumItems.TryGetValue(decade, out numItems))
{
continue;
}
result.Add(new FilterValue(year.ToString(),
new BooleanCombinationFilter(BooleanOperator.And, new IFilter[]
{
new RelationalFilter(MediaAspect.ATTR_RECORDINGTIME, RelationalOperator.GE, new DateTime(year, 1, 1)),
new RelationalFilter(MediaAspect.ATTR_RECORDINGTIME, RelationalOperator.LT, new DateTime(year + 10, 1, 1)),
}), null, numItems, this));
}
return(result);
}
public override async Task <ICollection <FilterValue> > GetAvailableValuesAsync(IEnumerable <Guid> necessaryMIATypeIds, IFilter selectAttributeFilter, IFilter filter)
{
IContentDirectory cd = ServiceRegistration.Get <IServerConnectionManager>().ContentDirectory;
if (cd == null)
{
throw new NotConnectedException("The MediaLibrary is not connected");
}
bool showVirtual = VirtualMediaHelper.ShowVirtualMedia(necessaryMIATypeIds);
if (_necessaryMIATypeIds != null)
{
necessaryMIATypeIds = _necessaryMIATypeIds;
}
HomogenousMap valueGroups = null;
HomogenousMap valueKeys = null;
if (_keyAttributeType != null)
{
Tuple <HomogenousMap, HomogenousMap> values = await cd.GetKeyValueGroupsAsync(_keyAttributeType, _valueAttributeType, selectAttributeFilter, ProjectionFunction.None, necessaryMIATypeIds, filter, true, showVirtual);
valueGroups = values.Item1;
valueKeys = values.Item2;
}
else
{
valueGroups = await cd.GetValueGroupsAsync(_valueAttributeType, selectAttributeFilter, ProjectionFunction.None, necessaryMIATypeIds, filter, true, showVirtual);
}
IList <FilterValue> result = new List <FilterValue>(valueGroups.Count);
int numEmptyEntries = 0;
foreach (KeyValuePair <object, object> group in valueGroups)
{
if (_keyAttributeType != null)
{
string name = GetDisplayName(group.Key);
if (name == string.Empty)
{
numEmptyEntries += (int)group.Value;
}
else
{
result.Add(new FilterValue(valueKeys[group.Key], name, new RelationalFilter(_valueAttributeType, RelationalOperator.EQ, group.Key), null, (int)group.Value, this));
}
}
else
{
string name = GetDisplayName(group.Key);
if (name == string.Empty)
{
numEmptyEntries += (int)group.Value;
}
else
{
result.Add(new FilterValue(name, new RelationalFilter(_valueAttributeType, RelationalOperator.EQ, group.Key), null, (int)group.Value, this));
}
}
}
if (numEmptyEntries > 0)
{
result.Insert(0, new FilterValue(Consts.RES_VALUE_EMPTY_TITLE, new EmptyFilter(_valueAttributeType), null, numEmptyEntries, this));
}
return(result);
}
public virtual async Task <bool> UpdateItemsAsync(int maxItems, UpdateReason updateReason)
{
if (!ShouldUpdate(updateReason))
{
return(false);
}
if (_playableConverterAction == null && _playableContainerConverterAction == null)
{
return(false);
}
var contentDirectory = ServiceRegistration.Get <IServerConnectionManager>().ContentDirectory;
if (contentDirectory == null)
{
return(false);
}
MediaItemQuery query = await CreateQueryAsync();
if (query == null)
{
return(false);
}
query.Limit = (uint)maxItems;
Guid?userProfile = CurrentUserProfile?.ProfileId;
bool showVirtual = VirtualMediaHelper.ShowVirtualMedia(_necessaryMias);
var items = await contentDirectory.SearchAsync(query, true, userProfile, showVirtual);
lock (_allItems.SyncRoot)
{
if (_currentMediaItems != null && _currentMediaItems.Select(m => m.MediaItemId).SequenceEqual(items.Select(m => m.MediaItemId)))
{
return(false);
}
_currentMediaItems = items;
IEnumerable <ListItem> listItems;
if (_playableConverterAction != null)
{
listItems = items.Select(mi =>
{
PlayableMediaItem listItem = _playableConverterAction(mi);
listItem.Command = new MethodDelegateCommand(() => PlayItemsModel.CheckQueryPlayAction(listItem.MediaItem));
return(listItem);
});
}
else
{
listItems = items.Select(mi => _playableContainerConverterAction(mi));
}
_allItems.Clear();
CollectionUtils.AddAll(_allItems, listItems);
}
_allItems.FireChange();
return(true);
}
public override async Task <ICollection <FilterValue> > GetAvailableValuesAsync(IEnumerable <Guid> necessaryMIATypeIds, IFilter selectAttributeFilter, IFilter filter)
{
IContentDirectory cd = ServiceRegistration.Get <IServerConnectionManager>().ContentDirectory;
if (cd == null)
{
throw new NotConnectedException("The MediaLibrary is not connected");
}
bool showVirtual = VirtualMediaHelper.ShowVirtualMedia(necessaryMIATypeIds);
ViewSettings settings = ServiceRegistration.Get <ISettingsManager>().Load <ViewSettings>();
IGenreConverter converter = ServiceRegistration.Get <IGenreConverter>();
Dictionary <int, FilterValue> genredFilters = new Dictionary <int, FilterValue>();
List <FilterValue> ungenredFilters = new List <FilterValue>();
if (_necessaryMIATypeIds != null)
{
necessaryMIATypeIds = _necessaryMIATypeIds;
}
HomogenousMap valueGroups = null;
HomogenousMap valueKeys = null;
if (_keyAttributeType != null)
{
Tuple <HomogenousMap, HomogenousMap> values = await cd.GetKeyValueGroupsAsync(_keyAttributeType, _valueAttributeType, selectAttributeFilter, ProjectionFunction.None, necessaryMIATypeIds, filter, true, showVirtual);
valueGroups = values.Item1;
valueKeys = values.Item2;
}
else
{
valueGroups = await cd.GetValueGroupsAsync(_valueAttributeType, selectAttributeFilter, ProjectionFunction.None, necessaryMIATypeIds, filter, true, showVirtual);
}
IList <FilterValue> result = new List <FilterValue>(valueGroups.Count);
int numEmptyEntries = 0;
foreach (KeyValuePair <object, object> group in valueGroups)
{
string name = GetDisplayName(group.Key);
if (name == string.Empty)
{
numEmptyEntries += (int)group.Value;
}
else if (!string.IsNullOrEmpty(_genreCategory) && settings.UseLocalizedGenres)
{
int?genreId = valueKeys[group.Key] as int?;
if (!genreId.HasValue)
{
ungenredFilters.Add(new FilterValue(valueKeys[group.Key], name, new RelationalFilter(_valueAttributeType, RelationalOperator.EQ, group.Key), null, (int)group.Value, this));
}
else if (!genredFilters.ContainsKey(genreId.Value))
{
if (converter.GetGenreName(genreId.Value, _genreCategory, null, out string genreName))
{
name = genreName;
}
genredFilters.Add(genreId.Value, new FilterValue(genreId.Value, name, new RelationalFilter(_valueAttributeType, RelationalOperator.EQ, group.Key), null, (int)group.Value, this));
}
else
{
genredFilters[genreId.Value] = new FilterValue(genreId.Value, genredFilters[genreId.Value].Title,
BooleanCombinationFilter.CombineFilters(BooleanOperator.Or, genredFilters[genreId.Value].Filter, new RelationalFilter(_valueAttributeType, RelationalOperator.EQ, group.Key)), null,
genredFilters[genreId.Value].NumItems.Value + (int)group.Value, this);
}
}
else
{
result.Add(new FilterValue(valueKeys[group.Key], name, new RelationalFilter(_valueAttributeType, RelationalOperator.EQ, group.Key), null, (int)group.Value, this));
}
}
foreach (var gf in genredFilters.Values)
{
result.Add(gf);
}
foreach (var ugf in ungenredFilters)
{
result.Add(ugf);
}
if (numEmptyEntries > 0)
{
result.Insert(0, new FilterValue(Consts.RES_VALUE_EMPTY_TITLE, new EmptyFilter(_valueAttributeType), null, numEmptyEntries, this));
}
return(result);
}
public override async Task <ICollection <FilterValue> > GetAvailableValuesAsync(IEnumerable <Guid> necessaryMIATypeIds, IFilter selectAttributeFilter, IFilter filter)
{
IContentDirectory cd = ServiceRegistration.Get <IServerConnectionManager>().ContentDirectory;
if (cd == null)
{
throw new NotConnectedException("The MediaLibrary is not connected");
}
bool showVirtual = VirtualMediaHelper.ShowVirtualMedia(necessaryMIATypeIds);
if (string.IsNullOrEmpty(CertificationHelper.DisplayMovieCertificationCountry))
{
HomogenousMap valueGroups = await cd.GetValueGroupsAsync(MovieAspect.ATTR_CERTIFICATION, null, ProjectionFunction.None,
necessaryMIATypeIds, filter, true, showVirtual);
IList <FilterValue> result = new List <FilterValue>(valueGroups.Count);
int numEmptyEntries = 0;
foreach (KeyValuePair <object, object> group in valueGroups)
{
string certification = (string)group.Key;
if (!string.IsNullOrEmpty(certification))
{
CertificationMapping cert;
if (CertificationMapper.TryFindMovieCertification(certification, out cert))
{
result.Add(new FilterValue(cert.CertificationId, cert.Name,
new RelationalFilter(MovieAspect.ATTR_CERTIFICATION, RelationalOperator.EQ, certification), null, (int)group.Value, this));
}
}
else
{
numEmptyEntries += (int)group.Value;
}
}
if (numEmptyEntries > 0)
{
result.Insert(0, new FilterValue("UR", Consts.RES_VALUE_UNRATED_TITLE, new EmptyFilter(MovieAspect.ATTR_CERTIFICATION), null, numEmptyEntries, this));
}
return(result);
}
else
{
IList <FilterValue> result = new List <FilterValue>();
IFilter emptyFilter = new EmptyFilter(MovieAspect.ATTR_CERTIFICATION);
int numEmptyItems = await cd.CountMediaItemsAsync(necessaryMIATypeIds, BooleanCombinationFilter.CombineFilters(BooleanOperator.And, filter, emptyFilter), true, showVirtual);
if (numEmptyItems > 0)
{
result.Add(new FilterValue("UR", Consts.RES_VALUE_UNRATED_TITLE, emptyFilter, null, numEmptyItems, this));
}
List <string> usedFilters = new List <string>();
foreach (var cert in CertificationMapper.GetMovieCertificationsForCountry(CertificationHelper.DisplayMovieCertificationCountry))
{
IEnumerable <CertificationMapping> certs = CertificationMapper.FindAllAllowedMovieCertifications(cert.CertificationId);
if (certs.Count() > 0)
{
List <string> certList = new List <string>(certs.Select(c => c.CertificationId).Except(usedFilters));
usedFilters.AddRange(certList);
IFilter certFilter = new InFilter(MovieAspect.ATTR_CERTIFICATION, certList);
int numItems = await cd.CountMediaItemsAsync(necessaryMIATypeIds, BooleanCombinationFilter.CombineFilters(BooleanOperator.And, filter, certFilter), true, showVirtual);
result.Add(new FilterValue(cert.CertificationId, cert.Name, certFilter, null, numItems, this));
}
}
return(result);
}
}
protected internal async Task <Tuple <IList <MediaItem>, IList <ViewSpecification> > > ReLoadItemsAndSubViewSpecificationsAsync()
{
IList <MediaItem> mediaItems = null;
IList <ViewSpecification> subViewSpecifications = null;
IContentDirectory cd = ServiceRegistration.Get <IServerConnectionManager>().ContentDirectory;
if (cd == null)
{
return(new Tuple <IList <MediaItem>, IList <ViewSpecification> >(null, null));
}
Guid? userProfile = null;
IUserManagement userProfileDataManagement = ServiceRegistration.Get <IUserManagement>();
if (userProfileDataManagement != null && userProfileDataManagement.IsValidUser)
{
userProfile = userProfileDataManagement.CurrentUser.ProfileId;
}
bool showVirtual = VirtualMediaHelper.ShowVirtualMedia(_query.NecessaryRequestedMIATypeIDs);
try
{
if (MaxNumItems.HasValue)
{
// First request value groups. That is a performance consideration:
// If we have many items, we need groups. If we have few items, we don't need the groups but simply do a search.
// We request the groups first to make it faster for the many items case. In the case of few items, both groups and items
// are requested which doesn't take so long because there are only few items.
IList <MLQueryResultGroup> groups = await cd.GroupValueGroupsAsync(MediaAspect.ATTR_TITLE, null, ProjectionFunction.None,
_query.NecessaryRequestedMIATypeIDs, _query.Filter, _onlyOnline, GroupingFunction.FirstCharacter, showVirtual);
long numItems = groups.Aggregate <MLQueryResultGroup, long>(0, (current, group) => current + group.NumItemsInGroup);
if (numItems > MaxNumItems.Value)
{ // Group items
mediaItems = new List <MediaItem>(0);
subViewSpecifications = new List <ViewSpecification>(groups.Count);
foreach (MLQueryResultGroup group in groups)
{
MediaLibraryQueryViewSpecification subViewSpecification =
CreateSubViewSpecification(string.Format("{0}", group.GroupKey), _filterPath, group.AdditionalFilter, null);
subViewSpecification.MaxNumItems = null;
subViewSpecification._absNumItems = group.NumItemsInGroup;
subViewSpecifications.Add(subViewSpecification);
}
return(new Tuple <IList <MediaItem>, IList <ViewSpecification> >(mediaItems, subViewSpecifications));
}
// Else: No grouping
}
// Else: No grouping
mediaItems = await cd.SearchAsync(_query, _onlyOnline, userProfile, showVirtual);
CertificationHelper.ConvertCertifications(mediaItems);
subViewSpecifications = new List <ViewSpecification>(0);
return(new Tuple <IList <MediaItem>, IList <ViewSpecification> >(mediaItems, subViewSpecifications));
}
catch (UPnPRemoteException e)
{
ServiceRegistration.Get <ILogger>().Error("SimpleTextSearchViewSpecification.ReLoadItemsAndSubViewSpecifications: Error requesting server", e);
return(new Tuple <IList <MediaItem>, IList <ViewSpecification> >(null, null));
}
}
