Example #1
0
        public AlbumForApiContract(Album album, AlbumMergeRecord mergeRecord, ContentLanguagePreference languagePreference,
                                   bool artists = true, bool names = true, bool pvs = false, bool tags = true, bool webLinks = false)
        {
            ArtistString        = album.ArtistString[languagePreference];
            CatalogNumber       = album.OriginalRelease != null ? album.OriginalRelease.CatNum : null;
            CreateDate          = album.CreateDate;
            DefaultName         = album.DefaultName;
            DefaultNameLanguage = album.Names.SortNames.DefaultLanguage;
            DiscType            = album.DiscType;
            Id            = album.Id;
            Name          = album.Names.SortNames[languagePreference];
            RatingAverage = album.RatingAverage;
            RatingCount   = album.RatingCount;
            ReleaseDate   = new OptionalDateTimeContract(album.OriginalReleaseDate);
            ReleaseEvent  = album.OriginalReleaseEventName;
            Status        = album.Status;
            Version       = album.Version;

            if (languagePreference != ContentLanguagePreference.Default)
            {
                LocalizedName = album.Names.SortNames[languagePreference];
            }

            if (artists)
            {
                Artists = album.Artists.Select(a => new ArtistForAlbumForApiContract(a, languagePreference)).ToArray();
            }

            if (names)
            {
                Names = album.Names.Select(n => new LocalizedStringContract(n)).ToArray();
            }

            if (pvs)
            {
                PVs = album.PVs.Select(p => new PVContract(p)).ToArray();
            }

            if (tags)
            {
                Tags = album.Tags.Usages.Select(u => new TagUsageForApiContract(u)).ToArray();
            }

            if (webLinks)
            {
                WebLinks = album.WebLinks.Select(w => new WebLinkContract(w)).ToArray();
            }

            if (mergeRecord != null)
            {
                MergedTo = mergeRecord.Target.Id;
            }
        }
Example #2
0
        public AlbumContract(Album album, ContentLanguagePreference languagePreference)
        {
            ParamIs.NotNull(() => album);

            AdditionalNames = album.Names.GetAdditionalNamesStringForLanguage(languagePreference);
            ArtistString    = album.ArtistString.GetBestMatch(languagePreference);
            CreateDate      = album.CreateDate;
            DiscType        = album.DiscType;
            Id            = album.Id;
            Name          = album.TranslatedName[languagePreference];
            RatingAverage = album.RatingAverage;
            RatingCount   = album.RatingCount;
            ReleaseDate   = new OptionalDateTimeContract(album.OriginalReleaseDate);
            ReleaseEvent  = album.OriginalReleaseEventName;
            Status        = album.Status;
            Version       = album.Version;
        }
Example #3
0
        public AlbumForApiContract(Album album, ContentLanguagePreference languagePreference)
        {
            Artists = album.Artists.Select(a => new ArtistForAlbumForApiContract(a, languagePreference)).ToArray();
            Tags    = album.Tags.Tags.Select(t => t.Name).ToArray();

            CreateDate          = album.CreateDate;
            DefaultName         = album.DefaultName;
            DefaultNameLanguage = album.Names.SortNames.DefaultLanguage;
            DiscType            = album.DiscType;
            Id            = album.Id;
            Names         = album.Names.Select(n => new LocalizedStringContract(n)).ToArray();
            RatingAverage = album.RatingAverage;
            RatingCount   = album.RatingCount;
            ReleaseDate   = new OptionalDateTimeContract(album.OriginalReleaseDate);
            ReleaseEvent  = album.OriginalReleaseEventName;
            Status        = album.Status;
            Version       = album.Version;
        }
        public AlbumForApiContract(Album album, ContentLanguagePreference languagePreference)
        {
            Artists = album.Artists.Select(a => new ArtistForAlbumForApiContract(a, languagePreference)).ToArray();
            Tags = album.Tags.Tags.Select(t => t.Name).ToArray();

            CreateDate = album.CreateDate;
            DefaultName = album.DefaultName;
            DefaultNameLanguage = album.Names.SortNames.DefaultLanguage;
            DiscType = album.DiscType;
            Id = album.Id;
            Names = album.Names.Select(n => new LocalizedStringContract(n)).ToArray();
            RatingAverage = album.RatingAverage;
            RatingCount = album.RatingCount;
            ReleaseDate = new OptionalDateTimeContract(album.OriginalReleaseDate);
            ReleaseEvent = album.OriginalReleaseEventName;
            Status = album.Status;
            Version = album.Version;
        }
Example #5
0
        public AlbumContract(Album album, ContentLanguagePreference languagePreference)
        {
            ParamIs.NotNull(() => album);

            AdditionalNames  = album.Names.GetAdditionalNamesStringForLanguage(languagePreference);
            ArtistString     = album.ArtistString.GetBestMatch(languagePreference);
            CoverPictureMime = album.CoverPictureMime;
            CreateDate       = album.CreateDate;
            Deleted          = album.Deleted;
            DiscType         = album.DiscType;
            Id            = album.Id;
            Name          = album.TranslatedName[languagePreference];
            RatingAverage = album.RatingAverage;
            RatingCount   = album.RatingCount;
            ReleaseDate   = new OptionalDateTimeContract(album.OriginalReleaseDate);
            ReleaseEvent  = album.OriginalReleaseEvent != null ? new ReleaseEventForApiContract(album.OriginalReleaseEvent, languagePreference, ReleaseEventOptionalFields.None, null, false) : null;
            Status        = album.Status;
            Version       = album.Version;
        }
		public AlbumForApiContract(Album album, AlbumMergeRecord mergeRecord, ContentLanguagePreference languagePreference, 
			bool artists = true, bool names = true, bool pvs = false, bool tags = true, bool webLinks = false) {

			ArtistString = album.ArtistString[languagePreference];
			CatalogNumber = album.OriginalRelease != null ? album.OriginalRelease.CatNum : null;
			CreateDate = album.CreateDate;
			DefaultName = album.DefaultName;
			DefaultNameLanguage = album.Names.SortNames.DefaultLanguage;
			DiscType = album.DiscType;
			Id = album.Id;
			Name = album.Names.SortNames[languagePreference];				
			RatingAverage = album.RatingAverage;
			RatingCount = album.RatingCount;
			ReleaseDate = new OptionalDateTimeContract(album.OriginalReleaseDate);
			ReleaseEvent = album.OriginalReleaseEventName;
			Status = album.Status;
			Version = album.Version;

			if (languagePreference != ContentLanguagePreference.Default) {
				LocalizedName = album.Names.SortNames[languagePreference];				
			}

			if (artists)
				Artists = album.Artists.Select(a => new ArtistForAlbumForApiContract(a, languagePreference)).ToArray();

			if (names)
				Names = album.Names.Select(n => new LocalizedStringContract(n)).ToArray();

			if (pvs)
				PVs = album.PVs.Select(p => new PVContract(p)).ToArray();

			if (tags)
				Tags = album.Tags.Usages.Select(u => new TagUsageForApiContract(u)).ToArray();

			if (webLinks)
				WebLinks = album.WebLinks.Select(w => new WebLinkContract(w)).ToArray();

			if (mergeRecord != null)
				MergedTo = mergeRecord.Target.Id;

		}
Example #7
0
        public AlbumForApiContract(
            Album album, AlbumMergeRecord mergeRecord,
            ContentLanguagePreference languagePreference,
            IAggregatedEntryImageUrlFactory thumbPersister,
            AlbumOptionalFields fields,
            SongOptionalFields songFields)
        {
            ArtistString        = album.ArtistString[languagePreference];
            CatalogNumber       = album.OriginalRelease != null ? album.OriginalRelease.CatNum : null;
            CreateDate          = album.CreateDate;
            DefaultName         = album.DefaultName;
            DefaultNameLanguage = album.Names.SortNames.DefaultLanguage;
            DiscType            = album.DiscType;
            Id            = album.Id;
            Name          = album.Names.SortNames[languagePreference];
            RatingAverage = album.RatingAverage;
            RatingCount   = album.RatingCount;
            ReleaseDate   = new OptionalDateTimeContract(album.OriginalReleaseDate);
            Status        = album.Status;
            Version       = album.Version;

            if (fields.HasFlag(AlbumOptionalFields.AdditionalNames))
            {
                AdditionalNames = album.Names.GetAdditionalNamesStringForLanguage(languagePreference);
            }

            if (fields.HasFlag(AlbumOptionalFields.Artists))
            {
                Artists = album.Artists.Select(a => new ArtistForAlbumForApiContract(a, languagePreference)).ToArray();
            }

            if (fields.HasFlag(AlbumOptionalFields.Description))
            {
                Description = album.Description[languagePreference];
            }

            if (fields.HasFlag(AlbumOptionalFields.Discs))
            {
                Discs = album.Discs.Select(d => new AlbumDiscPropertiesContract(d)).ToArray();
            }

            if (fields.HasFlag(AlbumOptionalFields.Identifiers))
            {
                Identifiers = album.Identifiers.Select(i => new AlbumIdentifierContract(i)).ToArray();
            }

            if (thumbPersister != null && fields.HasFlag(AlbumOptionalFields.MainPicture) && album.Thumb != null)
            {
                MainPicture = new EntryThumbForApiContract(album.Thumb, thumbPersister);
            }

            if (fields.HasFlag(AlbumOptionalFields.Names))
            {
                Names = album.Names.Select(n => new LocalizedStringContract(n)).ToArray();
            }

            if (fields.HasFlag(AlbumOptionalFields.PVs))
            {
                PVs = album.PVs.Select(p => new PVContract(p)).ToArray();
            }

            if (fields.HasFlag(AlbumOptionalFields.ReleaseEvent))
            {
                ReleaseEvent = album.OriginalReleaseEvent != null ? new ReleaseEventForApiContract(album.OriginalReleaseEvent, languagePreference, ReleaseEventOptionalFields.None, thumbPersister) : null;
            }

            if (fields.HasFlag(AlbumOptionalFields.Tags))
            {
                Tags = album.Tags.ActiveUsages.Select(u => new TagUsageForApiContract(u, languagePreference)).ToArray();
            }

            if (fields.HasFlag(AlbumOptionalFields.Tracks))
            {
                Tracks = album.Songs.Select(s => new SongInAlbumForApiContract(s, languagePreference, songFields)).ToArray();
            }

            if (fields.HasFlag(AlbumOptionalFields.WebLinks))
            {
                WebLinks = album.WebLinks.Select(w => new WebLinkForApiContract(w)).ToArray();
            }

            if (mergeRecord != null)
            {
                MergedTo = mergeRecord.Target.Id;
            }
        }
 public static string FormatReleaseDate(OptionalDateTimeContract contract)
 {
     return(OptionalDateTime.ToDateTime(contract.Year, contract.Month, contract.Day).ToShortDateString());
 }