public SongForApiContract(Song song, SongMergeRecord mergeRecord, ContentLanguagePreference languagePreference, SongOptionalFields fields) {
			
			ArtistString = song.ArtistString[languagePreference];
			CreateDate = song.CreateDate;
			DefaultName = song.DefaultName;
			DefaultNameLanguage = song.Names.SortNames.DefaultLanguage;
			FavoritedTimes = song.FavoritedTimes;
			Id = song.Id;
			LengthSeconds = song.LengthSeconds;
			Name = song.Names.SortNames[languagePreference];
			PVServices = song.PVServices;
			RatingScore = song.RatingScore;
			SongType = song.SongType;
			Status = song.Status;
			Version = song.Version;

			if (languagePreference != ContentLanguagePreference.Default || fields.HasFlag(SongOptionalFields.AdditionalNames)) {
				AdditionalNames = song.Names.GetAdditionalNamesStringForLanguage(languagePreference);
			}

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

			if (fields.HasFlag(SongOptionalFields.Albums))
				Albums = song.Albums.Select(a => new AlbumContract(a.Album, languagePreference)).ToArray();

			if (fields.HasFlag(SongOptionalFields.Artists))
				Artists = song.Artists.Select(a => new ArtistForSongContract(a, languagePreference)).ToArray();

			if (fields.HasFlag(SongOptionalFields.Names))
				Names = song.Names.Select(n => new LocalizedStringContract(n)).ToArray();

			if (fields.HasFlag(SongOptionalFields.PVs))
				PVs = song.PVs.Select(p => new PVContract(p)).ToArray();

			if (fields.HasFlag(SongOptionalFields.Tags))
				Tags = song.Tags.Usages.Select(u => new TagUsageForApiContract(u)).ToArray();

			if (fields.HasFlag(SongOptionalFields.ThumbUrl))
				ThumbUrl = VideoServiceHelper.GetThumbUrl(song.PVs.PVs);

			if (fields.HasFlag(SongOptionalFields.WebLinks))
				WebLinks = song.WebLinks.Select(w => new WebLinkContract(w)).ToArray();

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


		}
Example #2
0
        public void Merge(int sourceId, int targetId)
        {
            PermissionContext.VerifyPermission(PermissionToken.MergeEntries);

            if (sourceId == targetId)
            {
                throw new ArgumentException("Source and target songs can't be the same", "targetId");
            }

            repository.HandleTransaction(ctx => {
                var source = ctx.Load(sourceId);
                var target = ctx.Load(targetId);

                ctx.AuditLogger.AuditLog(string.Format("Merging {0} to {1}",
                                                       entryLinkFactory.CreateEntryLink(source), entryLinkFactory.CreateEntryLink(target)));

                // Names
                foreach (var n in source.Names.Names.Where(n => !target.HasName(n)))
                {
                    var name = target.CreateName(n.Value, n.Language);
                    ctx.Save(name);
                }

                // Weblinks
                foreach (var w in source.WebLinks.Where(w => !target.HasWebLink(w.Url)))
                {
                    var link = target.CreateWebLink(w.Description, w.Url, w.Category);
                    ctx.Save(link);
                }

                // PVs
                var pvs = source.PVs.Where(a => !target.HasPV(a.Service, a.PVId));
                foreach (var p in pvs)
                {
                    var pv = target.CreatePV(new PVContract(p));
                    ctx.Save(pv);
                }

                // Artist links
                var artists = source.Artists.Where(a => !target.HasArtistLink(a)).ToArray();
                foreach (var a in artists)
                {
                    a.Move(target);
                    ctx.Update(a);
                }

                // Album links
                var albums = source.Albums.Where(s => !target.IsOnAlbum(s.Album)).ToArray();
                foreach (var s in albums)
                {
                    s.Move(target);
                    ctx.Update(s);
                }

                // Favorites
                var userFavorites = source.UserFavorites.Where(a => !target.IsFavoritedBy(a.User)).ToArray();
                foreach (var u in userFavorites)
                {
                    u.Move(target);
                    ctx.Update(u);
                }

                // Custom lists
                var songLists = source.ListLinks.ToArray();
                foreach (var s in songLists)
                {
                    s.ChangeSong(target);
                    ctx.Update(s);
                }

                // Other properties
                if (target.OriginalVersion == null)
                {
                    target.OriginalVersion = source.OriginalVersion;
                }

                var alternateVersions = source.AlternateVersions.ToArray();
                foreach (var alternate in alternateVersions)
                {
                    alternate.OriginalVersion = target;
                    ctx.Update(alternate);
                }

                if (target.LengthSeconds == 0)
                {
                    target.LengthSeconds = source.LengthSeconds;
                }

                target.Notes.CopyIfEmpty(source.Notes);

                if (target.PublishDate.IsEmpty)
                {
                    target.PublishDate = source.PublishDate;
                }

                // Create merge record
                var mergeEntry = new SongMergeRecord(source, target);
                ctx.Save(mergeEntry);

                source.Deleted = true;

                target.UpdateArtistString();
                target.UpdateNicoId();

                Archive(ctx, source, SongArchiveReason.Deleted, string.Format("Merged to {0}", target));
                Archive(ctx, target, SongArchiveReason.Merged, string.Format("Merged from {0}", source));

                ctx.Update(source);
                ctx.Update(target);
            });
        }
Example #3
0
        public SongForApiContract(Song song, SongMergeRecord mergeRecord, ContentLanguagePreference languagePreference,
                                  bool albums = true, bool artists = true, bool names = true, bool pvs = false, bool tags = true, bool thumbUrl = true, bool webLinks = false)
        {
            ArtistString        = song.ArtistString[languagePreference];
            CreateDate          = song.CreateDate;
            DefaultName         = song.DefaultName;
            DefaultNameLanguage = song.Names.SortNames.DefaultLanguage;
            FavoritedTimes      = song.FavoritedTimes;
            Id            = song.Id;
            LengthSeconds = song.LengthSeconds;
            Name          = song.Names.SortNames[languagePreference];
            PVServices    = song.PVServices;
            RatingScore   = song.RatingScore;
            SongType      = song.SongType;
            Status        = song.Status;
            Version       = song.Version;

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

            if (albums)
            {
                Albums = song.Albums.Select(a => new AlbumContract(a.Album, languagePreference)).ToArray();
            }

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

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

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

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

            if (thumbUrl)
            {
                ThumbUrl = VideoServiceHelper.GetThumbUrl(song.PVs.PVs);
            }

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

            if (mergeRecord != null)
            {
                MergedTo = mergeRecord.Target.Id;
            }
        }
Example #4
0
        public SongForApiContract(Song song, SongMergeRecord mergeRecord, ContentLanguagePreference languagePreference, SongOptionalFields fields)
        {
            ArtistString        = song.ArtistString[languagePreference];
            CreateDate          = song.CreateDate;
            DefaultName         = song.DefaultName;
            DefaultNameLanguage = song.Names.SortNames.DefaultLanguage;
            FavoritedTimes      = song.FavoritedTimes;
            Id            = song.Id;
            LengthSeconds = song.LengthSeconds;
            Name          = song.Names.SortNames[languagePreference];
            PublishDate   = song.PublishDate;
            PVServices    = song.PVServices;
            RatingScore   = song.RatingScore;
            SongType      = song.SongType;
            Status        = song.Status;
            Version       = song.Version;

            if (fields.HasFlag(SongOptionalFields.AdditionalNames))
            {
                AdditionalNames = song.Names.GetAdditionalNamesStringForLanguage(languagePreference);
            }

            if (fields.HasFlag(SongOptionalFields.Albums))
            {
                Albums = song.OnAlbums.Select(a => new AlbumContract(a, languagePreference)).ToArray();
            }

            if (fields.HasFlag(SongOptionalFields.Artists))
            {
                Artists = song.Artists.Select(a => new ArtistForSongContract(a, languagePreference)).ToArray();
            }

            if (fields.HasFlag(SongOptionalFields.Lyrics))
            {
                Lyrics = song.Lyrics.Select(l => new LyricsForSongContract(l)).ToArray();
            }

            if (fields.HasFlag(SongOptionalFields.MainPicture))
            {
                var thumb = song.GetThumbUrl();

                if (!string.IsNullOrEmpty(thumb))
                {
                    MainPicture = new EntryThumbForApiContract {
                        UrlThumb = thumb
                    };
                }
            }

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

            if (song.HasOriginalVersion)
            {
                OriginalVersionId = song.OriginalVersion.Id;
            }

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

            if (fields.HasFlag(SongOptionalFields.ReleaseEvent) && song.ReleaseEvent != null)
            {
                ReleaseEvent = new ReleaseEventForApiContract(song.ReleaseEvent, languagePreference, ReleaseEventOptionalFields.None, null, true);
            }

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

            if (fields.HasFlag(SongOptionalFields.ThumbUrl))
            {
                ThumbUrl = song.GetThumbUrl();
            }

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

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