public void Archive(IRepositoryContext <Album> ctx, Album album, AlbumDiff diff, AlbumArchiveReason reason, string notes = "")
{
var agentLoginData = ctx.CreateAgentLoginData(PermissionContext);
var archived = ArchivedAlbumVersion.Create(album, diff, agentLoginData, reason, notes);
ctx.OfType <ArchivedAlbumVersion>().Save(archived);
}
public void Archive(ISession session, Album album, AlbumDiff diff, AlbumArchiveReason reason, string notes = "")
{
var agentLoginData = SessionHelper.CreateAgentLoginData(session, PermissionContext);
var archived = ArchivedAlbumVersion.Create(album, diff, agentLoginData, reason, notes);
session.Save(archived);
}
public AlbumDiffContract(AlbumDiff diff)
{
ParamIs.NotNull(() => diff);
Cover = diff.Cover;
Description = diff.Description;
IsSnapshot = diff.IsSnapshot;
Names = diff.Names;
WebLinks = diff.WebLinks;
}
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);
}
public AlbumForEditContract UpdateBasicProperties(AlbumForEditContract properties, PictureDataContract pictureData)
{
ParamIs.NotNull(() => properties);
return(HandleQuery(session => {
using (var tx = session.BeginTransaction()) {
var album = session.Load <Album>(properties.Id);
VerifyEntryEdit(album);
var diff = new AlbumDiff(DoSnapshot(album.ArchivedVersionsManager.GetLatestVersion(), GetLoggedUser(session)));
SysLog(string.Format("updating properties for {0}", album));
if (album.DiscType != properties.DiscType)
{
album.DiscType = properties.DiscType;
album.UpdateArtistString();
diff.DiscType = true;
}
if (album.Description != properties.Description)
{
album.Description = properties.Description;
diff.Description = true;
}
if (album.TranslatedName.DefaultLanguage != properties.TranslatedName.DefaultLanguage)
{
album.TranslatedName.DefaultLanguage = properties.TranslatedName.DefaultLanguage;
diff.OriginalName = true;
}
var validNames = properties.Names.AllNames;
var nameDiff = album.Names.Sync(validNames, album);
SessionHelper.Sync(session, nameDiff);
album.Names.UpdateSortNames();
if (nameDiff.Changed)
{
diff.Names = true;
}
var validWebLinks = properties.WebLinks.Where(w => !string.IsNullOrEmpty(w.Url));
var webLinkDiff = WebLink.Sync(album.WebLinks, validWebLinks, album);
SessionHelper.Sync(session, webLinkDiff);
if (webLinkDiff.Changed)
{
diff.WebLinks = true;
}
var newOriginalRelease = (properties.OriginalRelease != null ? new AlbumRelease(properties.OriginalRelease) : new AlbumRelease());
if (album.OriginalRelease == null)
{
album.OriginalRelease = new AlbumRelease();
}
if (!album.OriginalRelease.Equals(newOriginalRelease))
{
album.OriginalRelease = newOriginalRelease;
diff.OriginalRelease = true;
}
NHibernateUtil.Initialize(album.CoverPictureData);
if (pictureData != null)
{
album.CoverPictureData = new PictureData(pictureData);
diff.Cover = true;
}
if (album.Status != properties.Status)
{
album.Status = properties.Status;
diff.Status = true;
}
var songGetter = new Func <SongInAlbumEditContract, Song>(contract => {
if (contract.SongId != 0)
{
return session.Load <Song>(contract.SongId);
}
else
{
SysLog(string.Format("creating a new song '{0}' to {1}", contract.SongName, album));
var song = new Song(new LocalizedString(contract.SongName, ContentLanguageSelection.Unspecified));
session.Save(song);
Services.Songs.Archive(session, song, SongArchiveReason.Created,
string.Format("Created for album '{0}'", album.DefaultName));
AuditLog(string.Format("created {0} for {1}",
EntryLinkFactory.CreateEntryLink(song), EntryLinkFactory.CreateEntryLink(album)), session);
AddEntryEditedEntry(session, song, EntryEditEvent.Created);
return song;
}
});
var tracksDiff = album.SyncSongs(properties.Songs, songGetter);
SessionHelper.Sync(session, tracksDiff);
if (tracksDiff.Changed)
{
var add = string.Join(", ", tracksDiff.Added.Select(i => i.Song.ToString()));
var rem = string.Join(", ", tracksDiff.Removed.Select(i => i.Song.ToString()));
var edit = string.Join(", ", tracksDiff.Edited.Select(i => i.Song.ToString()));
var str = string.Format("edited tracks (added: {0}, removed: {1}, reordered: {2})", add, rem, edit)
.Truncate(300);
AuditLog(str, session);
diff.Tracks = true;
}
var picsDiff = album.Pictures.SyncPictures(properties.Pictures, GetLoggedUser(session), album.CreatePicture);
SessionHelper.Sync(session, picsDiff);
ImageHelper.GenerateThumbsAndMoveImages(picsDiff.Added);
if (picsDiff.Changed)
{
diff.Pictures = true;
}
var pvDiff = album.SyncPVs(properties.PVs);
SessionHelper.Sync(session, pvDiff);
if (pvDiff.Changed)
{
diff.PVs = true;
}
var logStr = string.Format("updated properties for {0} ({1})",
EntryLinkFactory.CreateEntryLink(album), diff.ChangedFieldsString)
+ (properties.UpdateNotes != string.Empty ? " " + properties.UpdateNotes : string.Empty)
.Truncate(400);
AuditLog(logStr, session);
AddEntryEditedEntry(session, album, EntryEditEvent.Updated);
Archive(session, album, diff, AlbumArchiveReason.PropertiesUpdated, properties.UpdateNotes);
session.Update(album);
tx.Commit();
return new AlbumForEditContract(album, PermissionContext.LanguagePreference);
}
}));
}
public AlbumForEditContract UpdateBasicProperties(AlbumForEditContract properties, EntryPictureFileContract pictureData)
{
ParamIs.NotNull(() => properties);
return(repository.HandleTransaction(session => {
var album = session.Load(properties.Id);
VerifyEntryEdit(album);
var diff = new AlbumDiff(DoSnapshot(album.ArchivedVersionsManager.GetLatestVersion(), session.OfType <User>().GetLoggedUser(PermissionContext)));
session.AuditLogger.SysLog(string.Format("updating properties for {0}", album));
if (album.DiscType != properties.DiscType)
{
album.DiscType = properties.DiscType;
album.UpdateArtistString();
diff.DiscType.Set();
}
diff.Description.Set(album.Description.CopyFrom(properties.Description));
var parsedBarcodes = properties.Identifiers.Select(Album.ParseBarcode).ToArray();
var barcodeDiff = album.SyncIdentifiers(parsedBarcodes);
session.Sync(barcodeDiff);
if (barcodeDiff.Changed)
{
diff.Identifiers.Set();
}
if (album.TranslatedName.DefaultLanguage != properties.DefaultNameLanguage)
{
album.TranslatedName.DefaultLanguage = properties.DefaultNameLanguage;
diff.OriginalName.Set();
}
var validNames = properties.Names;
var nameDiff = album.Names.Sync(validNames, album);
session.OfType <AlbumName>().Sync(nameDiff);
album.Names.UpdateSortNames();
if (nameDiff.Changed)
{
diff.Names.Set();
}
var webLinkDiff = WebLink.Sync(album.WebLinks, properties.WebLinks, album);
session.OfType <AlbumWebLink>().Sync(webLinkDiff);
if (webLinkDiff.Changed)
{
diff.WebLinks.Set();
}
var newEvent = new CreateEventQuery().FindOrCreate(session, PermissionContext, properties.OriginalRelease.ReleaseEvent, album);
var newOriginalRelease = (properties.OriginalRelease != null ? new AlbumRelease(properties.OriginalRelease, newEvent) : new AlbumRelease());
if (album.OriginalRelease == null)
{
album.OriginalRelease = new AlbumRelease();
}
if (!album.OriginalRelease.Equals(newOriginalRelease))
{
album.OriginalRelease = newOriginalRelease;
diff.OriginalRelease.Set();
}
// Required because of a bug in NHibernate
NHibernateUtil.Initialize(album.CoverPictureData);
if (pictureData != null)
{
var parsed = ImageHelper.GetOriginal(pictureData.UploadedFile, pictureData.ContentLength, pictureData.Mime);
album.CoverPictureData = new PictureData(parsed);
album.CoverPictureMime = parsed.Mime;
pictureData.Id = album.Id;
pictureData.EntryType = EntryType.Album;
var thumbGenerator = new ImageThumbGenerator(imagePersister);
thumbGenerator.GenerateThumbsAndMoveImage(pictureData.UploadedFile, pictureData, ImageSizes.Thumb | ImageSizes.SmallThumb | ImageSizes.TinyThumb);
diff.Cover.Set();
}
if (album.Status != properties.Status)
{
album.Status = properties.Status;
diff.Status.Set();
}
var artistGetter = new Func <ArtistContract, Artist>(artist =>
session.OfType <Artist>().Load(artist.Id));
var artistsDiff = album.SyncArtists(properties.ArtistLinks, artistGetter);
session.OfType <ArtistForAlbum>().Sync(artistsDiff);
if (artistsDiff.Changed)
{
diff.Artists.Set();
}
var discsDiff = album.SyncDiscs(properties.Discs);
session.OfType <AlbumDiscProperties>().Sync(discsDiff);
if (discsDiff.Changed)
{
diff.Discs.Set();
}
var songGetter = new Func <SongInAlbumEditContract, Song>(contract => {
if (contract.SongId != 0)
{
return session.Load <Album, Song>(contract.SongId);
}
else
{
var songName = StringHelper.TrimIfNotWhitespace(contract.SongName);
session.AuditLogger.SysLog(string.Format("creating a new song '{0}' to {1}", songName, album));
var song = new Song(new LocalizedString(songName, ContentLanguageSelection.Unspecified));
session.Save(song);
var songDiff = new SongDiff();
songDiff.Names.Set();
var songArtistDiff = song.SyncArtists(contract.Artists,
addedArtistContracts => GetArtists(session, addedArtistContracts));
if (songArtistDiff.Changed)
{
songDiff.Artists.Set();
session.Update(song);
}
session.Sync(songArtistDiff);
var archived = ArchiveSong(session.OfType <Song>(), song, songDiff, SongArchiveReason.Created,
string.Format("Created for album '{0}'", album.DefaultName.TruncateWithEllipsis(100)));
session.AuditLogger.AuditLog(string.Format("created {0} for {1}",
entryLinkFactory.CreateEntryLink(song), entryLinkFactory.CreateEntryLink(album)));
AddEntryEditedEntry(session.OfType <ActivityEntry>(), song, EntryEditEvent.Created, archived);
return song;
}
});
var tracksDiff = album.SyncSongs(properties.Songs, songGetter,
(song, artistContracts) => UpdateSongArtists(session, song, artistContracts));
session.OfType <SongInAlbum>().Sync(tracksDiff);
if (tracksDiff.Changed)
{
var add = string.Join(", ", tracksDiff.Added.Select(i => HttpUtility.HtmlEncode(i.SongToStringOrName)));
var rem = string.Join(", ", tracksDiff.Removed.Select(i => HttpUtility.HtmlEncode(i.SongToStringOrName)));
var edit = string.Join(", ", tracksDiff.Edited.Select(i => HttpUtility.HtmlEncode(i.SongToStringOrName)));
var str = string.Format("edited tracks (added: {0}, removed: {1}, reordered: {2})", add, rem, edit)
.Truncate(300);
session.AuditLogger.AuditLog(str);
diff.Tracks.Set();
}
var picsDiff = album.Pictures.SyncPictures(properties.Pictures, session.OfType <User>().GetLoggedUser(PermissionContext), album.CreatePicture);
session.OfType <AlbumPictureFile>().Sync(picsDiff);
var entryPictureFileThumbGenerator = new ImageThumbGenerator(pictureFilePersister);
album.Pictures.GenerateThumbsAndMoveImage(entryPictureFileThumbGenerator, picsDiff.Added, ImageSizes.Original | ImageSizes.Thumb);
if (picsDiff.Changed)
{
diff.Pictures.Set();
}
var pvDiff = album.SyncPVs(properties.PVs);
session.OfType <PVForAlbum>().Sync(pvDiff);
if (pvDiff.Changed)
{
diff.PVs.Set();
}
var logStr = string.Format("updated properties for album {0} ({1})",
entryLinkFactory.CreateEntryLink(album), diff.ChangedFieldsString)
+ (properties.UpdateNotes != string.Empty ? " " + properties.UpdateNotes : string.Empty)
.Truncate(400);
session.AuditLogger.AuditLog(logStr);
var archivedAlbum = Archive(session, album, diff, AlbumArchiveReason.PropertiesUpdated, properties.UpdateNotes);
session.Update(album);
AddEntryEditedEntry(session.OfType <ActivityEntry>(), album, EntryEditEvent.Updated, archivedAlbum);
var newSongCutoff = TimeSpan.FromHours(1);
if (artistsDiff.Added.Any() && album.CreateDate >= DateTime.Now - newSongCutoff)
{
var addedArtists = artistsDiff.Added.Where(a => a.Artist != null).Select(a => a.Artist).Distinct().ToArray();
if (addedArtists.Any())
{
new FollowedArtistNotifier().SendNotifications(session, album, addedArtists, PermissionContext.LoggedUser, entryLinkFactory, mailer, enumTranslations);
}
}
return new AlbumForEditContract(album, PermissionContext.LanguagePreference, pictureFilePersister);
}));
}
public EntryRevertedContract RevertToVersion(int archivedAlbumVersionId)
{
PermissionContext.VerifyPermission(PermissionToken.RestoreRevisions);
return(HandleTransaction(session => {
var archivedVersion = session.Load <ArchivedAlbumVersion>(archivedAlbumVersionId);
var album = archivedVersion.Album;
session.AuditLogger.SysLog("reverting " + album + " to version " + archivedVersion.Version);
var fullProperties = ArchivedAlbumContract.GetAllProperties(archivedVersion);
var warnings = new List <string>();
var diff = new AlbumDiff();
album.Description.Original = fullProperties.Description;
album.Description.English = fullProperties.DescriptionEng ?? string.Empty;
album.DiscType = fullProperties.DiscType;
album.TranslatedName.DefaultLanguage = fullProperties.TranslatedName.DefaultLanguage;
// Picture
var versionWithPic = archivedVersion.GetLatestVersionWithField(AlbumEditableFields.Cover);
if (versionWithPic != null)
{
album.CoverPictureData = versionWithPic.CoverPicture;
album.CoverPictureMime = versionWithPic.CoverPictureMime;
if (versionWithPic.CoverPicture != null)
{
var thumbGenerator = new ImageThumbGenerator(imagePersister);
using (var stream = new MemoryStream(versionWithPic.CoverPicture.Bytes)) {
var thumb = new EntryThumb(album, versionWithPic.CoverPictureMime);
thumbGenerator.GenerateThumbsAndMoveImage(stream, thumb, ImageSizes.Thumb | ImageSizes.SmallThumb | ImageSizes.TinyThumb);
}
}
}
else
{
album.CoverPictureData = null;
album.CoverPictureMime = null;
}
// Assume picture was changed if there's a version between the current version and the restored version where the picture was changed.
diff.Cover.Set(!Equals(album.ArchivedVersionsManager.GetLatestVersionWithField(AlbumEditableFields.Cover, album.Version), versionWithPic));
// Original release
album.OriginalRelease = (fullProperties.OriginalRelease != null ? new AlbumRelease(fullProperties.OriginalRelease, session.NullSafeLoad <ReleaseEvent>(fullProperties.OriginalRelease.ReleaseEvent)) : null);
// Artists
DatabaseContextHelper.RestoreObjectRefs <ArtistForAlbum, Artist, ArchivedArtistForAlbumContract>(
session.OfType <Artist>(), 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
DatabaseContextHelper.RestoreObjectRefs <SongInAlbum, Song, SongInAlbumRefContract>(
session.OfType <Song>(), 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);
session.Sync(nameDiff);
}
// Weblinks
if (fullProperties.WebLinks != null)
{
var webLinkDiff = WebLink.SyncByValue(album.WebLinks, fullProperties.WebLinks, album);
session.Sync(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, diff, 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);
}));
}
private AlbumContract AcceptImportedAlbum(ISession session, IAlbumImporter importer, ContentLanguageSelection languageSelection,
InspectedAlbum acceptedAlbum, int[] selectedSongIds)
{
Album album;
var diff = new AlbumDiff(false);
var isNew = acceptedAlbum.MergedAlbum == null;
if (isNew)
{
album = new Album(new LocalizedString(acceptedAlbum.ImportedAlbum.Title, languageSelection));
if (languageSelection != ContentLanguageSelection.Unspecified)
{
album.Names.SortNames.DefaultLanguage = languageSelection;
}
album.DiscType = DiscType.Unknown;
diff.Names.Set();
session.Save(album);
}
else
{
album = session.Load <Album>(acceptedAlbum.MergedAlbum.Id);
if (!album.Names.HasName(acceptedAlbum.ImportedAlbum.Title))
{
album.CreateName(acceptedAlbum.ImportedAlbum.Title, languageSelection);
diff.Names.Set();
}
}
foreach (var inspectedArtist in acceptedAlbum.Artists)
{
if (inspectedArtist.ExistingArtist != null)
{
var artist = session.Load <Artist>(inspectedArtist.ExistingArtist.Id);
if (!artist.HasAlbum(album))
{
session.Save(artist.AddAlbum(album));
diff.Artists.Set();
}
}
else
{
album.AddArtist(inspectedArtist.Name, false, ArtistRoles.Default);
diff.Artists.Set();
}
}
if (acceptedAlbum.MergedAlbum == null || acceptedAlbum.MergeTracks)
{
foreach (var inspectedTrack in acceptedAlbum.Tracks)
{
if (AcceptImportedSong(session, importer, album, inspectedTrack, languageSelection, selectedSongIds))
{
diff.Tracks.Set();
}
}
}
var importedAlbum = session.Load <MikuDbAlbum>(acceptedAlbum.ImportedAlbum.Id);
importedAlbum.Status = AlbumStatus.Approved;
if (importedAlbum.CoverPicture != null && album.CoverPictureData == null)
{
album.CoverPictureData = importedAlbum.CoverPicture;
album.CoverPictureMime = importedAlbum.CoverPictureMime;
// TODO: should generate thumbnail as well
diff.Cover.Set();
}
if (acceptedAlbum.ImportedAlbum.Data.ReleaseYear != null && album.OriginalReleaseDate.Year == null)
{
album.OriginalReleaseDate.Year = acceptedAlbum.ImportedAlbum.Data.ReleaseYear;
diff.OriginalRelease.Set();
}
// Add link if not already added a link to that service
var sourceUrl = acceptedAlbum.ImportedAlbum.SourceUrl;
if (importer != null && !string.IsNullOrEmpty(sourceUrl))
{
if (album.WebLinks.All(w => !string.Equals(w.Url, sourceUrl, StringComparison.InvariantCultureIgnoreCase) && !importer.IsValidFor(w.Url)))
{
album.CreateWebLink(importer.ServiceName, sourceUrl, WebLinkCategory.Reference, disabled: false);
diff.WebLinks.Set();
}
}
album.UpdateArtistString();
var importerName = importer != null ? importer.ServiceName : "(unknown)";
var archived = _albumService.Archive(session, album, diff, AlbumArchiveReason.AutoImportedFromMikuDb, "Imported from " + importerName);
AuditLog($"accepted imported album '{acceptedAlbum.ImportedAlbum.Title}'", session);
AddEntryEditedEntry(session, album, isNew ? EntryEditEvent.Created : EntryEditEvent.Updated, archived);
session.Update(album);
session.Update(importedAlbum);
return(new AlbumContract(album, PermissionContext.LanguagePreference));
}
public async Task <ArchivedAlbumVersion> ArchiveAsync(IDatabaseContext <Album> ctx, Album album, AlbumDiff diff, AlbumArchiveReason reason, string notes = "")
{
var agentLoginData = ctx.CreateAgentLoginData(PermissionContext);
var archived = ArchivedAlbumVersion.Create(album, diff, agentLoginData, reason, notes);
await ctx.SaveAsync(archived);
return(archived);
}
private AlbumContract AcceptImportedAlbum(ISession session, ContentLanguageSelection languageSelection,
InspectedAlbum acceptedAlbum, int[] selectedSongIds)
{
Album album;
var diff = new AlbumDiff(false);
if (acceptedAlbum.MergedAlbum == null)
{
album = new Album(new LocalizedString(acceptedAlbum.ImportedAlbum.Title, languageSelection));
if (languageSelection != ContentLanguageSelection.Unspecified)
{
album.Names.SortNames.DefaultLanguage = languageSelection;
}
album.DiscType = DiscType.Unknown;
diff.Names = true;
session.Save(album);
}
else
{
album = session.Load <Album>(acceptedAlbum.MergedAlbum.Id);
NHibernateUtil.Initialize(album.CoverPictureData);
if (!album.Names.HasName(acceptedAlbum.ImportedAlbum.Title))
{
album.CreateName(acceptedAlbum.ImportedAlbum.Title, languageSelection);
diff.Names = true;
}
}
foreach (var inspectedArtist in acceptedAlbum.Artists)
{
if (inspectedArtist.ExistingArtist != null)
{
var artist = session.Load <Artist>(inspectedArtist.ExistingArtist.Id);
if (!artist.HasAlbum(album))
{
session.Save(artist.AddAlbum(album));
diff.Artists = true;
}
}
else
{
album.AddArtist(inspectedArtist.Name, false, ArtistRoles.Default);
diff.Artists = true;
}
}
if (acceptedAlbum.MergedAlbum == null || acceptedAlbum.MergeTracks)
{
foreach (var inspectedTrack in acceptedAlbum.Tracks)
{
if (AcceptImportedSong(session, album, inspectedTrack, languageSelection, selectedSongIds))
{
diff.Tracks = true;
}
}
}
var importedAlbum = session.Load <MikuDbAlbum>(acceptedAlbum.ImportedAlbum.Id);
importedAlbum.Status = AlbumStatus.Approved;
if (importedAlbum.CoverPicture != null && album.CoverPictureData == null)
{
album.CoverPictureData = importedAlbum.CoverPicture;
using (var stream = new MemoryStream(album.CoverPictureData.Bytes)) {
var thumbs = ImageHelper.GenerateThumbs(stream, new[] { 250 });
if (thumbs.Any())
{
album.CoverPictureData.Thumb250 = new PictureThumb250(thumbs.First().Bytes);
}
}
diff.Cover = true;
}
if (acceptedAlbum.ImportedAlbum.Data.ReleaseYear != null && album.OriginalReleaseDate.Year == null)
{
album.OriginalReleaseDate.Year = acceptedAlbum.ImportedAlbum.Data.ReleaseYear;
diff.OriginalRelease = true;
}
if (!album.WebLinks.Any(w => w.Url.Contains("mikudb.com")))
{
album.CreateWebLink("MikuDB", acceptedAlbum.ImportedAlbum.SourceUrl, WebLinkCategory.Reference);
diff.WebLinks = true;
}
album.UpdateArtistString();
AuditLog(string.Format("accepted imported album '{0}'", acceptedAlbum.ImportedAlbum.Title), session);
AddEntryEditedEntry(session, album, EntryEditEvent.Created);
Services.Albums.Archive(session, album, diff, AlbumArchiveReason.AutoImportedFromMikuDb);
session.Update(album);
session.Update(importedAlbum);
return(new AlbumContract(album, PermissionContext.LanguagePreference));
}
public ExportedAlbumContract(Album album, AlbumDiff diff)
: base(album, diff)
{
Version = album.Version;
}
