public PartialFindResult <ArtistForApiContract> GetList(
string query = "",
string artistTypes = null,
string tag = null,
int?followedByUserId = null,
EntryStatus?status = null,
int start = 0, int maxResults = defaultMax, bool getTotalCount = false,
ArtistSortRule sort = ArtistSortRule.Name,
bool preferAccurateMatches = false,
NameMatchMode nameMatchMode = NameMatchMode.Exact,
ArtistOptionalFields fields = ArtistOptionalFields.None,
ContentLanguagePreference lang = ContentLanguagePreference.Default)
{
var textQuery = ArtistSearchTextQuery.Create(query, nameMatchMode);
var types = EnumVal <ArtistType> .ParseMultiple(artistTypes);
var param = new ArtistQueryParams(textQuery, types, start, Math.Min(maxResults, absoluteMax), false, getTotalCount, sort, preferAccurateMatches)
{
Tag = tag,
UserFollowerId = followedByUserId ?? 0
};
param.Common.EntryStatus = status;
var ssl = WebHelper.IsSSL(Request);
var artists = service.FindArtists(s => new ArtistForApiContract(s, lang, thumbPersister, ssl, fields), param);
return(artists);
}
public static IQueryable <Album> WhereMatchFilter(this IQueryable <Album> query, AdvancedSearchFilter filter)
{
switch (filter.FilterType)
{
case AdvancedFilterType.ArtistType: {
var param = EnumVal <ArtistType> .Parse(filter.Param);
return(WhereArtistHasType(query, param));
}
case AdvancedFilterType.NoCoverPicture: {
return(query.Where(a => a.CoverPictureMime == null || a.CoverPictureMime == string.Empty));
}
case AdvancedFilterType.HasStoreLink: {
return(query.WhereHasLinkWithCategory(WebLinkCategory.Commercial));
}
case AdvancedFilterType.WebLink: {
return(query.WhereHasLink <Album, AlbumWebLink>(filter.Param));
}
}
return(query);
}
public ActionResult Creat(User user)
{
try
{
if (ModelState.IsValid)
{
var ret = userService.Exist(x => x.UserName == user.UserName || x.DisplayName == user.DisplayName);
if (ret)
{
return(View(user));
}
user.Status = EnumVal.GetStatusVal(Status.Y);
User newUser = userService.Add(user);
if (!string.IsNullOrWhiteSpace(newUser.UserName))
{
return(RedirectToAction("Index", "UserManage"));
}
}
}
catch (Exception ex)
{
Log.Error("Post新增用户：", ex);
}
return(View(user));
}
public ActionResult Index(ViewLogin viewUser)
{
if (ModelState.IsValid)
{
try {
var user = userService.Find(viewUser.UserName);
//存在并且状态为Y
if (user == null && user.Status == EnumVal.GetStatusVal(Status.Y))
{
ModelState.AddModelError("UserName", "用户名不存在");
}
else if (viewUser.Password != user.Password)
{
ModelState.AddModelError("Password", "密码不正确");
}
else
{
Session.Add("UserName", viewUser.UserName);
Session.Add("Password", viewUser.Password);
Session.Add("UserID", user.ID);
return(RedirectToAction("Index", "Home"));
}
}catch (Exception ex) {
Log.Error("LoginController-Index-", ex);
return(View(viewUser));
}
}
return(View(viewUser));
}
public override int GetHashCode()
{
int hash = 1;
if (IntVal != 0)
{
hash ^= IntVal.GetHashCode();
}
if (StrVal.Length != 0)
{
hash ^= StrVal.GetHashCode();
}
if (msgVal_ != null)
{
hash ^= MsgVal.GetHashCode();
}
if (EnumVal != 0)
{
hash ^= EnumVal.GetHashCode();
}
if (NestEnumVal != 0)
{
hash ^= NestEnumVal.GetHashCode();
}
hash ^= msgArray_.GetHashCode();
hash ^= nestEnumArray_.GetHashCode();
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public static IQueryable <T> WhereAlbumMatchFilter <T>(this IQueryable <T> query, AdvancedSearchFilter?filter)
where T : IAlbumLink
{
if (filter == null)
{
return(query);
}
switch (filter.FilterType)
{
case AdvancedFilterType.ArtistType:
{
var param = EnumVal <ArtistType> .Parse(filter.Param);
return(WhereAlbumHasArtistWithType(query, param));
}
case AdvancedFilterType.NoCoverPicture:
{
return(query.Where(a => a.Album.CoverPictureMime == null || a.Album.CoverPictureMime == string.Empty));
}
case AdvancedFilterType.HasStoreLink:
{
return(query.WhereAlbumHasLinkWithCategory(WebLinkCategory.Commercial));
}
case AdvancedFilterType.HasTracks:
{
return(query.Where(a => filter.Negate != a.Album.AllSongs.Any(s => s.Song == null || !s.Song.Deleted)));
}
}
return(query);
}
public static IEnumerable <SongType> ToIndividualSelections(this SongTypes selections, bool skipUnspecified = false)
{
return(EnumVal <SongTypes>
.GetIndividualValues(selections)
.Where(t => !skipUnspecified || t != SongTypes.Unspecified)
.Select(s => (SongType)s));
}
public PartialFindResult <SongInListForApiContract> GetSongs(int listId,
string query = "",
string songTypes = null,
PVServices?pvServices = null,
[FromQuery(Name = "tagId[]")] int[] tagId = null,
[FromQuery(Name = "artistId[]")] int[] artistId = null,
bool childVoicebanks = false,
[FromQuery(Name = "advancedFilters")] AdvancedSearchFilterParams[] advancedFilters = null,
int start = 0, int maxResults = DefaultMax, bool getTotalCount = false,
SongSortRule?sort = null,
NameMatchMode nameMatchMode = NameMatchMode.Auto,
SongOptionalFields fields = SongOptionalFields.None,
ContentLanguagePreference lang = ContentLanguagePreference.Default)
{
maxResults = Math.Min(maxResults, AbsoluteMax);
var types = EnumVal <SongType> .ParseMultiple(songTypes);
return(_queries.GetSongsInList(
new SongInListQueryParams
{
TextQuery = SearchTextQuery.Create(query, nameMatchMode),
ListId = listId,
Paging = new PagingProperties(start, maxResults, getTotalCount),
PVServices = pvServices,
ArtistIds = artistId,
ChildVoicebanks = childVoicebanks,
TagIds = tagId,
SortRule = sort,
AdvancedFilters = advancedFilters?.Select(advancedFilter => advancedFilter.ToAdvancedSearchFilter()).ToArray(),
SongTypes = types,
},
songInList => new SongInListForApiContract(songInList, lang, fields)));
}
public static IEnumerable <ContentLanguageSelection> ToIndividualSelections(this ContentLanguageSelections selections)
{
return(EnumVal <ContentLanguageSelections>
.GetIndividualValues(selections)
.Where(s => s != ContentLanguageSelections.All)
.Select(s => (ContentLanguageSelection)s));
}
public ParsedSongQuery ParseTextQuery(SearchTextQuery textQuery)
{
var query = textQuery.OriginalQuery;
if (string.IsNullOrWhiteSpace(query))
{
return(new ParsedSongQuery());
}
var trimmed = query.Trim();
var term = GetTerm(trimmed, "id", "tag", "artist-tag", "artist-type", "publish-date");
return((term?.PropertyName) switch
{
"tag" => new ParsedSongQuery {
TagName = term.Value
},
"artist-tag" => new ParsedSongQuery {
ArtistTag = term.Value
},
"artist-type" => new ParsedSongQuery {
ArtistType = EnumVal <ArtistType> .ParseSafe(term.Value, ArtistType.Unknown)
},
"id" => new ParsedSongQuery {
Id = PrimitiveParseHelper.ParseIntOrDefault(term.Value, 0)
},
"publish-date" => ParseDateRange(term.Value),
_ => ParseReferenceQuery(trimmed, query) ?? new ParsedSongQuery {
Name = textQuery
},
});
public static IQueryable <Artist> WhereMatchFilter(this IQueryable <Artist> query, AdvancedSearchFilter filter)
{
switch (filter.FilterType)
{
case AdvancedFilterType.HasUserAccount: {
return(query.Where(a => a.OwnerUsers.Any()));
}
case AdvancedFilterType.RootVoicebank: {
return(filter.Negate ? query.Where(a => a.BaseVoicebank != null) : query.Where(a => ArtistHelper.VoiceSynthesizerTypes.Contains(a.ArtistType) && a.BaseVoicebank == null));
}
case AdvancedFilterType.VoiceProvider: {
var param = EnumVal <ArtistType> .ParseSafe(filter.Param, ArtistType.Unknown);
return(param == ArtistType.Unknown ?
query.Where(a => a.AllMembers.Any(m => m.LinkType == ArtistLinkType.VoiceProvider)) :
query.Where(a => a.AllMembers.Any(m => m.LinkType == ArtistLinkType.VoiceProvider && m.Member.ArtistType == param)));
}
case AdvancedFilterType.WebLink: {
return(query.WhereHasLink <Artist, ArtistWebLink>(filter.Param));
}
}
return(query);
}
public static IQueryable <T> WhereMatchFilter <T>(this IQueryable <T> query, AdvancedSearchFilter filter)
where T : ISongLink
{
if (filter == null)
{
return(query);
}
switch (filter.FilterType)
{
case AdvancedFilterType.ArtistType: {
var param = EnumVal <ArtistType> .Parse(filter.Param);
return(WhereSongHasArtistWithType(query, param));
}
case AdvancedFilterType.HasMultipleVoicebanks: {
return(query.Where(s => s.Song.AllArtists.Count(a => !a.IsSupport && ArtistHelper.VoiceSynthesizerTypes.Contains(a.Artist.ArtistType)) > 1));
}
case AdvancedFilterType.HasPublishDate: {
return(query.WhereSongHasPublishDate(!filter.Negate));
}
case AdvancedFilterType.Lyrics: {
var any = filter.Param == AdvancedSearchFilter.Any;
var languageCodes = !any ? (filter.Param ?? string.Empty).Split(',') : null;
return(WhereSongHasLyrics(query, languageCodes, any));
}
}
return(query);
}
/// <summary>
/// Gets a list of individual values from bitarray.
/// <see cref="ArtistTypes.Unknown"/> is skipped.
/// </summary>
/// <param name="flags">Bitarray of artist types.</param>
/// <returns>Individual artist types.</returns>
public static ArtistType[] GetArtistTypesFromFlags(ArtistTypes flags)
{
return(EnumVal <ArtistTypes>
.GetIndividualValues(flags)
.Where(v => v != ArtistTypes.Unknown)
.Select(a => EnumVal <ArtistType> .Parse(a.ToString()))
.ToArray());
}
public AuditLogEntryContract[] GetAuditLog(string filter, int start, int maxEntries, int timeCutoffDays,
string userName, string[] excludeUsers, bool onlyNewUsers,
AuditLogUserGroupFilter filterByGroup = AuditLogUserGroupFilter.Nothing)
{
return(HandleTransaction(session => {
var q = session.Query <AuditLogEntry>();
if (timeCutoffDays > 0)
{
var cutoff = DateTime.Now - TimeSpan.FromDays(timeCutoffDays);
q = q.Where(e => e.Time > cutoff);
}
if (!string.IsNullOrWhiteSpace(filter))
{
q = q.Where(e => e.Action.Contains(filter));
}
if (!string.IsNullOrWhiteSpace(userName))
{
q = q.Where(e => e.AgentName == userName || e.User.Options.LastLoginAddress == userName);
}
if (excludeUsers.Any())
{
var usr = session.Query <User>().Where(u => excludeUsers.Contains(u.Name)).Select(u => u.Id).Distinct().ToArray();
q = q.Where(e => !usr.Contains(e.User.Id));
}
if (onlyNewUsers)
{
var newUserDate = DateTime.Now - TimeSpan.FromDays(7);
q = q.Where(e => e.User.CreateDate >= newUserDate);
}
if (filterByGroup != AuditLogUserGroupFilter.Nothing && filterByGroup != AuditLogUserGroupFilter.NoFilter)
{
var userGroup = EnumVal <UserGroupId> .Parse(filterByGroup.ToString());
q = q.Where(e => e.User != null && e.User.GroupId == userGroup);
}
if (filterByGroup == AuditLogUserGroupFilter.Nothing)
{
q = q.Where(e => e.User == null);
}
var entries = q
.OrderByDescending(e => e.Time)
.Skip(start)
.Take(maxEntries)
.ToArray()
.Select(e => new AuditLogEntryContract(e))
.ToArray();
return entries;
}, IsolationLevel.ReadUncommitted));
}
public PartialFindResult <SongForApiContract> GetList(
string query = "",
string songTypes = null,
[FromUri] string[] tagName = null,
[FromUri] int[] tagId = null,
bool childTags = false,
[FromUri] int[] artistId = null,
ArtistAlbumParticipationStatus artistParticipationStatus = ArtistAlbumParticipationStatus.Everything,
bool childVoicebanks = false,
bool includeMembers = false,
bool onlyWithPvs = false,
[FromUri] PVServices?pvServices = null,
int?since = null,
int?minScore = null,
int?userCollectionId = null,
int?releaseEventId = null,
EntryStatus?status = null,
[FromUri] AdvancedSearchFilter[] advancedFilters = null,
int start = 0, int maxResults = defaultMax, bool getTotalCount = false,
SongSortRule sort = SongSortRule.Name,
bool preferAccurateMatches = false,
NameMatchMode nameMatchMode = NameMatchMode.Exact,
SongOptionalFields fields = SongOptionalFields.None,
ContentLanguagePreference lang = ContentLanguagePreference.Default)
{
var textQuery = SearchTextQuery.Create(query, nameMatchMode);
var types = EnumVal <SongType> .ParseMultiple(songTypes);
var param = new SongQueryParams(textQuery, types, start, Math.Min(maxResults, absoluteMax), getTotalCount, sort, false, preferAccurateMatches, null)
{
ArtistParticipation =
{
ArtistIds = artistId,
Participation = artistParticipationStatus,
ChildVoicebanks = childVoicebanks,
IncludeMembers = includeMembers
},
TagIds = tagId,
Tags = tagName,
ChildTags = childTags,
OnlyWithPVs = onlyWithPvs,
TimeFilter = since.HasValue ? TimeSpan.FromHours(since.Value) : TimeSpan.Zero,
MinScore = minScore ?? 0,
PVServices = pvServices,
UserCollectionId = userCollectionId ?? 0,
ReleaseEventId = releaseEventId ?? 0,
AdvancedFilters = advancedFilters,
LanguagePreference = lang
};
param.Common.EntryStatus = status;
var artists = service.Find(s => new SongForApiContract(s, null, lang, fields), param);
return(artists);
}
public static string EntrySubTypeName(EntryTypeAndSubType fullEntryType)
{
return(fullEntryType.EntryType switch
{
EntryType.Album => DiscTypeName(EnumVal <DiscType> .Parse(fullEntryType.SubType)),
EntryType.Artist => ArtistTypeName(EnumVal <ArtistType> .Parse(fullEntryType.SubType)),
EntryType.ReleaseEvent => ReleaseEventCategoryNames[EnumVal <EventCategory> .Parse(fullEntryType.SubType)],
EntryType.Song => SongTypeNames[EnumVal <SongType> .Parse(fullEntryType.SubType)],
_ => string.Empty,
});
public static IQueryable <Song> WhereMatchFilter(this IQueryable <Song> query, AdvancedSearchFilter filter)
{
if (filter == null)
{
return(query);
}
switch (filter.FilterType)
{
case AdvancedFilterType.ArtistType: {
var param = EnumVal <ArtistType> .Parse(filter.Param);
return(WhereArtistHasType(query, param));
}
case AdvancedFilterType.HasAlbum:
return(filter.Negate ? query.Where(s => !s.AllAlbums.Any()) : query.Where(s => s.AllAlbums.Any()));
case AdvancedFilterType.HasMultipleVoicebanks: {
return(query.Where(s => s.AllArtists.Count(a => !a.IsSupport && ArtistHelper.VoiceSynthesizerTypes.Contains(a.Artist.ArtistType)) > 1));
}
case AdvancedFilterType.HasPublishDate: {
return(query.WhereHasPublishDate(!filter.Negate));
}
case AdvancedFilterType.Lyrics: {
var any = filter.Param == AdvancedSearchFilter.Any;
var languageCodes = !any ? (filter.Param ?? string.Empty).Split(',') : null;
return(WhereHasLyrics(query, languageCodes, any));
}
case AdvancedFilterType.LyricsContent: {
return(query.WhereHasLyricsContent(filter.Param));
}
case AdvancedFilterType.HasOriginalMedia: {
return(query.Where(s => filter.Negate != s.PVs.PVs.Any(pv => !pv.Disabled && pv.PVType == PVType.Original)));
}
case AdvancedFilterType.HasMedia: {
return(query.Where(s => filter.Negate != s.PVs.PVs.Any()));
}
case AdvancedFilterType.WebLink: {
return(query.WhereHasLink <Song, SongWebLink>(filter.Param));
}
}
return(query);
}
public static IEnumerable <PurchaseStatus> ToIndividualSelections(this PurchaseStatuses selections)
{
if (selections == PurchaseStatuses.Nothing)
{
return new[] { PurchaseStatus.Nothing }
}
;
return(EnumVal <PurchaseStatuses>
.GetIndividualValues(selections)
.Where(s => s != PurchaseStatuses.All && s != PurchaseStatuses.Nothing)
.Select(s => (PurchaseStatus)s));
}
}
public static EntryTypeAndTagCollection <TSubType> Create(
EntryType entryType, IReadOnlyCollection <TSubType> subTypes,
IReadOnlyCollection <int> tagIds, IDatabaseContext ctx, bool allowAllTags = false)
{
TSubType[] allTypes;
int[] songTypeTagIds;
int[] allTagIds;
if (tagIds.Any())
{
var songTypesAndTagsFromTags = ctx.Query <EntryTypeToTagMapping>()
.WhereEntryTypeIs(entryType)
.WhereHasSubType()
.Where(etm => tagIds.Contains(etm.Tag.Id))
.Select(etm => new { TagId = etm.Tag.Id, etm.SubType })
.ToArray();
songTypeTagIds = songTypesAndTagsFromTags.Select(etm => etm.TagId).ToArray();
var songTypesFromTags = songTypesAndTagsFromTags.Select(etm => EnumVal <TSubType> .Parse(etm.SubType));
allTypes = subTypes.Union(songTypesFromTags).ToArray();
}
else
{
allTypes = subTypes.ToArray();
songTypeTagIds = new int[0];
}
if (subTypes.Any())
{
var tagsFromSongTypes = ctx.Query <EntryTypeToTagMapping>()
.WhereEntryTypeIs(entryType, subTypes)
.Select(etm => etm.Tag.Id)
.ToArray();
allTagIds = songTypeTagIds.Union(tagsFromSongTypes).ToArray();
}
else
{
allTagIds = songTypeTagIds;
}
if (allowAllTags)
{
allTagIds = allTagIds.Union(tagIds).ToArray();
}
return(new EntryTypeAndTagCollection <TSubType>(allTypes, allTagIds));
}
private ParsedSongQuery ParseTextQuery(string query)
{
if (string.IsNullOrWhiteSpace(query))
{
return(new ParsedSongQuery());
}
var term = GetTerm(query.Trim(), "tag", "artist-tag", "artist-type");
if (term == null)
{
var nicoId = VideoService.NicoNicoDouga.GetIdByUrl(query);
if (!string.IsNullOrEmpty(nicoId))
{
return new ParsedSongQuery {
NicoId = nicoId
}
}
;
}
else
{
switch (term.PropertyName)
{
case "tag":
return(new ParsedSongQuery {
TagName = term.Value
});
case "artist-tag":
return(new ParsedSongQuery {
ArtistTag = term.Value
});
case "artist-type":
return(new ParsedSongQuery {
ArtistType = EnumVal <ArtistType> .ParseSafe(term.Value, ArtistType.Unknown)
});
}
}
return(new ParsedSongQuery {
Name = query.Trim()
});
}
private bool TryGetLanguagePreferenceFromCookie(ref ContentLanguagePreference languagePreference)
{
if (HttpContext.Current == null)
{
return(false);
}
var cookie = HttpContext.Current.Request.Cookies.Get("languagePreference");
if (cookie == null || string.IsNullOrEmpty(cookie.Value))
{
return(false);
}
languagePreference = EnumVal <ContentLanguagePreference> .Parse(cookie.Value);
return(true);
}
public PartialFindResult <SongForApiContract> GetList(
string query = "",
string songTypes = null,
string tag = null,
int?artistId = null,
ArtistAlbumParticipationStatus artistParticipationStatus = ArtistAlbumParticipationStatus.Everything,
bool childVoicebanks = false,
bool onlyWithPvs = false,
[FromUri] PVServices?pvServices = null,
int?since = null,
int?minScore = null,
[FromUri] ContentLanguageSelections?lyrics = null,
int?userCollectionId = null,
EntryStatus?status = null,
int start = 0, int maxResults = defaultMax, bool getTotalCount = false,
SongSortRule sort = SongSortRule.Name,
bool preferAccurateMatches = false,
NameMatchMode nameMatchMode = NameMatchMode.Exact,
SongOptionalFields fields = SongOptionalFields.None,
ContentLanguagePreference lang = ContentLanguagePreference.Default)
{
var textQuery = SearchTextQuery.Create(query, nameMatchMode);
var types = EnumVal <SongType> .ParseMultiple(songTypes);
var param = new SongQueryParams(textQuery, types, start, Math.Min(maxResults, absoluteMax), false, getTotalCount, sort, false, preferAccurateMatches, null)
{
Tag = tag,
OnlyWithPVs = onlyWithPvs,
ArtistId = artistId ?? 0,
ArtistParticipationStatus = artistParticipationStatus,
ChildVoicebanks = childVoicebanks,
TimeFilter = since.HasValue ? TimeSpan.FromHours(since.Value) : TimeSpan.Zero,
LyricsLanguages = lyrics != null?lyrics.Value.ToIndividualSelections().ToArray() : null,
MinScore = minScore ?? 0,
PVServices = pvServices,
UserCollectionId = userCollectionId ?? 0
};
param.Common.EntryStatus = status;
var artists = service.Find(s => new SongForApiContract(s, null, lang, fields), param);
return(artists);
}
public ActionResult Delete(int id)
{
try
{
var userDelet = userService.Find(id);
if (userDelet != null && !userDelet.UserName.Equals("admin"))
{
//只是更改状态并不实际删除
userDelet.Status = EnumVal.GetStatusVal(Status.N);
userService.Update(userDelet);
return(RedirectToAction("Index", "UserManage"));
}
}
catch (Exception ex)
{
Log.Error("UserManage-Delete-", ex);
}
return(RedirectToAction("Index", "UserManage"));
}
public static string EntryIndex(this UrlHelper urlHelper, EntryTypeAndSubType fullEntryType)
{
SearchRouteParams searchRouteParams = null;
switch (fullEntryType.EntryType)
{
case EntryType.Artist:
searchRouteParams = new SearchRouteParams(EntryType.Artist)
{
artistType = EnumVal <ArtistType> .ParseSafe(fullEntryType.SubType)
};
break;
case EntryType.Album:
searchRouteParams = new SearchRouteParams(EntryType.Album)
{
discType = EnumVal <DiscType> .ParseSafe(fullEntryType.SubType)
};
break;
case EntryType.Song:
searchRouteParams = new SearchRouteParams(EntryType.Song)
{
songType = EnumVal <SongType> .ParseSafe(fullEntryType.SubType)
};
break;
case EntryType.ReleaseEvent:
searchRouteParams = new SearchRouteParams(EntryType.ReleaseEvent);
break;
case EntryType.Tag:
searchRouteParams = new SearchRouteParams(EntryType.Tag);
break;
}
if (searchRouteParams != null)
{
return(urlHelper.Action("Index", "Search", searchRouteParams));
}
return("");
}
public ActionResult Create([Bind(Include = "ID,Status,Reark,FirstCode,SecondCode,ThirdCode,FourthCode,FifthCode,InfoValue")] Dictionary dictionary)
{
try
{
if (ModelState.IsValid)
{
dictionary.Status = EnumVal.GetStatusVal(Status.Y);
db.Dictionarys.Add(dictionary);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(dictionary));
}
catch (Exception ex) {
Log.Error("DictionarydController-Create-Post", ex);
return(View());
}
}
public PartialFindResult <ArtistForApiContract> GetList(
string query = "",
string artistTypes = null,
bool allowBaseVoicebanks = true,
[FromQuery(Name = "tagName[]")] string[] tagName = null,
[FromQuery(Name = "tagId[]")] int[] tagId = null,
bool childTags = false,
int?followedByUserId = null,
EntryStatus?status = null,
[FromQuery(Name = "advancedFilters")] AdvancedSearchFilterParams[] advancedFilters = null,
int start = 0, int maxResults = DefaultMax, bool getTotalCount = false,
ArtistSortRule sort = ArtistSortRule.Name,
bool preferAccurateMatches = false,
NameMatchMode nameMatchMode = NameMatchMode.Exact,
ArtistOptionalFields fields = ArtistOptionalFields.None,
ContentLanguagePreference lang = ContentLanguagePreference.Default)
{
var textQuery = ArtistSearchTextQuery.Create(query, nameMatchMode);
var types = EnumVal <ArtistType> .ParseMultiple(artistTypes);
var param = new ArtistQueryParams(textQuery, types, start, Math.Min(maxResults, AbsoluteMax), getTotalCount, sort, preferAccurateMatches)
{
Tags = tagName,
TagIds = tagId,
ChildTags = childTags,
UserFollowerId = followedByUserId ?? 0,
AllowBaseVoicebanks = allowBaseVoicebanks,
AdvancedFilters = advancedFilters?.Select(advancedFilter => advancedFilter.ToAdvancedSearchFilter()).ToArray(),
};
param.Common.EntryStatus = status;
var artists = _service.FindArtists(s => new ArtistForApiContract(s, lang, _thumbPersister, fields), param);
return(artists);
}
private ParsedSongQuery ParseTextQuery(string query)
{
if (string.IsNullOrWhiteSpace(query))
{
return(new ParsedSongQuery());
}
var trimmed = query.Trim();
var term = GetTerm(trimmed, "id", "tag", "artist-tag", "artist-type");
if (term == null)
{
// Optimization: check prefix, in most cases the user won't be searching by URL
if (trimmed.StartsWith("/s/", StringComparison.InvariantCultureIgnoreCase) ||
trimmed.StartsWith("http", StringComparison.InvariantCultureIgnoreCase))
{
var nicoId = VideoService.NicoNicoDouga.GetIdByUrl(query);
if (!string.IsNullOrEmpty(nicoId))
{
return new ParsedSongQuery {
NicoId = nicoId
}
}
;
var entryId = entryUrlParser.Parse(trimmed, allowRelative: true);
if (entryId.EntryType == EntryType.Song)
{
return new ParsedSongQuery {
Id = entryId.Id
}
}
;
}
}
else
{
switch (term.PropertyName)
{
case "tag":
return(new ParsedSongQuery {
TagName = term.Value
});
case "artist-tag":
return(new ParsedSongQuery {
ArtistTag = term.Value
});
case "artist-type":
return(new ParsedSongQuery {
ArtistType = EnumVal <ArtistType> .ParseSafe(term.Value, ArtistType.Unknown)
});
case "id":
return(new ParsedSongQuery {
Id = PrimitiveParseHelper.ParseIntOrDefault(term.Value, 0)
});
}
}
return(new ParsedSongQuery {
Name = trimmed
});
}
public EnumFieldAccessor(EnumVal <T> val, T field)
: this()
{
_val = val;
_field = field;
}
protected EntryDiff(bool isSnapshot = false)
{
IsSnapshot = isSnapshot;
ChangedFields = new EnumVal <T>();
}
protected EntryDiff(T changedFields)
{
ChangedFields = new EnumVal <T>(changedFields);
IsSnapshot = false;
}
