public static string ToJsonModel(LogicalGrouping logicalGrouping)
{
switch (logicalGrouping)
{
case LogicalGrouping.MatchAll:
return("match_all");
case LogicalGrouping.MatchAny:
return("match_any");
default:
throw new ArgumentException(nameof(logicalGrouping));
}
}
public PartialFindResult <RatedSongForUserForApiContract> GetRatedSongs(
int id,
string query = "",
string tagName = null,
[FromUri] int[] tagId = null,
[FromUri] int[] artistId = null,
bool childVoicebanks = false,
LogicalGrouping artistGrouping = LogicalGrouping.And,
SongVoteRating?rating = null,
int?songListId = null,
bool groupByRating = true,
[FromUri] PVServices?pvServices = null,
[FromUri] AdvancedSearchFilter[] advancedFilters = null,
int start = 0, int maxResults = defaultMax, bool getTotalCount = false,
RatedSongForUserSortRule?sort = null,
NameMatchMode nameMatchMode = NameMatchMode.Auto,
SongOptionalFields fields = SongOptionalFields.None,
ContentLanguagePreference lang = ContentLanguagePreference.Default)
{
maxResults = Math.Min(maxResults, absoluteMax);
var textQuery = SearchTextQuery.Create(query, nameMatchMode);
var queryParams = new RatedSongQueryParams(id, new PagingProperties(start, maxResults, getTotalCount))
{
TextQuery = textQuery,
SortRule = sort ?? RatedSongForUserSortRule.Name,
ArtistIds = artistId,
ArtistGrouping = artistGrouping,
ChildVoicebanks = childVoicebanks,
FilterByRating = rating ?? SongVoteRating.Nothing,
GroupByRating = groupByRating,
PVServices = pvServices,
SonglistId = songListId ?? 0,
TagIds = tagId,
TagName = tagName,
AdvancedFilters = advancedFilters
};
var songs = queries.GetRatedSongs(queryParams, ratedSong => new RatedSongForUserForApiContract(ratedSong, lang, fields));
return(songs);
}
/// <summary>
/// Gets the conditions.
/// </summary>
/// <param name="conditionsElement">The conditions element.</param>
/// <returns></returns>
private IEnumerable <ICondition> GetConditions(XmlNode conditionsElement)
{
LogicalGrouping logicalGrouping = LogicalGrouping.MatchAll; // from schema definition
bool trackAllCaptures = false; // from schema definition
if (conditionsElement.Attributes["logicalGrouping"] != null)
{
try { logicalGrouping = (LogicalGrouping)Enum.Parse(typeof(LogicalGrouping), conditionsElement.Attributes["logicalGrouping"].Value, true); }
catch (Exception exc) { Manager.Log("Condition: " + exc.Message, "Error"); }
}
if (conditionsElement.Attributes["trackAllCaptures"] != null)
{
trackAllCaptures = XmlConvert.ToBoolean(conditionsElement.Attributes["trackAllCaptures"].Value);
}
// process each condition
foreach (XmlNode conditionElement in conditionsElement.SelectNodes("add"))
{
yield return(GetCondition(conditionElement, logicalGrouping));
}
}
public void ConfigureConditionBehavior(LogicalGrouping logicalGrouping, bool trackAllCaptures)
{
_conditions = new ConditionCollection(logicalGrouping, trackAllCaptures);
}
public ConditionCollection(LogicalGrouping grouping, bool trackAllCaptures)
{
Grouping = grouping;
TrackAllCaptures = trackAllCaptures;
}
public static IQueryable <T> WhereSongHasArtists <T>(this IQueryable <T> query, EntryIdsCollection artistIds, bool childVoicebanks, LogicalGrouping grouping)
where T : ISongLink
{
return(grouping == LogicalGrouping.And ? WhereSongHasArtists(query, artistIds, childVoicebanks) : WhereSongHasAnyArtist(query, artistIds, childVoicebanks));
}
/// <summary>
/// Gets the condition.
/// </summary>
/// <param name="conditionElement">The condition element.</param>
/// <param name="matchAll">if set to <see langword="true"/> [match all].</param>
/// <returns></returns>
private ICondition GetCondition(XmlNode conditionElement, LogicalGrouping logicalGrouping)
{
string input = "-";
MatchType matchType = MatchType.Pattern; // from schema definition
string pattern = "(.*)";
bool ignoreCase = true; // from schema definition
bool negate = false; // from schema definition
if (conditionElement.Attributes["input"] != null)
{
input = conditionElement.Attributes["input"].Value;
}
if (conditionElement.Attributes["matchType"] != null)
{
try { matchType = (MatchType)Enum.Parse(typeof(MatchType), conditionElement.Attributes["matchType"].Value, true); }
catch (Exception exc) { Manager.Log("Condition: " + exc.Message, "Error"); }
}
if (conditionElement.Attributes["pattern"] != null)
{
pattern = conditionElement.Attributes["pattern"].Value;
}
if (conditionElement.Attributes["ignoreCase"] != null)
{
ignoreCase = XmlConvert.ToBoolean(conditionElement.Attributes["ignoreCase"].Value);
}
if (conditionElement.Attributes["negate"] != null)
{
negate = XmlConvert.ToBoolean(conditionElement.Attributes["negate"].Value);
}
RegexOptions conditionOptions = Manager.RuleOptions;
IConditionFlagProcessor conditionFlags = new ConditionFlagProcessor();
if (ignoreCase)
{
conditionFlags.Add(new CF.NoCaseFlag());
conditionOptions |= RegexOptions.IgnoreCase;
}
if (logicalGrouping == LogicalGrouping.MatchAny)
{
conditionFlags.Add(new CF.OrNextFlag());
}
ICondition condition = null;
// create the condition
switch (matchType)
{
case MatchType.IsFile: condition = new IsFileCondition(); break;
case MatchType.IsDirectory: condition = new IsDirectoryCondition(); break;
case MatchType.Pattern: condition = new DefaultCondition(); break;
}
Pattern compiledPattern = new Pattern(pattern, negate, conditionOptions);
var conditionTest = new DefaultConditionTestValue(input);
// initialize condition
condition.Init(compiledPattern, conditionTest, conditionFlags);
return(condition);
}
/// <summary>
/// Gets the condition.
/// </summary>
/// <param name="conditionElement">The condition element.</param>
/// <param name="matchAll">if set to <see langword="true"/> [match all].</param>
/// <returns></returns>
private ICondition GetCondition(XmlNode conditionElement, LogicalGrouping logicalGrouping)
{
var input = "-";
var matchType = MatchType.Pattern; // from schema definition
var pattern = "(.*)";
var ignoreCase = true; // from schema definition
var negate = false; // from schema definition
if (conditionElement.Attributes["input"] != null)
{
input = conditionElement.Attributes["input"].Value;
}
if (conditionElement.Attributes["matchType"] != null)
{
try { matchType = (MatchType)Enum.Parse(typeof(MatchType), conditionElement.Attributes["matchType"].Value, true); }
catch (Exception exc)
{
Logger.Error("Condition: " + exc.Message, exc);
}
}
if (conditionElement.Attributes["pattern"] != null)
{
pattern = conditionElement.Attributes["pattern"].Value;
}
if (conditionElement.Attributes["ignoreCase"] != null)
{
ignoreCase = XmlConvert.ToBoolean(conditionElement.Attributes["ignoreCase"].Value);
}
if (conditionElement.Attributes["negate"] != null)
{
negate = XmlConvert.ToBoolean(conditionElement.Attributes["negate"].Value);
}
var conditionOptions = UrlRewriterManager.RuleOptions;
IConditionFlagProcessor conditionFlags = new ConditionFlagProcessor();
if (ignoreCase)
{
conditionFlags.Add(new UrlRewriter.Conditions.Flags.NoCaseFlag());
conditionOptions |= RegexOptions.IgnoreCase;
}
if (logicalGrouping == LogicalGrouping.MatchAny)
{
conditionFlags.Add(new OrNextFlag());
}
ICondition condition = null;
// create the condition
switch (matchType)
{
case MatchType.IsFile: condition = new IsFileCondition(); break;
case MatchType.IsDirectory: condition = new IsDirectoryCondition(); break;
case MatchType.Pattern: condition = new DefaultCondition("", ""); break;
}
var compiledPattern = new Pattern(pattern, negate, conditionOptions);
var conditionTest = new DefaultConditionTestValue(input);
// initialize condition
condition.Init(compiledPattern, conditionTest, conditionFlags);
return condition;
}
