internal static Task <IList <MediaItem> > GetTrackByAlbumTrackAsync(Guid?userId, Guid albumId, int discNo, int trackNo)
{
IFilter filter = new RelationalFilter(AudioAspect.ATTR_DISCID, RelationalOperator.EQ, discNo);
filter = BooleanCombinationFilter.CombineFilters(BooleanOperator.And, filter, new RelationalFilter(AudioAspect.ATTR_TRACK, RelationalOperator.EQ, trackNo));
return(GetTracksAsync(userId, albumId, filter));
}
public static CompiledGroupedAttributeValueQuery Compile(MIA_Management miaManagement,
IEnumerable <Guid> necessaryRequestedMIATypeIDs,
MediaItemAspectMetadata.AttributeSpecification selectAttribute, IAttributeFilter selectAttributeFilter,
SelectProjectionFunction selectProjectionFunction, Type projectionValueType, IFilter filter)
{
IDictionary <Guid, MediaItemAspectMetadata> availableMIATypes = miaManagement.ManagedMediaItemAspectTypes;
// If we're doing a complex query, we can optimize if we have an extra select attribute filter, i.e. a restriction
// on the result set of values. See ComplexAttributeQueryBuilder.GenerateSqlGroupByStatement().
bool simpleQuery = selectAttribute.Cardinality == Cardinality.Inline || selectAttribute.Cardinality == Cardinality.ManyToOne;
IFilter combinedFilter = simpleQuery ?
BooleanCombinationFilter.CombineFilters(BooleanOperator.And, new IFilter[] { filter, selectAttributeFilter }) : filter;
selectAttributeFilter = simpleQuery ? null : selectAttributeFilter;
ICollection <MediaItemAspectMetadata> necessaryMIATypes = new List <MediaItemAspectMetadata>();
// Raise exception if necessary MIA types are not present
foreach (Guid miaTypeID in necessaryRequestedMIATypeIDs)
{
MediaItemAspectMetadata miam;
if (!availableMIATypes.TryGetValue(miaTypeID, out miam))
{
throw new InvalidDataException("Necessary requested MIA type of ID '{0}' is not present in the media library", miaTypeID);
}
necessaryMIATypes.Add(miam);
}
return(new CompiledGroupedAttributeValueQuery(miaManagement, necessaryMIATypes, selectAttribute, selectAttributeFilter,
selectProjectionFunction, projectionValueType, combinedFilter));
}
public override ICollection <FilterValue> GetAvailableValues(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 = BooleanCombinationFilter.CombineFilters(BooleanOperator.Or,
new EmptyUserDataFilter(userProfileDataManagement.CurrentUser.ProfileId, UserDataKeysKnown.KEY_PLAY_COUNT),
new RelationalUserDataFilter(userProfileDataManagement.CurrentUser.ProfileId, UserDataKeysKnown.KEY_PLAY_COUNT, RelationalOperator.EQ, "0"));
IFilter watchedFilter = new RelationalUserDataFilter(userProfileDataManagement.CurrentUser.ProfileId, UserDataKeysKnown.KEY_PLAY_COUNT, RelationalOperator.GT, "0");
int numUnwatchedItems = cd.CountMediaItems(necessaryMIATypeIds, BooleanCombinationFilter.CombineFilters(BooleanOperator.And, filter, unwatchedFilter), true, ShowVirtualSetting.ShowVirtualMedia(necessaryMIATypeIds));
int numWatchedItems = cd.CountMediaItems(necessaryMIATypeIds, BooleanCombinationFilter.CombineFilters(BooleanOperator.And, filter, watchedFilter), true, ShowVirtualSetting.ShowVirtualMedia(necessaryMIATypeIds));
return(new List <FilterValue>(new FilterValue[]
{
new FilterValue(Consts.RES_VALUE_UNWATCHED, unwatchedFilter, null, numUnwatchedItems, this),
new FilterValue(Consts.RES_VALUE_WATCHED, watchedFilter, null, numWatchedItems, this),
}.Where(fv => !fv.NumItems.HasValue || fv.NumItems.Value > 0)));
}
internal static WebTVSeasonBasic TVSeasonBasic(IOwinContext context, MediaItem item, Guid?showId = null)
{
Guid? user = ResourceAccessUtils.GetUser(context);
ISet <Guid> necessaryMIATypespisodes = new HashSet <Guid>();
necessaryMIATypespisodes.Add(MediaAspect.ASPECT_ID);
necessaryMIATypespisodes.Add(EpisodeAspect.ASPECT_ID);
IFilter unwatchedEpisodeFilter = BooleanCombinationFilter.CombineFilters(BooleanOperator.And,
new RelationshipFilter(EpisodeAspect.ROLE_EPISODE, SeasonAspect.ROLE_SEASON, item.MediaItemId),
new RelationalUserDataFilter(user.Value, UserDataKeysKnown.KEY_PLAY_PERCENTAGE, RelationalOperator.LT, UserDataKeysKnown.GetSortablePlayPercentageString(100), true));
int unwatchedCount = MediaLibraryAccess.CountMediaItems(context, necessaryMIATypespisodes, unwatchedEpisodeFilter);
GetShowId(item, ref showId);
var mediaAspect = item.GetAspect(MediaAspect.Metadata);
var seasonAspect = item.GetAspect(SeasonAspect.Metadata);
var importerAspect = item.GetAspect(ImporterAspect.Metadata);
DateTime?firstAired = mediaAspect.GetAttributeValue <DateTime?>(MediaAspect.ATTR_RECORDINGTIME);
return(new WebTVSeasonBasic
{
Title = mediaAspect.GetAttributeValue <string>(MediaAspect.ATTR_TITLE),
Id = item.MediaItemId.ToString(),
ShowId = showId.HasValue ? showId.Value.ToString() : null,
SeasonNumber = seasonAspect.GetAttributeValue <int>(SeasonAspect.ATTR_SEASON),
EpisodeCount = seasonAspect.GetAttributeValue <int>(SeasonAspect.ATTR_AVAILABLE_EPISODES),
UnwatchedEpisodeCount = unwatchedCount,
DateAdded = importerAspect.GetAttributeValue <DateTime>(ImporterAspect.ATTR_DATEADDED),
Year = firstAired.HasValue ? firstAired.Value.Year : 0,
});
}
protected override async Task <MediaItemQuery> CreateQueryAsync()
{
Guid? userProfile = CurrentUserProfile?.ProfileId;
IFilter linkedFilter = userProfile.HasValue ? BooleanCombinationFilter.CombineFilters(BooleanOperator.And,
new NotFilter(new EmptyUserDataFilter(userProfile.Value, UserDataKeysKnown.KEY_PLAY_COUNT)),
new RelationalUserDataFilter(userProfile.Value, UserDataKeysKnown.KEY_PLAY_COUNT, RelationalOperator.GT, UserDataKeysKnown.GetSortablePlayCountString(0))) :
null;
IFilter filter = userProfile.HasValue ? BooleanCombinationFilter.CombineFilters(BooleanOperator.And,
new FilteredRelationshipFilter(_role, _linkedRole, await AppendUserFilterAsync(linkedFilter, _necessaryLinkedMias)),
new NotFilter(new EmptyUserDataFilter(userProfile.Value, UserDataKeysKnown.KEY_PLAY_MAX_CHILD_COUNT))) :
new RelationalFilter(MediaAspect.ATTR_PLAYCOUNT, RelationalOperator.GT, 0);
List <ISortInformation> sort = userProfile.HasValue ? new List <ISortInformation>
{
new DataSortInformation(UserDataKeysKnown.KEY_PLAY_MAX_CHILD_COUNT, SortDirection.Descending),
new DataSortInformation(UserDataKeysKnown.KEY_PLAY_COUNT, SortDirection.Descending),
new DataSortInformation(UserDataKeysKnown.KEY_PLAY_DATE, SortDirection.Descending)
} :
new List <ISortInformation>
{
new AttributeSortInformation(MediaAspect.ATTR_PLAYCOUNT, SortDirection.Descending),
new AttributeSortInformation(MediaAspect.ATTR_LASTPLAYED, SortDirection.Descending)
};
return(new MediaItemQuery(_necessaryMias, _optionalMias, filter)
{
SubqueryFilter = GetNavigationFilter(_navigationInitializerType),
SortInformation = sort
});
}
public IFilter GetSearchFilter(IDictionary <Guid, IList <MediaItemAspect> > extractedAspects)
{
List <IFilter> searchFilters = new List <IFilter>();
IList <MultipleMediaItemAspect> externalAspects;
if (MediaItemAspect.TryGetAspects(extractedAspects, ExternalIdentifierAspect.Metadata, out externalAspects))
{
foreach (MultipleMediaItemAspect externalAspect in externalAspects)
{
string source = externalAspect.GetAttributeValue <string>(ExternalIdentifierAspect.ATTR_SOURCE);
string type = externalAspect.GetAttributeValue <string>(ExternalIdentifierAspect.ATTR_TYPE);
string id = externalAspect.GetAttributeValue <string>(ExternalIdentifierAspect.ATTR_ID);
if (searchFilters.Count == 0)
{
searchFilters.Add(new BooleanCombinationFilter(BooleanOperator.And, new[]
{
new RelationalFilter(ExternalIdentifierAspect.ATTR_SOURCE, RelationalOperator.EQ, source),
new RelationalFilter(ExternalIdentifierAspect.ATTR_TYPE, RelationalOperator.EQ, type),
new RelationalFilter(ExternalIdentifierAspect.ATTR_ID, RelationalOperator.EQ, id),
}));
}
else
{
searchFilters[0] = BooleanCombinationFilter.CombineFilters(BooleanOperator.Or, searchFilters[0],
new BooleanCombinationFilter(BooleanOperator.And, new[]
{
new RelationalFilter(ExternalIdentifierAspect.ATTR_SOURCE, RelationalOperator.EQ, source),
new RelationalFilter(ExternalIdentifierAspect.ATTR_TYPE, RelationalOperator.EQ, type),
new RelationalFilter(ExternalIdentifierAspect.ATTR_ID, RelationalOperator.EQ, id),
}));
}
}
}
return(BooleanCombinationFilter.CombineFilters(BooleanOperator.Or, searchFilters.ToArray()));
}
public IFilter GetSearchFilter(IDictionary <Guid, IList <MediaItemAspect> > extractedAspects)
{
SingleMediaItemAspect seasonAspect;
if (!MediaItemAspect.TryGetAspect(extractedAspects, SeasonAspect.Metadata, out seasonAspect))
{
return(null);
}
IFilter seasonFilter = RelationshipExtractorUtils.CreateExternalItemFilter(extractedAspects, ExternalIdentifierAspect.TYPE_SEASON);
IFilter seriesFilter = RelationshipExtractorUtils.CreateExternalItemFilter(extractedAspects, ExternalIdentifierAspect.TYPE_SERIES);
if (seriesFilter == null)
{
return(seasonFilter);
}
int? seasonNumber = seasonAspect.GetAttributeValue <int?>(SeasonAspect.ATTR_SEASON);
IFilter seasonNumberFilter = seasonNumber.HasValue ?
new RelationalFilter(SeasonAspect.ATTR_SEASON, RelationalOperator.EQ, seasonNumber.Value) : null;
seriesFilter = BooleanCombinationFilter.CombineFilters(BooleanOperator.And, seriesFilter, seasonNumberFilter);
return(BooleanCombinationFilter.CombineFilters(BooleanOperator.Or, seasonFilter, seriesFilter));
}
public static IFilter GetEpisodeSearchFilter(IDictionary <Guid, IList <MediaItemAspect> > extractedAspects)
{
SingleMediaItemAspect episodeAspect;
if (!MediaItemAspect.TryGetAspect(extractedAspects, EpisodeAspect.Metadata, out episodeAspect))
{
return(null);
}
IFilter episodeFilter = RelationshipExtractorUtils.CreateExternalItemFilter(extractedAspects, ExternalIdentifierAspect.TYPE_EPISODE);
IFilter seriesFilter = RelationshipExtractorUtils.CreateExternalItemFilter(extractedAspects, ExternalIdentifierAspect.TYPE_SERIES);
if (seriesFilter == null)
{
return(episodeFilter);
}
int? seasonNumber = episodeAspect.GetAttributeValue <int?>(EpisodeAspect.ATTR_SEASON);
IFilter seasonNumberFilter = seasonNumber.HasValue ?
new RelationalFilter(EpisodeAspect.ATTR_SEASON, RelationalOperator.EQ, seasonNumber.Value) : null;
IEnumerable <int> episodeNumbers = episodeAspect.GetCollectionAttribute <int>(EpisodeAspect.ATTR_EPISODE);
IFilter episodeNumberFilter = episodeNumbers != null && episodeNumbers.Any() ?
new RelationalFilter(EpisodeAspect.ATTR_EPISODE, RelationalOperator.EQ, episodeNumbers.First()) : null;
seriesFilter = BooleanCombinationFilter.CombineFilters(BooleanOperator.And, seriesFilter, seasonNumberFilter, episodeNumberFilter);
return(BooleanCombinationFilter.CombineFilters(BooleanOperator.Or, episodeFilter, seriesFilter));
}
public MediaLibraryQueryViewSpecification CreateSubViewSpecification(string viewDisplayName, IFilter filter, IEnumerable <Guid> filteredMias)
{
IFilter combinedFilter;
if (_filter == null || !CanCombineFilters(filteredMias))
{
combinedFilter = filter;
}
else
{
if (filter is AbstractRelationshipFilter)
{
//TODO: Check why reversing the filter order is necessary for RelationshipFilters
combinedFilter = BooleanCombinationFilter.CombineFilters(BooleanOperator.And, new IFilter[] { filter, _filter });
}
else
{
combinedFilter = BooleanCombinationFilter.CombineFilters(BooleanOperator.And, new IFilter[] { _filter, filter });
}
}
return(new MediaLibraryQueryViewSpecification(viewDisplayName, combinedFilter, _necessaryMIATypeIds, _optionalMIATypeIds, _onlyOnline, filteredMias)
{
MaxNumItems = _maxNumItems
});
}
protected override async Task <MediaItemQuery> CreateQueryAsync()
{
Guid? userProfile = CurrentUserProfile?.ProfileId;
IFilter filter = userProfile.HasValue ? await AppendUserFilterAsync(new NotFilter(new EmptyUserDataFilter(userProfile.Value, UserDataKeysKnown.KEY_PLAY_COUNT)),
_necessaryMias) : new RelationalFilter(MediaAspect.ATTR_PLAYCOUNT, RelationalOperator.GT, 0);
IFilter navigationFilter = GetNavigationFilter(_navigationInitializerType);
if (navigationFilter != null)
{
filter = BooleanCombinationFilter.CombineFilters(BooleanOperator.And, filter, navigationFilter);
}
List <ISortInformation> sort = userProfile.HasValue ? new List <ISortInformation>
{
new DataSortInformation(UserDataKeysKnown.KEY_PLAY_COUNT, SortDirection.Descending),
new DataSortInformation(UserDataKeysKnown.KEY_PLAY_DATE, SortDirection.Descending)
} :
new List <ISortInformation>
{
new AttributeSortInformation(MediaAspect.ATTR_PLAYCOUNT, SortDirection.Descending),
new AttributeSortInformation(MediaAspect.ATTR_LASTPLAYED, SortDirection.Descending)
};
return(new MediaItemQuery(_necessaryMias, _optionalMias, filter)
{
SortInformation = sort
});
}
protected override async Task <MediaItemQuery> CreateQueryAsync()
{
Guid? userProfile = CurrentUserProfile?.ProfileId;
IFilter filter;
if (userProfile.HasValue)
{
filter = await AppendUserFilterAsync(
new RelationalUserDataFilter(userProfile.Value, UserDataKeysKnown.KEY_PLAY_PERCENTAGE, RelationalOperator.EQ, UserDataKeysKnown.GetSortablePlayPercentageString(0), true), _necessaryMias);
}
else
{
filter = new RelationalFilter(MediaAspect.ATTR_PLAYCOUNT, RelationalOperator.EQ, 0);
}
IFilter navigationFilter = GetNavigationFilter(_navigationInitializerType);
if (navigationFilter != null)
{
filter = BooleanCombinationFilter.CombineFilters(BooleanOperator.And, filter, navigationFilter);
}
return(new MediaItemQuery(_necessaryMias, _optionalMias, filter)
{
SortInformation = new List <ISortInformation> {
new AttributeSortInformation(ImporterAspect.ATTR_DATEADDED, SortDirection.Ascending)
}
});
}
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)));
}
public static IFilter GetUserRestrictionFilter(ICollection <Guid> necessaryMias, UserProfile userProfile, IFilter filter = null)
{
var check = CheckUserRestrictions();
if (!check.ApplyUserRestrictions)
{
return(filter);
}
//ILogger logger = ServiceRegistration.Get<ILogger>(false);
//logger?.Debug($"Media: Applying filter for user: {userProfile.Name} ({userProfile.ProfileId})");
var userFilter = userProfile.GetUserFilter(necessaryMias);
if (userFilter != null && filter != null)
{
return(BooleanCombinationFilter.CombineFilters(BooleanOperator.And, filter, userFilter));
}
else if (userFilter != null)
{
return(userFilter);
}
return(filter);
}
public IFilter GetSearchFilter(IDictionary <Guid, IList <MediaItemAspect> > extractedAspects)
{
SingleMediaItemAspect audioAspect;
if (!MediaItemAspect.TryGetAspect(extractedAspects, AudioAspect.Metadata, out audioAspect))
{
return(null);
}
IFilter trackFilter = RelationshipExtractorUtils.CreateExternalItemFilter(extractedAspects, ExternalIdentifierAspect.TYPE_TRACK);
IFilter albumFilter = RelationshipExtractorUtils.CreateExternalItemFilter(extractedAspects, ExternalIdentifierAspect.TYPE_ALBUM);
if (albumFilter == null)
{
return(trackFilter);
}
int?trackNumber = audioAspect.GetAttributeValue <int?>(AudioAspect.ATTR_TRACK);
if (trackNumber.HasValue)
{
albumFilter = BooleanCombinationFilter.CombineFilters(BooleanOperator.And, albumFilter,
new RelationalFilter(AudioAspect.ATTR_TRACK, RelationalOperator.EQ, trackNumber.Value));
}
return(BooleanCombinationFilter.CombineFilters(BooleanOperator.Or, trackFilter, albumFilter));
}
internal static async Task <MediaItem> GetEpisodeBySeriesEpisodeAsync(Guid?userId, Guid seriesId, int seasonNo, int episodeNo)
{
IFilter filter = new RelationalFilter(EpisodeAspect.ATTR_SEASON, RelationalOperator.EQ, seasonNo);
filter = BooleanCombinationFilter.CombineFilters(BooleanOperator.And, filter, new InFilter(EpisodeAspect.ATTR_EPISODE, new object[] { episodeNo }));
var items = await GetEpisodesAsync(userId, seriesId, filter);
return(items.FirstOrDefault());
}
public MediaLibraryQueryViewSpecification CreateSubViewSpecification(string viewDisplayName, IFilter filter)
{
IFilter combinedFilter = _filter == null ? filter : BooleanCombinationFilter.CombineFilters(BooleanOperator.And, new IFilter[] { _filter, filter });
return(new MediaLibraryQueryViewSpecification(viewDisplayName, combinedFilter, _necessaryMIATypeIds, _optionalMIATypeIds, _onlyOnline)
{
MaxNumItems = _maxNumItems
});
}
public void TestFilteredRelationshipQueryBuilder()
{
// Use the real RelationshipFilter because CompiledFilter is hard coded to look for it
MockCore.AddMediaItemAspectStorage(RelationshipAspect.Metadata);
SingleTestMIA mia1 = TestBackendUtils.CreateSingleMIA("Meta1", Cardinality.Inline, true, true);
SingleTestMIA mia2 = TestBackendUtils.CreateSingleMIA("Meta2", Cardinality.Inline, true, true);
SingleTestMIA mia3 = TestBackendUtils.CreateSingleMIA("Meta3", Cardinality.Inline, true, true);
ICollection <MediaItemAspectMetadata> requiredMIATypes = new List <MediaItemAspectMetadata>();
requiredMIATypes.Add(mia1.Metadata);
requiredMIATypes.Add(mia2.Metadata);
IFilter linkedMovieFilter = BooleanCombinationFilter.CombineFilters(
BooleanOperator.And,
new RelationalFilter(mia3.ATTR_INTEGER, RelationalOperator.EQ, 1),
new RelationalFilter(mia3.ATTR_STRING, RelationalOperator.EQ, "test"));
Guid movieType = new Guid("bbbbbbbb-2222-2222-2222-bbbbbbbbbbbb");
Guid actorType = new Guid("cccccccc-3333-3333-3333-cccccccccccc");
IFilter filter = new FilteredRelationshipFilter(actorType, movieType, linkedMovieFilter);
MIAQueryBuilder builder = new MIAQueryBuilder(MockCore.Management, new List <QueryAttribute>(), null, requiredMIATypes, new List <MediaItemAspectMetadata>(), filter, null, null);
string mediaItemIdAlias = null;
IDictionary <MediaItemAspectMetadata, string> miamAliases = null;
IDictionary <QueryAttribute, string> attributeAliases = null;
string statementStr = null;
IList <BindVar> bindVars = null;
builder.GenerateSqlStatement(out mediaItemIdAlias, out miamAliases, out attributeAliases, out statementStr, out bindVars);
Console.WriteLine("mediaItemIdAlias: {0}", mediaItemIdAlias);
Console.WriteLine("miamAliases: [{0}]", string.Join(",", miamAliases));
Console.WriteLine("attributeAliases: [{0}]", string.Join(",", attributeAliases));
Console.WriteLine("statementStr: {0}", statementStr);
Console.WriteLine("bindVars: [{0}]", string.Join(",", bindVars));
Assert.AreEqual("A0", mediaItemIdAlias, "Media item ID alias");
Assert.AreEqual(CreateMIAMAliases(mia1.Metadata, "A1", mia2.Metadata, "A2"), miamAliases, "MIAM aliases");
Assert.AreEqual(new Dictionary <QueryAttribute, string>(), attributeAliases, "Attribute aliases");
Assert.AreEqual("SELECT T0.MEDIA_ITEM_ID A0, T0.MEDIA_ITEM_ID A1, T1.MEDIA_ITEM_ID A2 FROM M_META1 T0 INNER JOIN M_META2 T1 ON T1.MEDIA_ITEM_ID = T0.MEDIA_ITEM_ID " +
" WHERE T0.MEDIA_ITEM_ID IN(SELECT R1.MEDIA_ITEM_ID FROM M_RELATIONSHIP R1 WHERE R1.ROLE=@V0 AND R1.LINKEDROLE=@V1 AND R1.LINKEDID IN( " +
"SELECT TS.A0 FROM (SELECT T0.MEDIA_ITEM_ID A0, T1.MEDIA_ITEM_ID A1 FROM MEDIA_ITEMS T0 LEFT OUTER JOIN M_META3 T1 ON T0.MEDIA_ITEM_ID = T1.MEDIA_ITEM_ID " +
" WHERE (T1.ATTR_INTEGER = @V2 AND T1.ATTR_STRING = @V3)) TS) " +
"UNION SELECT R1.LINKEDID FROM M_RELATIONSHIP R1 WHERE R1.LINKEDROLE=@V0 AND R1.ROLE=@V1 AND R1.MEDIA_ITEM_ID IN( SELECT TS.A0 FROM (" +
"SELECT T0.MEDIA_ITEM_ID A0, T1.MEDIA_ITEM_ID A1 FROM MEDIA_ITEMS T0 LEFT OUTER JOIN M_META3 T1 ON T0.MEDIA_ITEM_ID = T1.MEDIA_ITEM_ID " +
" WHERE (T1.ATTR_INTEGER = @V2 AND T1.ATTR_STRING = @V3)) TS))", statementStr, "Statement");
Assert.AreEqual(new List <BindVar>
{
new BindVar("V0", actorType, typeof(Guid)),
new BindVar("V1", movieType, typeof(Guid)),
new BindVar("V2", 1, typeof(int)),
new BindVar("V3", "test", typeof(string))
}, bindVars, "Bind vars");
}
public async Task <IFilter> AppendUserFilterAsync(IFilter filter, IEnumerable <Guid> filterMias)
{
IFilter userFilter = await CertificationHelper.GetUserCertificateFilter(filterMias);
if (userFilter != null)
{
return(filter != null?BooleanCombinationFilter.CombineFilters(BooleanOperator.And, filter, userFilter) : userFilter);
}
return(filter);
}
public IFilter GetSearchFilter(IDictionary <Guid, IList <MediaItemAspect> > extractedAspects)
{
if (!extractedAspects.ContainsKey(CharacterAspect.ASPECT_ID))
{
return(null);
}
return(BooleanCombinationFilter.CombineFilters(BooleanOperator.Or,
RelationshipExtractorUtils.CreateExternalItemFilter(extractedAspects, ExternalIdentifierAspect.TYPE_CHARACTER),
RelationshipExtractorUtils.CreateExternalItemFilter(extractedAspects, ExternalIdentifierAspect.TYPE_PERSON)));
}
/// <summary>
/// Combines the <paramref name="currentFilter"/> with a <see cref="FilteredRelationshipFilter"/> with
/// the specified <paramref name="role"/>, <paramref name="linkedRole"/> and <paramref name="subFilter"/>.
/// </summary>
/// <param name="currentFilter">The filter to combine.</param>
/// <param name="role">The role to use for the <see cref="RelationshipFilter"/>.</param>
/// <param name="linkedRole">The linked role to use for the <see cref="RelationshipFilter"/>.</param>
/// <param name="subFilter">The filter to use for the <see cref="RelationshipFilter"/>.</param>
/// <param name="ignoreNullSubFilter">Whether to not combine the filters if <paramref name="subFilter"/> is <c>null</c>.</param>
/// <returns></returns>
protected static IFilter CombineWithFilteredRelationship(IFilter currentFilter, Guid role, Guid linkedRole, IFilter subFilter, bool ignoreNullSubFilter)
{
if (subFilter == null && ignoreNullSubFilter)
{
return(currentFilter);
}
IFilter filteredRelationship = new FilteredRelationshipFilter(role, linkedRole, subFilter);
return(BooleanCombinationFilter.CombineFilters(BooleanOperator.And, currentFilter, filteredRelationship));
}
public MediaLibraryUnwatchedContainer(string id, Guid[] necessaryMiaTypeIds, Guid[] optionalMiaTypeIds, EndPointSettings client)
: base(id, "Unwatched", necessaryMiaTypeIds, optionalMiaTypeIds, null, client)
{
_filter = BooleanCombinationFilter.CombineFilters(BooleanOperator.Or,
new EmptyUserDataFilter(UserId, UserDataKeysKnown.KEY_PLAY_COUNT),
new RelationalUserDataFilter(UserId, UserDataKeysKnown.KEY_PLAY_COUNT, RelationalOperator.EQ, "0"));
_queryLimit = 10;
_sortInformation = new List <ISortInformation> {
new AttributeSortInformation(ImporterAspect.ATTR_DATEADDED, SortDirection.Descending)
};
}
protected void CombineFilter(IFilter filter)
{
if (_filter == null)
{
_filter = filter;
}
else
{
_filter = BooleanCombinationFilter.CombineFilters(BooleanOperator.And, _filter, filter);
}
}
protected IFilter CreateSubQueryFilter()
{
if (_subqueryFilter == null)
{
return(_filter);
}
if (_filter == null)
{
return(_subqueryFilter);
}
return(BooleanCombinationFilter.CombineFilters(BooleanOperator.And, _filter, _subqueryFilter));
}
private static Task <IList <MediaItem> > SearchByGroupAsync(Guid?userId, Guid itemRole, Guid groupRole, Guid groupId, ISet <Guid> necessaryMIATypes, ISet <Guid> optionalMIATypes, IFilter filter = null, uint?limit = null, uint?offset = null, IList <ISortInformation> sort = null)
{
if (filter != null)
{
filter = BooleanCombinationFilter.CombineFilters(BooleanOperator.And, filter, new RelationshipFilter(itemRole, groupRole, groupId));
}
else
{
filter = new RelationshipFilter(itemRole, groupRole, groupId);
}
return(SearchAsync(userId, necessaryMIATypes, optionalMIATypes, filter, limit, offset, sort));
}
public IFilter AppendUserFilter(IFilter filter, ICollection <Guid> necessaryMias)
{
IFilter userFilter = null;
IUserProfileDataManagement userProfileDataManagement = ServiceRegistration.Get <IUserProfileDataManagement>();
var res = userProfileDataManagement.GetProfileAsync(UserId).Result;
if (res.Success)
{
userFilter = res.Result.GetUserFilter(necessaryMias);
}
return(filter == null ? userFilter : userFilter != null?BooleanCombinationFilter.CombineFilters(BooleanOperator.And, filter, userFilter) : filter);
}
internal static IFilter AppendUserFilter(Guid?userId, IFilter filter, ICollection <Guid> filterMias)
{
IFilter userFilter = null;
if (userId.HasValue)
{
IUserProfileDataManagement userProfileDataManagement = ServiceRegistration.Get <IUserProfileDataManagement>();
var res = userProfileDataManagement.GetProfileAsync(userId.Value).Result;
if (res.Success)
{
userFilter = res.Result.GetUserFilter(filterMias);
}
}
return(filter == null ? userFilter : userFilter != null?BooleanCombinationFilter.CombineFilters(BooleanOperator.And, filter, userFilter) : filter);
}
/// <summary>
/// Gets a <see cref="BooleanCombinationFilter"/> of all filters provided by plugins that are applied to media view initialized
/// by the specified <paramref name="navigationInitializerType"/>.
/// </summary>
/// <param name="navigationInitializerType">The type of the derived <see cref="MediaPortal.UiComponents.Media.Models.NavigationModel.IMediaNavigationInitializer"/></param>
/// <returns></returns>
protected IFilter GetNavigationFilter(Type navigationInitializerType)
{
if (navigationInitializerType != null)
{
lock (_navigationFilterSync)
{
InitNavigationFilters();
if (_navigationFilters.TryGetValue(navigationInitializerType.Name, out IList <IFilter> filters) && filters.Count > 0)
{
return(filters.Count == 1 ? filters[0] : BooleanCombinationFilter.CombineFilters(BooleanOperator.And, filters));
}
}
}
return(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)));
}
protected override async Task <MediaItemQuery> CreateQueryAsync()
{
Guid?userProfile = CurrentUserProfile?.ProfileId;
return(new MediaItemQuery(_necessaryMias, _optionalMias, null)
{
Filter = userProfile.HasValue ? new FilteredRelationshipFilter(_role, _linkedRole, await AppendUserFilterAsync(
BooleanCombinationFilter.CombineFilters(BooleanOperator.And,
new NotFilter(new EmptyUserDataFilter(userProfile.Value, UserDataKeysKnown.KEY_PLAY_DATE)),
new RelationalUserDataFilter(userProfile.Value, UserDataKeysKnown.KEY_PLAY_PERCENTAGE, RelationalOperator.LT, UserDataKeysKnown.GetSortablePlayPercentageString(100)),
new RelationalUserDataFilter(userProfile.Value, UserDataKeysKnown.KEY_PLAY_PERCENTAGE, RelationalOperator.GT, UserDataKeysKnown.GetSortablePlayPercentageString(0))),
_necessaryLinkedMias)) : null,
SubqueryFilter = GetNavigationFilter(_navigationInitializerType),
SortInformation = new List <ISortInformation> {
new DataSortInformation(UserDataKeysKnown.KEY_PLAY_DATE, SortDirection.Descending)
}
});
}
public static IFilter GetMovieCollectionSearchFilter(IDictionary <Guid, IList <MediaItemAspect> > extractedAspects)
{
List <IFilter> movieCollectionFilters = new List <IFilter>();
if (!extractedAspects.ContainsKey(MovieCollectionAspect.ASPECT_ID))
{
return(null);
}
IList <MultipleMediaItemAspect> externalAspects;
if (MediaItemAspect.TryGetAspects(extractedAspects, ExternalIdentifierAspect.Metadata, out externalAspects))
{
foreach (MultipleMediaItemAspect externalAspect in externalAspects)
{
string source = externalAspect.GetAttributeValue <string>(ExternalIdentifierAspect.ATTR_SOURCE);
string type = externalAspect.GetAttributeValue <string>(ExternalIdentifierAspect.ATTR_TYPE);
string id = externalAspect.GetAttributeValue <string>(ExternalIdentifierAspect.ATTR_ID);
if (type == ExternalIdentifierAspect.TYPE_COLLECTION)
{
if (movieCollectionFilters.Count == 0)
{
movieCollectionFilters.Add(new BooleanCombinationFilter(BooleanOperator.And, new[]
{
new RelationalFilter(ExternalIdentifierAspect.ATTR_SOURCE, RelationalOperator.EQ, source),
new RelationalFilter(ExternalIdentifierAspect.ATTR_TYPE, RelationalOperator.EQ, type),
new RelationalFilter(ExternalIdentifierAspect.ATTR_ID, RelationalOperator.EQ, id),
}));
}
else
{
movieCollectionFilters[0] = BooleanCombinationFilter.CombineFilters(BooleanOperator.Or, movieCollectionFilters[0],
new BooleanCombinationFilter(BooleanOperator.And, new[]
{
new RelationalFilter(ExternalIdentifierAspect.ATTR_SOURCE, RelationalOperator.EQ, source),
new RelationalFilter(ExternalIdentifierAspect.ATTR_TYPE, RelationalOperator.EQ, type),
new RelationalFilter(ExternalIdentifierAspect.ATTR_ID, RelationalOperator.EQ, id),
}));
}
}
}
}
return(BooleanCombinationFilter.CombineFilters(BooleanOperator.Or, movieCollectionFilters.ToArray()));
}
