public void Merge(int sourceId, int targetId)
{
PermissionContext.VerifyPermission(PermissionToken.MergeEntries);
if (sourceId == targetId)
{
throw new ArgumentException("Source and target artists can't be the same", "targetId");
}
HandleTransaction(session => {
var source = session.Load <Artist>(sourceId);
var target = session.Load <Artist>(targetId);
AuditLog(string.Format("Merging {0} to {1}",
EntryLinkFactory.CreateEntryLink(source), EntryLinkFactory.CreateEntryLink(target)), session);
foreach (var n in source.Names.Names.Where(n => !target.HasName(n)))
{
var name = target.CreateName(n.Value, n.Language);
session.Save(name);
}
foreach (var w in source.WebLinks.Where(w => !target.HasWebLink(w.Url)))
{
var link = target.CreateWebLink(w.Description, w.Url, w.Category);
session.Save(link);
}
var groups = source.Groups.Where(g => !target.HasGroup(g.Group)).ToArray();
foreach (var g in groups)
{
g.MoveToMember(target);
session.Update(g);
}
var members = source.Members.Where(m => !m.Member.HasGroup(target)).ToArray();
foreach (var m in members)
{
m.MoveToGroup(target);
session.Update(m);
}
var albums = source.Albums.Where(a => !target.HasAlbum(a.Album)).ToArray();
foreach (var a in albums)
{
a.Move(target);
session.Update(a);
}
var songs = source.Songs.Where(s => !target.HasSong(s.Song)).ToArray();
foreach (var s in songs)
{
s.Move(target);
session.Update(s);
}
var ownerUsers = source.OwnerUsers.Where(s => !target.HasOwnerUser(s.User)).ToArray();
foreach (var u in ownerUsers)
{
u.Move(target);
session.Update(u);
}
var pictures = source.Pictures.ToArray();
foreach (var p in pictures)
{
p.Move(target);
session.Update(p);
}
var users = source.Users.ToArray();
foreach (var u in users)
{
u.Move(target);
session.Update(u);
}
if (target.Description == string.Empty)
{
target.Description = source.Description;
}
source.Deleted = true;
Archive(session, target, ArtistArchiveReason.Merged, string.Format("Merged from '{0}'", source.DefaultName));
session.Update(source);
session.Update(target);
});
}
public EntryRevertedContract RevertToVersion(int archivedSongVersionId)
{
PermissionContext.VerifyPermission(PermissionToken.RestoreRevisions);
return(HandleTransaction(session => {
var archivedVersion = session.Load <ArchivedSongVersion>(archivedSongVersionId);
var song = archivedVersion.Song;
SysLog("reverting " + song + " to version " + archivedVersion.Version);
var fullProperties = ArchivedSongContract.GetAllProperties(archivedVersion);
var warnings = new List <string>();
song.LengthSeconds = fullProperties.LengthSeconds;
song.NicoId = fullProperties.NicoId;
song.Notes = fullProperties.Notes;
song.SongType = fullProperties.SongType;
song.TranslatedName.DefaultLanguage = fullProperties.TranslatedName.DefaultLanguage;
// Artists
SessionHelper.RestoreObjectRefs <ArtistForSong, Artist, ArchivedArtistForSongContract>(
session, warnings, song.AllArtists, fullProperties.Artists,
(a1, a2) => (a1.Artist != null && a1.Artist.Id == a2.Id) || (a1.Artist == null && a2.Id == 0 && a1.Name == a2.NameHint),
(artist, artistRef) => RestoreArtistRef(song, artist, artistRef),
artistForSong => artistForSong.Delete());
// Names
if (fullProperties.Names != null)
{
var nameDiff = song.Names.SyncByContent(fullProperties.Names, song);
SessionHelper.Sync(session, nameDiff);
}
// Weblinks
if (fullProperties.WebLinks != null)
{
var webLinkDiff = WebLink.SyncByValue(song.WebLinks, fullProperties.WebLinks, song);
SessionHelper.Sync(session, webLinkDiff);
}
// Lyrics
if (fullProperties.Lyrics != null)
{
var lyricsDiff = CollectionHelper.Diff(song.Lyrics, fullProperties.Lyrics, (p1, p2) => (p1.Id == p2.Id));
foreach (var lyrics in lyricsDiff.Added)
{
session.Save(song.CreateLyrics(lyrics.Language, lyrics.Value, lyrics.Source));
}
foreach (var lyrics in lyricsDiff.Removed)
{
song.Lyrics.Remove(lyrics);
session.Delete(lyrics);
}
foreach (var lyrics in lyricsDiff.Unchanged)
{
var newLyrics = fullProperties.Lyrics.First(l => l.Id == lyrics.Id);
lyrics.Language = newLyrics.Language;
lyrics.Source = newLyrics.Source;
lyrics.Value = newLyrics.Value;
session.Update(lyrics);
}
}
// PVs
if (fullProperties.PVs != null)
{
var pvDiff = CollectionHelper.Diff(song.PVs, fullProperties.PVs, (p1, p2) => (p1.PVId == p2.PVId && p1.Service == p2.Service));
foreach (var pv in pvDiff.Added)
{
session.Save(song.CreatePV(new PVContract(pv)));
}
foreach (var pv in pvDiff.Removed)
{
pv.OnDelete();
session.Delete(pv);
}
}
song.UpdateFavoritedTimes();
Archive(session, song, SongArchiveReason.Reverted);
AuditLog("reverted " + EntryLinkFactory.CreateEntryLink(song) + " to revision " + archivedVersion.Version, session);
return new EntryRevertedContract(song, warnings);
}));
}
public EntryRevertedContract RevertToVersion(int archivedAlbumVersionId)
{
PermissionContext.VerifyPermission(PermissionToken.RestoreRevisions);
return(HandleTransaction(session => {
var archivedVersion = session.Load <ArchivedAlbumVersion>(archivedAlbumVersionId);
var album = archivedVersion.Album;
SysLog("reverting " + album + " to version " + archivedVersion.Version);
var fullProperties = ArchivedAlbumContract.GetAllProperties(archivedVersion);
var warnings = new List <string>();
album.Description.Original = fullProperties.Description;
album.Description.English = fullProperties.DescriptionEng;
album.DiscType = fullProperties.DiscType;
album.TranslatedName.DefaultLanguage = fullProperties.TranslatedName.DefaultLanguage;
// Picture
var versionWithPic = archivedVersion.GetLatestVersionWithField(AlbumEditableFields.Cover);
if (versionWithPic != null)
{
album.CoverPictureData = versionWithPic.CoverPicture;
}
// Original release
album.OriginalRelease = (fullProperties.OriginalRelease != null ? new AlbumRelease(fullProperties.OriginalRelease) : null);
// Artists
SessionHelper.RestoreObjectRefs <ArtistForAlbum, Artist, ArchivedArtistForAlbumContract>(
session, warnings, album.AllArtists, fullProperties.Artists,
(a1, a2) => (a1.Artist != null && a1.Artist.Id == a2.Id) || (a1.Artist == null && a2.Id == 0 && a1.Name == a2.NameHint),
(artist, albumRef) => RestoreArtistRef(album, artist, albumRef),
albumForArtist => albumForArtist.Delete());
// Songs
SessionHelper.RestoreObjectRefs <SongInAlbum, Song, SongInAlbumRefContract>(
session, warnings, album.AllSongs, fullProperties.Songs,
(a1, a2) => ((a1.Song != null && a1.Song.Id == a2.Id) || a1.Song == null && a2.Id == 0 && a1.Name == a2.NameHint),
(song, songRef) => RestoreTrackRef(album, song, songRef),
songInAlbum => songInAlbum.Delete());
// Names
if (fullProperties.Names != null)
{
var nameDiff = album.Names.SyncByContent(fullProperties.Names, album);
SessionHelper.Sync(session, nameDiff);
}
// Weblinks
if (fullProperties.WebLinks != null)
{
var webLinkDiff = WebLink.SyncByValue(album.WebLinks, fullProperties.WebLinks, album);
SessionHelper.Sync(session, webLinkDiff);
}
// PVs
if (fullProperties.PVs != null)
{
var pvDiff = CollectionHelper.Diff(album.PVs, fullProperties.PVs, (p1, p2) => (p1.PVId == p2.PVId && p1.Service == p2.Service));
foreach (var pv in pvDiff.Added)
{
session.Save(album.CreatePV(new PVContract(pv)));
}
foreach (var pv in pvDiff.Removed)
{
pv.OnDelete();
session.Delete(pv);
}
}
album.UpdateArtistString();
album.UpdateRatingTotals();
Archive(session, album, AlbumArchiveReason.Reverted, string.Format("Reverted to version {0}", archivedVersion.Version));
AuditLog(string.Format("reverted {0} to revision {1}", EntryLinkFactory.CreateEntryLink(album), archivedVersion.Version), session);
return new EntryRevertedContract(album, warnings);
}));
}
protected string CreateEntryLink(IEntryBase entry)
{
return(EntryLinkFactory.CreateEntryLink(entry));
}
/// <summary>
/// Reverts an album to an earlier archived version.
/// </summary>
/// <param name="archivedArtistVersionId">Id of the archived version to be restored.</param>
/// <returns>Result of the revert operation, with possible warnings if any. Cannot be null.</returns>
/// <remarks>Requires the RestoreRevisions permission.</remarks>
public EntryRevertedContract RevertToVersion(int archivedArtistVersionId)
{
PermissionContext.VerifyPermission(PermissionToken.RestoreRevisions);
return(HandleTransaction(session => {
var archivedVersion = session.Load <ArchivedArtistVersion>(archivedArtistVersionId);
var artist = archivedVersion.Artist;
SysLog("reverting " + artist + " to version " + archivedVersion.Version);
var fullProperties = ArchivedArtistContract.GetAllProperties(archivedVersion);
var warnings = new List <string>();
artist.ArtistType = fullProperties.ArtistType;
artist.Description.Original = fullProperties.Description;
artist.Description.English = fullProperties.DescriptionEng;
artist.TranslatedName.DefaultLanguage = fullProperties.TranslatedName.DefaultLanguage;
artist.BaseVoicebank = SessionHelper.RestoreWeakRootEntityRef <Artist>(session, warnings, fullProperties.BaseVoicebank);
// Picture
var versionWithPic = archivedVersion.GetLatestVersionWithField(ArtistEditableFields.Picture);
if (versionWithPic != null)
{
artist.Picture = versionWithPic.Picture;
}
/*
* // Albums
* SessionHelper.RestoreObjectRefs<ArtistForAlbum, Album>(
* session, warnings, artist.AllAlbums, fullProperties.Albums, (a1, a2) => (a1.Album.Id == a2.Id),
* album => (!artist.HasAlbum(album) ? artist.AddAlbum(album) : null),
* albumForArtist => albumForArtist.Delete());
*/
// Groups
SessionHelper.RestoreObjectRefs <GroupForArtist, Artist>(
session, warnings, artist.AllGroups, fullProperties.Groups, (a1, a2) => (a1.Group.Id == a2.Id),
grp => (!artist.HasGroup(grp) ? artist.AddGroup(grp) : null),
groupForArtist => groupForArtist.Delete());
/*
* // Members
* SessionHelper.RestoreObjectRefs<GroupForArtist, Artist>(
* session, warnings, artist.AllMembers, fullProperties.Members, (a1, a2) => (a1.Member.Id == a2.Id),
* member => (!artist.HasMember(member) ? artist.AddMember(member) : null),
* groupForArtist => groupForArtist.Delete());
*/
// Names
if (fullProperties.Names != null)
{
var nameDiff = artist.Names.SyncByContent(fullProperties.Names, artist);
SessionHelper.Sync(session, nameDiff);
}
// Weblinks
if (fullProperties.WebLinks != null)
{
var webLinkDiff = WebLink.SyncByValue(artist.WebLinks, fullProperties.WebLinks, artist);
SessionHelper.Sync(session, webLinkDiff);
}
Archive(session, artist, ArtistArchiveReason.Reverted, string.Format("Reverted to version {0}", archivedVersion.Version));
AuditLog(string.Format("reverted {0} to revision {1}", EntryLinkFactory.CreateEntryLink(artist), archivedVersion.Version), session);
return new EntryRevertedContract(artist, warnings);
}));
}
