private IArtistWithSupport CreateArtist(ArtistType artistType, string name) { var p = new Artist { ArtistType = artistType }; p.Names.Add(new ArtistName(p, new LocalizedString(name, ContentLanguageSelection.English))); return p.AddAlbum(new Album()); }
public ActionResult Index(string filter, EntryType searchType = EntryType.Undefined, bool allowRedirect = true, string tag = null, string sort = null, int? artistId = null, ArtistType? artistType = null, DiscType? discType = null, SongType? songType = null, bool? onlyWithPVs = null ) { filter = !string.IsNullOrEmpty(filter) ? filter.Trim() : string.Empty; if (allowRedirect && !string.IsNullOrEmpty(filter)) { var redirectResult = TryRedirect(filter, searchType); if (redirectResult != null) return redirectResult; } ViewBag.Query = filter; ViewBag.SearchType = searchType != EntryType.Undefined ? searchType.ToString() : "Anything"; ViewBag.Tag = tag; ViewBag.Sort = sort; ViewBag.ArtistId = artistId; ViewBag.ArtistType = artistType; ViewBag.DiscType = discType; ViewBag.SongType = songType; ViewBag.OnlyWithPVs = onlyWithPVs; SetSearchEntryType(searchType); return View(); }
public ArtistQueryParams() { Common = new CommonSearchParams(); Paging = new PagingProperties(0, 30, true); ArtistTypes = new ArtistType[] { }; }
public static IQueryable<ArtistName> FilterByArtistType(this IQueryable<ArtistName> queryable, ArtistType[] types) { if (types == null || !types.Any()) return queryable; return queryable.Where(n => types.Contains(n.Artist.ArtistType)); }
/// <param name="query">Query search string. Can be null or empty, in which case no filtering by name is done.</param> /// <param name="songTypes">Allowed song types. Can be null or empy, in which case no filtering by song type is done.</param> /// <param name="start">0-based order number of the first item to be returned.</param> /// <param name="maxResults">Maximum number of results to be returned.</param> /// <param name="draftsOnly">Whether to return only entries with a draft status.</param> /// <param name="getTotalCount">Whether to return the total number of entries matching the criteria.</param> /// <param name="nameMatchMode">Mode for name maching. Ignored when query string is null or empty.</param> /// <param name="sortRule">Sort rule for results.</param> /// <param name="moveExactToTop">Whether to move exact match to the top of search results.</param> public ArtistQueryParams(string query, ArtistType[] songTypes, int start, int maxResults, bool draftsOnly, bool getTotalCount, NameMatchMode nameMatchMode, ArtistSortRule sortRule, bool moveExactToTop) { Common = new CommonSearchParams(query, draftsOnly, nameMatchMode, true, moveExactToTop); Paging = new PagingProperties(start, maxResults, getTotalCount); ArtistTypes = songTypes ?? new ArtistType[] { }; SortRule = sortRule; }
/// <summary> /// Filters out songs that aren't "main" songs for a particular artist type. /// /// At the moment this just filters out PVs for music producers. /// Used by the "recent songs" list on artist page. /// </summary> /// <param name="query">Query. Cannot be null.</param> /// <param name="artistType">Artist type.</param> /// <returns>Filtered query.</returns> public static IQueryable<ArtistForSong> WhereIsMainSong(this IQueryable<ArtistForSong> query, ArtistType artistType) { if (artistType == ArtistType.Producer) { return query.Where(q => q.Song.SongType != SongType.MusicPV || (q.Roles & ArtistRoles.Animator) != ArtistRoles.Default); } return query; }
public ArtistIndex(PartialFindResult<ArtistWithAdditionalNamesContract> result, string filter, ArtistType artistType, bool? draftsOnly, ArtistSortRule sort, int? page, IndexRouteParams routeParams) { Artists = new StaticPagedList<ArtistWithAdditionalNamesContract>(result.Items, page ?? 1, 30, result.TotalCount); DraftsOnly = draftsOnly ?? false; Filter = filter; ArtistType = artistType; Sort = sort; RouteParams = routeParams; FilterableArtistTypes = EnumVal<ArtistType>.Values.ToDictionary(a => a, Translate.ArtistTypeName); }
public Artist(ArtistType type, string name, short year) { this.type = type; this.name = name ?? string.Empty; this.year = year; }
public static Artist Vocalist(int id = 0, string name = null, ArtistType artistType = ArtistType.Vocaloid) { return new Artist(TranslatedString.Create(name ?? "Hatsune Miku")) { Id = id, ArtistType = artistType }; }
public static Artist Artist(ArtistType artistType, int id = 0, string name = "Artist") { return new Artist(TranslatedString.Create(name)) { Id = id, ArtistType = artistType }; }
public static bool IsVoiceSynthesizer(ArtistType artistType) { return(VoiceSynthesizerTypes.Contains(artistType)); }
public Artist(int id, string fullName, ArtistType artistType) { Id = id; FullName = fullName; ArtistType = artistType; }
public async Task <IList <AlbumData> > GetArtistAlbumDataAsync(IList <string> artists, ArtistType artistType) { var albumData = new List <AlbumData>(); await Task.Run(() => { try { using (var conn = this.factory.GetConnection()) { try { string filterQuery = string.Empty; if (artists != null) { if (artistType.Equals(ArtistType.All)) { filterQuery = $" AND ({DataUtils.CreateOrLikeClause("Artists", artists, Constants.ColumnValueDelimiter)} OR {DataUtils.CreateOrLikeClause("AlbumArtists", artists, Constants.ColumnValueDelimiter)})"; } else if (artistType.Equals(ArtistType.Track)) { filterQuery = $" AND ({DataUtils.CreateOrLikeClause("Artists", artists, Constants.ColumnValueDelimiter)})"; } else if (artistType.Equals(ArtistType.Album)) { filterQuery = $" AND ({DataUtils.CreateOrLikeClause("AlbumArtists", artists, Constants.ColumnValueDelimiter)})"; } } string query = this.SelectVisibleAlbumDataQuery() + filterQuery + " GROUP BY AlbumKey"; albumData = conn.Query <AlbumData>(query); } catch (Exception ex) { LogClient.Error("Could not get all the album values. Exception: {0}", ex.Message); } } } catch (Exception ex) { LogClient.Error("Could not connect to the database. Exception: {0}", ex.Message); } }); return(albumData); }
public static IQueryable <Song> WhereArtistHasType(this IQueryable <Song> query, ArtistType artistType) { return(query.WhereArtistHasType <Song, ArtistForSong>(artistType)); }
public static IQueryable <T> WhereArtistHasType <T>(this IQueryable <T> query, ArtistType artistType) where T : IArtistLink { if (artistType == ArtistType.Unknown) { return(query); } return(query.Where(m => m.Artist.ArtistType == artistType)); }
public static string ArtistTypeName(ArtistType artistType) { return(Model.Resources.ArtistTypeNames.ResourceManager.GetString(artistType.ToString())); }
public Artist(string artist, ArtistType type) { this.artist = artist; this.type = type; }
public static IQueryable<Artist> WhereHasType(this IQueryable<Artist> query, ArtistType[] artistTypes) { if (!artistTypes.Any()) return query; return query.Where(m => artistTypes.Contains(m.ArtistType)); }
public PartialFindResult<ArtistForUserForApiContract> GetFollowedArtists( int userId, ArtistType artistType = ArtistType.Unknown, int start = 0, int maxResults = defaultMax, bool getTotalCount = false, ArtistOptionalFields fields = ArtistOptionalFields.None, ContentLanguagePreference lang = ContentLanguagePreference.Default) { maxResults = Math.Min(maxResults, absoluteMax); var ssl = WebHelper.IsSSL(Request); var queryParams = new FollowedArtistQueryParams { UserId = userId, ArtistType = artistType, Paging = new PagingProperties(start, maxResults, getTotalCount), }; var artists = queries.GetArtists(queryParams, afu => new ArtistForUserForApiContract(afu, lang, thumbPersister, ssl, fields)); return artists; }
public static IQueryable <T> WhereAlbumHasArtistWithType <T>(this IQueryable <T> query, ArtistType artistType) where T : IAlbumLink { if (artistType == ArtistType.Unknown) { return(query); } return(query.Where(s => s.Album.AllArtists.Any(a => !a.IsSupport && a.Artist.ArtistType == artistType))); }
public static ArtistRoles GetOtherArtistRoles(ArtistType artistType) { switch (artistType) { case ArtistType.Illustrator: return ArtistRoles.Illustrator; case ArtistType.Lyricist: return ArtistRoles.Lyricist; default: return ArtistRoles.Default; } }
public static string ArtistTypeName(ArtistType artistType) { return ArtistTypeNames.ResourceManager.GetString(artistType.ToString()); }
public static IQueryable <Song> WhereArtistHasType(this IQueryable <Song> query, ArtistType artistType) { if (artistType == ArtistType.Unknown) { return(query); } return(query.Where(s => s.AllArtists.Any(a => a.Artist.ArtistType == artistType))); }
/// <summary> /// Filters out songs that aren't "main" songs for a particular artist type. /// /// At the moment this just filters out PVs for music producers. /// Used by the "recent songs" list on artist page. /// </summary> /// <param name="query">Query. Cannot be null.</param> /// <param name="artistType">Artist type.</param> /// <returns>Filtered query.</returns> public static IQueryable <ArtistForSong> WhereIsMainSong(this IQueryable <ArtistForSong> query, ArtistType artistType) { if (artistType == ArtistType.Producer) { return(query.Where(q => q.Song.SongType != SongType.MusicPV || (q.Roles & ArtistRoles.Animator) != ArtistRoles.Default)); } return(query); }
public static bool IsCustomizable(ArtistType at) { return(CustomizableTypes.Contains(at)); }
/// <summary> /// Filters out songs that aren't "main" songs for a particular artist type. /// /// At the moment this just filters out PVs for music producers. /// Used by the "recent songs" list on artist page. /// </summary> /// <param name="query">Query. Cannot be null.</param> /// <param name="artistType">Artist type.</param> /// <returns>Filtered query.</returns> public static IQueryable <ArtistForSong> WhereIsMainSong(this IQueryable <ArtistForSong> query, ArtistType artistType) { if (artistType == ArtistType.Producer) { return(query .Where(artistForSong => (artistForSong.Song.SongType != SongType.MusicPV || (artistForSong.Roles & ArtistRoles.Animator) != ArtistRoles.Default) && artistForSong.Roles != ArtistRoles.VocalDataProvider)); } return(query); }
public Artist(int id, string name, ArtistType artistType) { ID = id; Name = name; ArtistType = artistType; }
public static ArtistCategories GetCategories(ArtistType type, ArtistRoles roles) { if (roles == ArtistRoles.Default || !IsCustomizable(type)) { return CategoriesForTypes[type]; } else { var cat = ArtistCategories.Nothing; if (roles.HasFlag(ArtistRoles.Vocalist) || roles.HasFlag(ArtistRoles.Chorus)) cat |= ArtistCategories.Vocalist; if (roles.HasFlag(ArtistRoles.Arranger) || roles.HasFlag(ArtistRoles.Composer) || roles.HasFlag(ArtistRoles.VoiceManipulator)) cat |= ArtistCategories.Producer; if (roles.HasFlag(ArtistRoles.Distributor) || roles.HasFlag(ArtistRoles.Publisher)) cat |= ArtistCategories.Circle; if (roles.HasFlag(ArtistRoles.Animator)) cat |= ArtistCategories.Animator; //if (roles.HasFlag(ArtistRoles.Illustrator) || roles.HasFlag(ArtistRoles.Lyricist) || roles.HasFlag(ArtistRoles.Mastering)) // cat |= ArtistCategories.Other; if (cat == ArtistCategories.Nothing) cat = ArtistCategories.Other; return cat; } }
public static IQueryable <TEntry> WhereArtistHasType <TEntry, TArtistLink>(this IQueryable <TEntry> query, ArtistType artistType) where TEntry : IEntryWithArtistLinks <TArtistLink> where TArtistLink : IArtistLinkWithRoles { if (artistType == ArtistType.Unknown) { return(query); } return(query.Where(s => s.AllArtists.Any(a => !a.IsSupport && a.Artist.ArtistType == artistType))); }
public static bool IsCustomizable(ArtistType at) { return CustomizableTypes.Contains(at); }
public async Task <List <Artist> > GetArtistsAsync(ArtistType artistType) { var artists = new List <Artist>(); await Task.Run(() => { try { using (var conn = this.factory.GetConnection()) { try { var trackArtists = new List <Artist>(); var albumArtists = new List <string>(); // Get the Track Artists trackArtists = conn.Query <Artist>("SELECT DISTINCT art.ArtistID, art.ArtistName FROM Artist art" + " INNER JOIN Track tra ON art.ArtistID=tra.ArtistID" + " INNER JOIN Folder fol ON tra.FolderID=fol.FolderID" + " WHERE fol.ShowInCollection=1"); // Get the Album Artists var albums = conn.Query <Album>("SELECT DISTINCT alb.AlbumID, alb.AlbumTitle, alb.AlbumArtist, alb.Year, alb.ArtworkID, alb.DateLastSynced, alb.DateAdded FROM Album alb" + " INNER JOIN Track tra ON alb.AlbumID=tra.AlbumID" + " INNER JOIN Folder fol ON tra.FolderID=fol.FolderID" + " INNER JOIN Artist art ON tra.ArtistID=art.ArtistID" + " WHERE tra.AlbumID=alb.AlbumID AND tra.ArtistID=tra.ArtistID AND fol.ShowInCollection=1"); albumArtists = albums.Select((a) => a.AlbumArtist).ToList(); if (artistType == ArtistType.All | artistType == ArtistType.Track) { foreach (Artist trackArtist in trackArtists) { artists.Add(trackArtist); } } if (artistType == ArtistType.All | artistType == ArtistType.Album) { foreach (string albumArtist in albumArtists) { if (!artists.Select((art) => art.ArtistName).Contains(albumArtist)) { artists.Add(new Artist { ArtistName = albumArtist }); } } } // Orders the artists artists = artists.OrderBy((a) => Utils.GetSortableString(a.ArtistName, true)).ToList(); } catch (Exception ex) { LogClient.Instance.Logger.Error("Could not get the Artists. Exception: {0}", ex.Message); } } } catch (Exception ex) { LogClient.Instance.Logger.Error("Could not connect to the database. Exception: {0}", ex.Message); } }); return(artists); }