Beispiel #1
0
        public SongDetailsContract(Song song, ContentLanguagePreference languagePreference,
                                   SongListBaseContract[] pools, ISpecialTags specialTags)
        {
            Song = new SongContract(song, languagePreference);

            AdditionalNames   = string.Join(", ", song.AllNames.Where(n => n != Song.Name).Distinct());
            Albums            = song.OnAlbums.Select(a => new AlbumContract(a, languagePreference)).OrderBy(a => a.Name).ToArray();
            AlternateVersions = song.AlternateVersions.Select(s => new SongContract(s, languagePreference)).ToArray();
            Artists           = song.Artists.Select(a => new ArtistForSongContract(a, languagePreference)).OrderBy(a => a.Name).ToArray();
            ArtistString      = song.ArtistString[languagePreference];
            CreateDate        = song.CreateDate;
            Deleted           = song.Deleted;
            LikeCount         = song.UserFavorites.Count(f => f.Rating == SongVoteRating.Like);
            LyricsFromParents = song.GetLyricsFromParents(specialTags).Select(l => new LyricsForSongContract(l, false)).ToArray();
            Notes             = song.Notes;
            OriginalVersion   = (song.OriginalVersion != null && !song.OriginalVersion.Deleted ?
                                 new SongForApiContract(song.OriginalVersion, null, languagePreference, SongOptionalFields.AdditionalNames | SongOptionalFields.ThumbUrl) : null);

            PVs            = song.PVs.Select(p => new PVContract(p)).ToArray();
            ReleaseEvent   = song.ReleaseEvent != null ? new ReleaseEventForApiContract(song.ReleaseEvent, ReleaseEventOptionalFields.None) : null;
            Tags           = song.Tags.ActiveUsages.Select(u => new TagUsageForApiContract(u, languagePreference)).OrderByDescending(t => t.Count).ToArray();
            TranslatedName = new TranslatedStringContract(song.TranslatedName);
            WebLinks       = song.WebLinks.Select(w => new WebLinkContract(w)).OrderBy(w => w.DescriptionOrUrl).ToArray();

            Pools = pools;
        }
		public SongDetailsContract(Song song, ContentLanguagePreference languagePreference) {

			Song = new SongContract(song, languagePreference);

			AdditionalNames = string.Join(", ", song.AllNames.Where(n => n != Song.Name).Distinct());
			Albums = song.Albums.Select(a => new AlbumContract(a.Album, languagePreference)).Distinct().OrderBy(a => a.Name).ToArray();
			AlternateVersions = song.AlternateVersions.Select(s => new SongContract(s, languagePreference)).ToArray();
			Artists = song.Artists.Select(a => new ArtistForSongContract(a, languagePreference)).OrderBy(a => a.Name).ToArray();
			ArtistString = song.ArtistString[languagePreference];
			CreateDate = song.CreateDate;
			Deleted = song.Deleted;
			LikeCount = song.UserFavorites.Count(f => f.Rating == SongVoteRating.Like);
			LyricsFromParents = song.LyricsFromParents.Select(l => new LyricsForSongContract(l)).ToArray();
			Notes = song.Notes;
			OriginalVersion = (song.OriginalVersion != null && !song.OriginalVersion.Deleted ? new SongContract(song.OriginalVersion, languagePreference) : null);

			// TODO (PERF): this might be handled through a special query if the list is long
			Pools =
				song.ListLinks
				.Where(l => l.List.FeaturedCategory == SongListFeaturedCategory.Pools)
				.OrderBy(l => l.List.Name).Take(3)
				.Select(l => new SongListBaseContract(l.List))
				.ToArray();

			ListCount = song.ListLinks.Count;

			PVs = song.PVs.Select(p => new PVContract(p)).ToArray();
			Tags = song.Tags.Usages.Select(u => new TagUsageContract(u)).OrderByDescending(t => t.Count).ToArray();
			TranslatedName = new TranslatedStringContract(song.TranslatedName);
			WebLinks = song.WebLinks.Select(w => new WebLinkContract(w)).OrderBy(w => w.DescriptionOrUrl).ToArray();

		}
 public ReleaseEventSeriesDetailsContract(ReleaseEventSeries series, ContentLanguagePreference languagePreference)
     : base(series, languagePreference)
 {
     Tags           = series.Tags.ActiveUsages.Select(u => new TagUsageForApiContract(u, languagePreference)).OrderByDescending(t => t.Count).ToArray();
     TranslatedName = new TranslatedStringContract(series.TranslatedName);
     WebLinks       = series.WebLinks.Select(w => new WebLinkContract(w)).OrderBy(w => w.DescriptionOrUrl).ToArray();
 }
Beispiel #4
0
        public SongDetailsContract(Song song, ContentLanguagePreference languagePreference)
        {
            Song = new SongContract(song, languagePreference);

            AdditionalNames   = string.Join(", ", song.AllNames.Where(n => n != Song.Name).Distinct());
            Albums            = song.Albums.Select(a => new AlbumContract(a.Album, languagePreference)).Distinct().OrderBy(a => a.Name).ToArray();
            AlternateVersions = song.AlternateVersions.Select(s => new SongContract(s, languagePreference)).ToArray();
            Artists           = song.Artists.Select(a => new ArtistForSongContract(a, languagePreference)).OrderBy(a => a.Name).ToArray();
            ArtistString      = song.ArtistString[languagePreference];
            CreateDate        = song.CreateDate;
            Deleted           = song.Deleted;
            LikeCount         = song.UserFavorites.Count(f => f.Rating == SongVoteRating.Like);
            LyricsFromParents = song.LyricsFromParents.Select(l => new LyricsForSongContract(l)).ToArray();
            Notes             = song.Notes;
            OriginalVersion   = (song.OriginalVersion != null && !song.OriginalVersion.Deleted ? new SongContract(song.OriginalVersion, languagePreference) : null);

            // TODO (PERF): this might be handled through a special query if the list is long
            Pools =
                song.ListLinks
                .Where(l => l.List.FeaturedCategory == SongListFeaturedCategory.Pools)
                .OrderBy(l => l.List.Name).Take(3)
                .Select(l => new SongListBaseContract(l.List))
                .ToArray();

            ListCount = song.ListLinks.Count;

            PVs            = song.PVs.Select(p => new PVContract(p)).ToArray();
            Tags           = song.Tags.Usages.Select(u => new TagUsageContract(u)).OrderByDescending(t => t.Count).ToArray();
            TranslatedName = new TranslatedStringContract(song.TranslatedName);
            WebLinks       = song.WebLinks.Select(w => new WebLinkContract(w)).OrderBy(w => w.DescriptionOrUrl).ToArray();
        }
Beispiel #5
0
        public SongDetailsContract(Song song, ContentLanguagePreference languagePreference,
                                   SongListBaseContract[] pools, ISpecialTags specialTags, IUserPermissionContext userContext, IEntryThumbPersister thumbPersister)
        {
            Song = new SongContract(song, languagePreference);

            AdditionalNames            = song.Names.GetAdditionalNamesStringForLanguage(languagePreference);
            Albums                     = song.OnAlbums.OrderBy(a => a.OriginalReleaseDate.SortableDateTime).Select(a => new AlbumContract(a, languagePreference)).ToArray();
            AlternateVersions          = song.AlternateVersions.Select(s => new SongContract(s, languagePreference, getThumbUrl: false)).OrderBy(s => s.PublishDate).ToArray();
            Artists                    = song.Artists.Select(a => new ArtistForSongContract(a, languagePreference)).OrderBy(a => a.Name).ToArray();
            ArtistString               = song.ArtistString[languagePreference];
            CanEditPersonalDescription = EntryPermissionManager.CanEditPersonalDescription(userContext, song);
            CanRemoveTagUsages         = EntryPermissionManager.CanRemoveTagUsages(userContext, song);
            CreateDate                 = song.CreateDate;
            Deleted                    = song.Deleted;
            LikeCount                  = song.UserFavorites.Count(f => f.Rating == SongVoteRating.Like);
            LyricsFromParents          = song.GetLyricsFromParents(specialTags).Select(l => new LyricsForSongContract(l, false)).ToArray();
            Notes           = song.Notes;
            OriginalVersion = (song.OriginalVersion != null && !song.OriginalVersion.Deleted ?
                               new SongForApiContract(song.OriginalVersion, null, languagePreference, SongOptionalFields.AdditionalNames | SongOptionalFields.ThumbUrl) : null);

            PVs                     = song.PVs.Select(p => new PVContract(p)).ToArray();
            ReleaseEvent            = song.ReleaseEvent != null && !song.ReleaseEvent.Deleted ? new ReleaseEventForApiContract(song.ReleaseEvent, languagePreference, ReleaseEventOptionalFields.None, thumbPersister, true) : null;
            PersonalDescriptionText = song.PersonalDescriptionText;
            var author = song.PersonalDescriptionAuthor;

            PersonalDescriptionAuthor = author != null ? new ArtistForApiContract(author, languagePreference, thumbPersister, true, ArtistOptionalFields.MainPicture) : null;
            SubjectsFromParents       = song.GetCharactersFromParents().Select(c => new ArtistForSongContract(c, languagePreference)).ToArray();
            Tags           = song.Tags.ActiveUsages.Select(u => new TagUsageForApiContract(u, languagePreference)).OrderByDescending(t => t.Count).ToArray();
            TranslatedName = new TranslatedStringContract(song.TranslatedName);
            WebLinks       = song.WebLinks.Select(w => new WebLinkContract(w)).OrderBy(w => w.DescriptionOrUrl).ToArray();

            Pools = pools;
        }
        public ArtistDetailsContract(Artist artist, ContentLanguagePreference languagePreference)
            : base(artist, languagePreference)
        {
            AllNames       = string.Join(", ", artist.AllNames.Where(n => n != Name));
            BaseVoicebank  = artist.BaseVoicebank != null ? new ArtistContract(artist.BaseVoicebank, languagePreference) : null;
            CreateDate     = artist.CreateDate;
            Description    = artist.Description;
            Draft          = artist.Status == EntryStatus.Draft;
            TranslatedName = new TranslatedStringContract(artist.TranslatedName);
            LatestAlbums   = new AlbumContract[] {};
            LatestSongs    = new SongForApiContract[] {};
            OwnerUsers     = artist.OwnerUsers.Select(u => new UserContract(u.User)).ToArray();
            Pictures       = artist.Pictures.Select(p => new EntryPictureFileContract(p)).ToArray();
            TopAlbums      = new AlbumContract[] {};
            TopSongs       = new SongForApiContract[] {};
            WebLinks       = artist.WebLinks.Select(w => new WebLinkContract(w)).OrderBy(w => w.DescriptionOrUrl).ToArray();

            CharacterDesigner = artist.ArtistLinksOfType(ArtistLinkType.CharacterDesigner, LinkDirection.ManyToOne, allowInheritance: true)
                                .Select(g => new ArtistContract(g, languagePreference)).FirstOrDefault();


            ChildVoicebanks = artist.CanHaveChildVoicebanks ? artist.ChildVoicebanks.Where(c => !c.Deleted)
                              .Select(c => new ArtistContract(c, languagePreference)).ToArray() : new ArtistContract[0];

            Groups = artist.ArtistLinksOfType(ArtistLinkType.Group, LinkDirection.ManyToOne)
                     .Select(g => new ArtistContract(g, languagePreference)).OrderBy(g => g.Name).ToArray();

            Illustrators = artist.ArtistLinksOfType(ArtistLinkType.Illustrator, LinkDirection.ManyToOne, allowInheritance: true)
                           .Select(g => new ArtistContract(g, languagePreference)).ToArray();

            IllustratorOf = artist.ArtistLinksOfType(ArtistLinkType.Illustrator, LinkDirection.OneToMany)
                            .Select(g => new ArtistContract(g, languagePreference)).OrderBy(a => a.Name).ToArray();

            Manager = artist.ArtistLinksOfType(ArtistLinkType.Manager, LinkDirection.ManyToOne, allowInheritance: true)
                      .Select(g => new ArtistContract(g, languagePreference)).FirstOrDefault();

            Members = artist.ArtistLinksOfType(ArtistLinkType.Group, LinkDirection.OneToMany)
                      .Select(g => new ArtistContract(g, languagePreference)).OrderBy(g => g.Name).ToArray();

            Tags = artist.Tags.ActiveUsages
                   .Select(u => new TagUsageForApiContract(u, languagePreference))
                   .OrderByDescending(t => t.Count).ToArray();

            VoiceProvider = artist.ArtistLinksOfType(ArtistLinkType.VoiceProvider, LinkDirection.ManyToOne, allowInheritance: true)
                            .Select(g => new ArtistContract(g, languagePreference)).FirstOrDefault();

            Voicebanks = artist.ArtistLinksOfType(ArtistLinkType.VoiceProvider, LinkDirection.OneToMany)
                         .Select(g => new ArtistContract(g, languagePreference)).OrderBy(a => a.Name).ToArray();
        }
        public ArchivedArtistContract(Artist artist, ArtistDiff diff)
        {
            ParamIs.NotNull(() => artist);

            Albums = (diff.IncludeAlbums ? artist.Albums.Select(a => new ObjectRefContract(a.Album)).ToArray() : null);
            ArtistType = artist.ArtistType;
            Id = artist.Id;
            Description = (diff.IncludeDescription ? artist.Description : null);
            Groups = artist.Groups.Select(g => new ObjectRefContract(g.Group)).ToArray();
            Members = artist.Members.Select(m => new ObjectRefContract(m.Member)).ToArray();
            Names = (diff.IncludeNames ? artist.Names.Names.Select(n => new LocalizedStringContract(n)).ToArray() : null);
            Pictures = (diff.IncludePictures ? artist.Pictures.Select(p => new ArchivedEntryPictureFileContract(p)).ToArray() : null);
            TranslatedName = new TranslatedStringContract(artist.TranslatedName);
            WebLinks = (diff.IncludeWebLinks ? artist.WebLinks.Select(l => new ArchivedWebLinkContract(l)).ToArray() : null);
        }
        public ArchivedArtistContract(Artist artist, ArtistDiff diff)
        {
            ParamIs.NotNull(() => artist);

            Albums         = (diff.IncludeAlbums ? artist.Albums.Select(a => new ObjectRefContract(a.Album)).ToArray() : null);
            ArtistType     = artist.ArtistType;
            Id             = artist.Id;
            Description    = (diff.IncludeDescription ? artist.Description : null);
            Groups         = artist.Groups.Select(g => new ObjectRefContract(g.Group)).ToArray();
            Members        = artist.Members.Select(m => new ObjectRefContract(m.Member)).ToArray();
            Names          = (diff.IncludeNames ? artist.Names.Names.Select(n => new LocalizedStringContract(n)).ToArray() : null);
            Pictures       = (diff.IncludePictures ? artist.Pictures.Select(p => new ArchivedEntryPictureFileContract(p)).ToArray() : null);
            TranslatedName = new TranslatedStringContract(artist.TranslatedName);
            WebLinks       = (diff.IncludeWebLinks ? artist.WebLinks.Select(l => new ArchivedWebLinkContract(l)).ToArray() : null);
        }
        public ArchivedAlbumContract(Album album, AlbumDiff diff)
        {
            ParamIs.NotNull(() => album);
            ParamIs.NotNull(() => diff);

            Artists = (diff.IncludeArtists ? album.Artists.Select(a => new ArchivedArtistForAlbumContract(a)).ToArray() : null);
            Description = (diff.IncludeDescription ? album.Description : null);
            DiscType = album.DiscType;
            Id = album.Id;
            OriginalRelease = (album.OriginalRelease != null && !album.OriginalRelease.IsEmpty ? new ArchivedAlbumReleaseContract(album.OriginalRelease) : null);
            Pictures = (diff.IncludePictures ? album.Pictures.Select(p => new ArchivedEntryPictureFileContract(p)).ToArray() : null);
            PVs = (diff.IncludePVs ? album.PVs.Select(p => new ArchivedPVContract(p)).ToArray() : null);
            Names = (diff.IncludeNames ? album.Names.Names.Select(n => new LocalizedStringContract(n)).ToArray() : null);
            Songs = (diff.IncludeTracks ? album.Songs.Select(s => new SongInAlbumRefContract(s)).ToArray() : null);
            TranslatedName = new TranslatedStringContract(album.TranslatedName);
            WebLinks = (diff.IncludeWebLinks ? album.WebLinks.Select(l => new ArchivedWebLinkContract(l)).ToArray() : null);
        }
Beispiel #10
0
        public ArchivedAlbumContract(Album album, AlbumDiff diff)
        {
            ParamIs.NotNull(() => album);
            ParamIs.NotNull(() => diff);

            Artists         = (diff.IncludeArtists ? album.Artists.Select(a => new ArchivedArtistForAlbumContract(a)).ToArray() : null);
            Description     = (diff.IncludeDescription ? album.Description : null);
            DiscType        = album.DiscType;
            Id              = album.Id;
            OriginalRelease = (album.OriginalRelease != null && !album.OriginalRelease.IsEmpty ? new ArchivedAlbumReleaseContract(album.OriginalRelease) : null);
            Pictures        = (diff.IncludePictures ? album.Pictures.Select(p => new ArchivedEntryPictureFileContract(p)).ToArray() : null);
            PVs             = (diff.IncludePVs ? album.PVs.Select(p => new ArchivedPVContract(p)).ToArray() : null);
            Names           = (diff.IncludeNames ? album.Names.Names.Select(n => new LocalizedStringContract(n)).ToArray() : null);
            Songs           = (diff.IncludeTracks ? album.Songs.Select(s => new SongInAlbumRefContract(s)).ToArray() : null);
            TranslatedName  = new TranslatedStringContract(album.TranslatedName);
            WebLinks        = (diff.IncludeWebLinks ? album.WebLinks.Select(l => new ArchivedWebLinkContract(l)).ToArray() : null);
        }
Beispiel #11
0
        public ArchivedArtistContract(Artist artist, ArtistDiff diff)
        {
            ParamIs.NotNull(() => artist);

            ArtistType      = artist.ArtistType;
            BaseVoicebank   = ObjectRefContract.Create(artist.BaseVoicebank);
            Id              = artist.Id;
            Description     = (diff.IncludeDescription ? artist.Description.Original : null);
            DescriptionEng  = (diff.IncludeDescription ? artist.Description.English : null);
            Groups          = artist.Groups.Select(g => new ArchivedArtistForArtistContract(g)).ToArray();
            MainPictureMime = artist.PictureMime;
            Members         = artist.Members.Select(m => new ObjectRefContract(m.Member)).ToArray();
            Names           = (diff.IncludeNames ? artist.Names.Names.Select(n => new LocalizedStringContract(n)).ToArray() : null);
            Pictures        = (diff.IncludePictures ? artist.Pictures.Select(p => new ArchivedEntryPictureFileContract(p)).ToArray() : null);
            ReleaseDate     = artist.ReleaseDate;
            TranslatedName  = new TranslatedStringContract(artist.TranslatedName);
            WebLinks        = (diff.IncludeWebLinks ? artist.WebLinks.Select(l => new ArchivedWebLinkContract(l)).ToArray() : null);
        }
Beispiel #12
0
 public AlbumForEditContract(Album album, ContentLanguagePreference languagePreference)
     : base(album, languagePreference)
 {
     ArtistLinks     = album.Artists.Select(a => new ArtistForAlbumContract(a, languagePreference)).OrderBy(a => a.Name).ToArray();
     Deleted         = album.Deleted;
     Description     = album.Description;
     Names           = new NameManagerEditContract(album.Names);
     OriginalRelease = (album.OriginalRelease != null ? new AlbumReleaseContract(album.OriginalRelease) : null);
     Pictures        = album.Pictures.Select(p => new EntryPictureFileContract(p)).ToArray();
     PVs             = album.PVs.Select(p => new PVContract(p)).ToArray();
     Songs           = album.Songs
                       .OrderBy(s => s.TrackNumber).OrderBy(s => s.DiscNumber)
                       .Select(s => new SongInAlbumEditContract(s, languagePreference)).ToArray();
     TranslatedName   = new TranslatedStringContract(album.TranslatedName);
     UpdateNotes      = string.Empty;
     ValidationResult = AlbumValidator.Validate(album);
     WebLinks         = album.WebLinks.Select(w => new WebLinkContract(w)).OrderBy(w => w.DescriptionOrUrl).ToArray();
 }
 public AlbumForEditContract(Album album, ContentLanguagePreference languagePreference)
     : base(album, languagePreference)
 {
     ArtistLinks = album.Artists.Select(a => new ArtistForAlbumContract(a, languagePreference)).OrderBy(a => a.Name).ToArray();
     Deleted = album.Deleted;
     Description = album.Description;
     Names = new NameManagerEditContract(album.Names);
     OriginalRelease = (album.OriginalRelease != null ? new AlbumReleaseContract(album.OriginalRelease) : null);
     Pictures = album.Pictures.Select(p => new EntryPictureFileContract(p)).ToArray();
     PVs = album.PVs.Select(p => new PVContract(p)).ToArray();
     Songs = album.Songs
         .OrderBy(s => s.TrackNumber).OrderBy(s => s.DiscNumber)
         .Select(s => new SongInAlbumEditContract(s, languagePreference)).ToArray();
     TranslatedName = new TranslatedStringContract(album.TranslatedName);
     UpdateNotes = string.Empty;
     ValidationResult = AlbumValidator.Validate(album);
     WebLinks = album.WebLinks.Select(w => new WebLinkContract(w)).OrderBy(w => w.DescriptionOrUrl).ToArray();
 }
        public ReleaseEventDetailsContract(ReleaseEvent releaseEvent, ContentLanguagePreference languagePreference,
                                           IUserPermissionContext userContext, IUserIconFactory userIconFactory, IEntryTypeTagRepository entryTypeTags = null)
            : base(releaseEvent, languagePreference, true, true)
        {
            ParamIs.NotNull(() => releaseEvent);

            CanRemoveTagUsages  = EntryPermissionManager.CanRemoveTagUsages(userContext, releaseEvent);
            DefaultNameLanguage = releaseEvent.TranslatedName.DefaultLanguage;
            PVs            = releaseEvent.PVs.Select(p => new PVContract(p)).ToArray();
            SeriesNumber   = releaseEvent.SeriesNumber;
            SeriesSuffix   = releaseEvent.SeriesSuffix;
            Tags           = releaseEvent.Tags.ActiveUsages.Select(u => new TagUsageForApiContract(u, languagePreference)).OrderByDescending(t => t.Count).ToArray();
            TranslatedName = new TranslatedStringContract(releaseEvent.TranslatedName);
            WebLinks       = releaseEvent.WebLinks.Select(w => new WebLinkContract(w)).OrderBy(w => w.DescriptionOrUrl).ToArray();

            var categoryTag = entryTypeTags?.GetTag(Domain.EntryType.ReleaseEvent, InheritedCategory);

            InheritedCategoryTag = categoryTag != null ? new TagBaseContract(categoryTag, languagePreference) : null;

            Albums = releaseEvent.Albums
                     .Select(a => new AlbumContract(a, languagePreference))
                     .OrderBy(a => a.Name)
                     .ToArray();

            Artists = releaseEvent.AllArtists
                      .Select(a => new ArtistForEventContract(a, languagePreference))
                      .OrderBy(a => a.Artist != null ? a.Artist.Name : a.Name)
                      .ToArray();

            Songs = releaseEvent.Songs
                    .Select(s => new SongForApiContract(s, languagePreference, SongOptionalFields.AdditionalNames | SongOptionalFields.ThumbUrl))
                    .OrderBy(s => s.Name)
                    .ToArray();

            UsersAttending = releaseEvent.Users
                             .Where(u => u.RelationshipType == UserEventRelationshipType.Attending)
                             .Select(u => new UserForApiContract(u.User, userIconFactory, UserOptionalFields.MainPicture))
                             .ToArray();

            if (releaseEvent.SongList != null)
            {
                SongListSongs = releaseEvent.SongList.SongLinks.OrderBy(s => s.Order).Select(s => new SongInListContract(s, languagePreference)).ToArray();
            }
        }
Beispiel #15
0
 public ArtistDetailsContract(Artist artist, ContentLanguagePreference languagePreference)
     : base(artist, languagePreference)
 {
     AllNames       = string.Join(", ", artist.AllNames.Where(n => n != Name));
     CreateDate     = artist.CreateDate;
     Description    = artist.Description;
     Draft          = artist.Status == EntryStatus.Draft;
     FollowCount    = artist.Users.Count;
     Groups         = artist.Groups.Select(g => new GroupForArtistContract(g, languagePreference)).OrderBy(g => g.Group.Name).ToArray();
     TranslatedName = new TranslatedStringContract(artist.TranslatedName);
     LatestAlbums   = new AlbumContract[] {};
     LatestSongs    = new SongContract[] {};
     Members        = artist.Members.Select(m => new GroupForArtistContract(m, languagePreference)).OrderBy(a => a.Member.Name).ToArray();
     OwnerUsers     = artist.OwnerUsers.Select(u => new UserContract(u.User)).ToArray();
     Pictures       = artist.Pictures.Select(p => new EntryPictureFileContract(p)).ToArray();
     Tags           = artist.Tags.Usages.Select(u => new TagUsageContract(u)).OrderByDescending(t => t.Count).ToArray();
     TopAlbums      = new AlbumContract[] {};
     TopSongs       = new SongContract[] {};
     WebLinks       = artist.WebLinks.Select(w => new WebLinkContract(w)).OrderBy(w => w.DescriptionOrUrl).ToArray();
 }
 public ArtistDetailsContract(Artist artist, ContentLanguagePreference languagePreference)
     : base(artist, languagePreference)
 {
     AllNames = string.Join(", ", artist.AllNames.Where(n => n != Name));
     CreateDate = artist.CreateDate;
     Description = artist.Description;
     Draft = artist.Status == EntryStatus.Draft;
     FollowCount = artist.Users.Count;
     Groups = artist.Groups.Select(g => new GroupForArtistContract(g, languagePreference)).OrderBy(g => g.Group.Name).ToArray();
     TranslatedName = new TranslatedStringContract(artist.TranslatedName);
     LatestAlbums = new AlbumContract[] {};
     LatestSongs = new SongContract[] {};
     Members = artist.Members.Select(m => new GroupForArtistContract(m, languagePreference)).OrderBy(a => a.Member.Name).ToArray();
     OwnerUsers = artist.OwnerUsers.Select(u => new UserContract(u.User)).ToArray();
     Pictures = artist.Pictures.Select(p => new EntryPictureFileContract(p)).ToArray();
     Tags = artist.Tags.Usages.Select(u => new TagUsageContract(u)).OrderByDescending(t => t.Count).ToArray();
     TopAlbums = new AlbumContract[] {};
     TopSongs = new SongContract[] {};
     WebLinks = artist.WebLinks.Select(w => new WebLinkContract(w)).OrderBy(w => w.DescriptionOrUrl).ToArray();
 }
        public ArtistForEditContract(Artist artist, ContentLanguagePreference languagePreference)
            : base(artist, languagePreference)
        {
            /*if (artist.Albums.Count() <= MaxAlbums)
                AlbumLinks = artist.Albums.Select(a => new AlbumForArtistEditContract(a, languagePreference)).OrderBy(a => a.AlbumName).ToArray();
            else {
                TooManyAlbums = true;
            }*/

            AllNames = string.Join(", ", artist.AllNames.Where(n => n != Name));
            Description = artist.Description;
            Groups = artist.Groups.Select(g => new GroupForArtistContract(g, languagePreference)).OrderBy(g => g.Group.Name).ToArray();
            TranslatedName = new TranslatedStringContract(artist.TranslatedName);
            Members = artist.Members.Select(m => new GroupForArtistContract(m, languagePreference)).OrderBy(a => a.Member.Name).ToArray();
            Names = new NameManagerEditContract(artist.Names);
            Pictures = artist.Pictures.Select(p => new EntryPictureFileContract(p)).ToArray();
            UpdateNotes = string.Empty;
            ValidationResult = ArtistValidator.Validate(artist);
            WebLinks = artist.WebLinks.Select(w => new WebLinkContract(w)).OrderBy(w => w.DescriptionOrUrl).ToArray();
        }
Beispiel #18
0
        public ArtistForEditContract(Artist artist, ContentLanguagePreference languagePreference)
            : base(artist, languagePreference)
        {
            /*if (artist.Albums.Count() <= MaxAlbums)
             *      AlbumLinks = artist.Albums.Select(a => new AlbumForArtistEditContract(a, languagePreference)).OrderBy(a => a.AlbumName).ToArray();
             * else {
             *      TooManyAlbums = true;
             * }*/

            AllNames         = string.Join(", ", artist.AllNames.Where(n => n != Name));
            Description      = artist.Description;
            Groups           = artist.Groups.Select(g => new GroupForArtistContract(g, languagePreference)).OrderBy(g => g.Group.Name).ToArray();
            TranslatedName   = new TranslatedStringContract(artist.TranslatedName);
            Members          = artist.Members.Select(m => new GroupForArtistContract(m, languagePreference)).OrderBy(a => a.Member.Name).ToArray();
            Names            = new NameManagerEditContract(artist.Names);
            Pictures         = artist.Pictures.Select(p => new EntryPictureFileContract(p)).ToArray();
            UpdateNotes      = string.Empty;
            ValidationResult = ArtistValidator.Validate(artist);
            WebLinks         = artist.WebLinks.Select(w => new WebLinkContract(w)).OrderBy(w => w.DescriptionOrUrl).ToArray();
        }
Beispiel #19
0
        public ArtistDetailsContract(Artist artist, ContentLanguagePreference languagePreference, IUserPermissionContext userContext, IEntryImagePersister imageStore)
            : base(artist, languagePreference)
        {
            AllNames           = string.Join(", ", artist.AllNames.Where(n => n != Name));
            BaseVoicebank      = artist.BaseVoicebank != null ? new ArtistContract(artist.BaseVoicebank, languagePreference) : null;
            CanRemoveTagUsages = EntryPermissionManager.CanRemoveTagUsages(userContext, artist);
            CreateDate         = artist.CreateDate;
            Description        = artist.Description;
            Draft          = artist.Status == EntryStatus.Draft;
            TranslatedName = new TranslatedStringContract(artist.TranslatedName);
            LatestAlbums   = new AlbumForApiContract[] {};
            LatestSongs    = new SongForApiContract[] {};
            OwnerUsers     = artist.OwnerUsers.Select(u => new UserContract(u.User)).ToArray();
            Pictures       = artist.Pictures.Select(p => new EntryPictureFileContract(p, imageStore)).ToArray();
            TopAlbums      = new AlbumForApiContract[] {};
            TopSongs       = new SongForApiContract[] {};
            WebLinks       = artist.WebLinks.Select(w => new WebLinkContract(w)).OrderBy(w => w.DescriptionOrUrl).ToArray();

            CharacterDesigner = artist.ArtistLinksOfType(ArtistLinkType.CharacterDesigner, LinkDirection.ManyToOne, allowInheritance: true)
                                .Select(g => new ArtistContract(g, languagePreference)).FirstOrDefault();

            CharacterDesignerOf = artist.ArtistLinksOfType(ArtistLinkType.CharacterDesigner, LinkDirection.OneToMany)
                                  .Select(g => new ArtistContract(g, languagePreference)).OrderBy(a => a.Name).ToArray();

            if (artist.CanHaveChildVoicebanks)
            {
                var children = artist.ChildVoicebanks
                               .Where(c => !c.Deleted)
                               .Select(c => new ArtistContract(c, languagePreference))
                               .ToArray();

                // Show child voicebanks with release date first
                ChildVoicebanks = children
                                  .Where(c => c.ReleaseDate.HasValue)
                                  .OrderBy(c => c.ReleaseDate)
                                  .Concat(children.Where(c => !c.ReleaseDate.HasValue))
                                  .ToArray();
            }
            else
            {
                ChildVoicebanks = new ArtistContract[0];
            }

            Groups = artist.ArtistLinksOfType(ArtistLinkType.Group, LinkDirection.ManyToOne)
                     .Select(g => new ArtistContract(g, languagePreference)).OrderBy(g => g.Name).ToArray();

            Illustrators = artist.ArtistLinksOfType(ArtistLinkType.Illustrator, LinkDirection.ManyToOne, allowInheritance: true)
                           .Select(g => new ArtistContract(g, languagePreference)).ToArray();

            IllustratorOf = artist.ArtistLinksOfType(ArtistLinkType.Illustrator, LinkDirection.OneToMany)
                            .Select(g => new ArtistContract(g, languagePreference)).OrderBy(a => a.Name).ToArray();

            Manager = artist.ArtistLinksOfType(ArtistLinkType.Manager, LinkDirection.ManyToOne, allowInheritance: true)
                      .Select(g => new ArtistContract(g, languagePreference)).FirstOrDefault();

            Members = artist.ArtistLinksOfType(ArtistLinkType.Group, LinkDirection.OneToMany)
                      .Select(g => new ArtistContract(g, languagePreference)).OrderBy(g => g.Name).ToArray();

            Tags = artist.Tags.ActiveUsages
                   .Select(u => new TagUsageForApiContract(u, languagePreference))
                   .OrderByDescending(t => t.Count).ToArray();

            VoiceProviders = artist.ArtistLinksOfType(ArtistLinkType.VoiceProvider, LinkDirection.ManyToOne, allowInheritance: true)
                             .Select(g => new ArtistContract(g, languagePreference)).OrderBy(a => a.Name).ToArray();

            Voicebanks = artist.ArtistLinksOfType(ArtistLinkType.VoiceProvider, LinkDirection.OneToMany)
                         .Select(g => new ArtistContract(g, languagePreference)).OrderBy(a => a.Name).ToArray();
        }