public async Task Update_Tracks()
{
var contract = new AlbumForEditContract(_album, ContentLanguagePreference.English, new InMemoryImagePersister());
var existingSong = CreateEntry.Song(name: "Nebula");
_repository.Save(existingSong);
contract.Songs = new[] {
CreateSongInAlbumEditContract(1, songId: existingSong.Id),
CreateSongInAlbumEditContract(2, songName: "Anger")
};
contract = await CallUpdate(contract);
var albumFromRepo = _repository.Load(contract.Id);
albumFromRepo.AllSongs.Count.Should().Be(2, "Number of songs");
var track1 = albumFromRepo.GetSongByTrackNum(1, 1);
track1.Song.Should().Be(existingSong, "First track");
var track2 = albumFromRepo.GetSongByTrackNum(1, 2);
track2.Song.DefaultName.Should().Be("Anger", "Second track name");
var archivedVersion = _repository.List <ArchivedAlbumVersion>().FirstOrDefault();
archivedVersion.Should().NotBeNull("Archived version was created");
archivedVersion.Diff.ChangedFields.Value.Should().Be(AlbumEditableFields.Tracks, "Changed fields");
}
public void Revert()
{
// Arrange
album.Description.English = "Original";
var oldVer = repository.HandleTransaction(ctx => queries.Archive(ctx, album, AlbumArchiveReason.PropertiesUpdated));
var contract = new AlbumForEditContract(album, ContentLanguagePreference.English, new InMemoryImagePersister());
contract.Description.English = "Updated";
CallUpdate(contract);
var entryFromRepo = repository.Load <Album>(album.Id);
Assert.AreEqual("Updated", entryFromRepo.Description.English, "Description was updated");
// Act
var result = queries.RevertToVersion(oldVer.Id);
// Assert
Assert.AreEqual(0, result.Warnings.Length, "Number of warnings");
entryFromRepo = repository.Load <Album>(result.Id);
Assert.AreEqual("Original", entryFromRepo.Description.English, "Description was restored");
var lastVersion = entryFromRepo.ArchivedVersionsManager.GetLatestVersion();
Assert.IsNotNull(lastVersion, "Last version is available");
Assert.AreEqual(AlbumArchiveReason.Reverted, lastVersion.Reason, "Last version archive reason");
Assert.IsFalse(lastVersion.Diff.Cover.IsChanged, "Picture was not changed");
}
public void Update_Discs() {
var contract = new AlbumForEditContract(album, ContentLanguagePreference.English, new InMemoryImagePersister());
repository.Save(CreateEntry.AlbumDisc(album));
contract.Discs = new[] {
new AlbumDiscPropertiesContract { Id = 1, Name = "Past" },
new AlbumDiscPropertiesContract { Id = 2, Name = "Present" }
};
contract = CallUpdate(contract);
var albumFromRepo = repository.Load(contract.Id);
Assert.AreEqual(2, albumFromRepo.Discs.Count, "Number of discs");
var disc1 = albumFromRepo.GetDisc(1);
Assert.IsNotNull(disc1, "disc1");
Assert.AreEqual("Past", disc1.Name, "disc1.Name");
var disc2 = albumFromRepo.GetDisc(2);
Assert.IsNotNull(disc2, "disc2");
Assert.AreEqual("Present", disc2.Name, "disc2.Name");
var archivedVersion = repository.List<ArchivedAlbumVersion>().FirstOrDefault();
Assert.IsNotNull(archivedVersion, "Archived version was created");
Assert.AreEqual(AlbumEditableFields.Discs, archivedVersion.Diff.ChangedFields.Value, "Changed fields");
}
public void Update_Names() {
var contract = new AlbumForEditContract(album, ContentLanguagePreference.English, new InMemoryImagePersister());
contract.Names.First().Value = "Replaced name";
contract.UpdateNotes = "Updated album";
contract = CallUpdate(contract);
Assert.AreEqual(album.Id, contract.Id, "Update album Id as expected");
var albumFromRepo = repository.Load(contract.Id);
Assert.AreEqual("Replaced name", albumFromRepo.DefaultName);
Assert.AreEqual(1, albumFromRepo.Version, "Version");
Assert.AreEqual(0, albumFromRepo.AllArtists.Count, "No artists");
Assert.AreEqual(0, albumFromRepo.AllSongs.Count, "No songs");
var archivedVersion = repository.List<ArchivedAlbumVersion>().FirstOrDefault();
Assert.IsNotNull(archivedVersion, "Archived version was created");
Assert.AreEqual(album, archivedVersion.Album, "Archived version album");
Assert.AreEqual(AlbumArchiveReason.PropertiesUpdated, archivedVersion.Reason, "Archived version reason");
Assert.AreEqual(AlbumEditableFields.Names, archivedVersion.Diff.ChangedFields.Value, "Changed fields");
var activityEntry = repository.List<ActivityEntry>().FirstOrDefault();
Assert.IsNotNull(activityEntry, "Activity entry was created");
Assert.AreEqual(album, activityEntry.EntryBase, "Activity entry's entry");
Assert.AreEqual(EntryEditEvent.Updated, activityEntry.EditEvent, "Activity entry event type");
}
public void Update_Tracks() {
var contract = new AlbumForEditContract(album, ContentLanguagePreference.English, new InMemoryImagePersister());
var existingSong = CreateEntry.Song(name: "Nebula");
repository.Save(existingSong);
contract.Songs = new[] {
CreateSongInAlbumEditContract(1, songId: existingSong.Id),
CreateSongInAlbumEditContract(2, songName: "Anger")
};
contract = CallUpdate(contract);
var albumFromRepo = repository.Load(contract.Id);
Assert.AreEqual(2, albumFromRepo.AllSongs.Count, "Number of songs");
var track1 = albumFromRepo.GetSongByTrackNum(1, 1);
Assert.AreEqual(existingSong, track1.Song, "First track");
var track2 = albumFromRepo.GetSongByTrackNum(1, 2);
Assert.AreEqual("Anger", track2.Song.DefaultName, "Second track name");
var archivedVersion = repository.List<ArchivedAlbumVersion>().FirstOrDefault();
Assert.IsNotNull(archivedVersion, "Archived version was created");
Assert.AreEqual(AlbumEditableFields.Tracks, archivedVersion.Diff.ChangedFields.Value, "Changed fields");
}
public AlbumEdit(AlbumForEditContract album)
: this()
{
ParamIs.NotNull(() => album);
DefaultLanguageSelection = album.TranslatedName.DefaultLanguage;
Description = album.Description;
DiscType = album.DiscType;
Id = album.Id;
Name = album.Name;
Names = album.Names;
Pictures = album.Pictures;
PVs = album.PVs;
Status = album.Status;
Tracks = album.Songs;
WebLinks = album.WebLinks.Select(w => new WebLinkDisplay(w)).ToArray();
if (album.OriginalRelease != null)
{
CatNum = album.OriginalRelease.CatNum;
ReleaseEvent = album.OriginalRelease.EventName;
var d = album.OriginalRelease.ReleaseDate;
if (d != null)
{
ReleaseDay = d.Day;
ReleaseMonth = d.Month;
ReleaseYear = d.Year;
}
}
CopyNonEditableFields(album);
}
public async Task Update_Names()
{
var contract = new AlbumForEditContract(_album, ContentLanguagePreference.English, new InMemoryImagePersister());
contract.Names.First().Value = "Replaced name";
contract.UpdateNotes = "Updated album";
contract = await CallUpdate(contract);
contract.Id.Should().Be(_album.Id, "Update album Id as expected");
var albumFromRepo = _repository.Load(contract.Id);
albumFromRepo.DefaultName.Should().Be("Replaced name");
albumFromRepo.Version.Should().Be(1, "Version");
albumFromRepo.AllArtists.Count.Should().Be(0, "No artists");
albumFromRepo.AllSongs.Count.Should().Be(0, "No songs");
var archivedVersion = _repository.List <ArchivedAlbumVersion>().FirstOrDefault();
archivedVersion.Should().NotBeNull("Archived version was created");
archivedVersion.Album.Should().Be(_album, "Archived version album");
archivedVersion.Reason.Should().Be(AlbumArchiveReason.PropertiesUpdated, "Archived version reason");
archivedVersion.Diff.ChangedFields.Value.Should().Be(AlbumEditableFields.Names, "Changed fields");
var activityEntry = _repository.List <ActivityEntry>().FirstOrDefault();
activityEntry.Should().NotBeNull("Activity entry was created");
activityEntry.EntryBase.Should().Be(_album, "Activity entry's entry");
activityEntry.EditEvent.Should().Be(EntryEditEvent.Updated, "Activity entry event type");
}
private async Task <AlbumForEditContract> CallUpdate(Stream image)
{
var contract = new AlbumForEditContract(album, ContentLanguagePreference.English, new InMemoryImagePersister());
using (var stream = image) {
return(await queries.UpdateBasicProperties(contract, new EntryPictureFileContract(stream, MediaTypeNames.Image.Jpeg, purpose : ImagePurpose.Main)));
}
}
private AlbumForEditContract CallUpdate(Stream image)
{
var contract = new AlbumForEditContract(album, ContentLanguagePreference.English);
using (var stream = image) {
return(queries.UpdateBasicProperties(contract, new EntryPictureFileContract {
UploadedFile = stream, Mime = MediaTypeNames.Image.Jpeg
}));
}
}
public AlbumEditViewModel(AlbumContract album, IUserPermissionContext permissionContext,
AlbumForEditContract editedAlbum = null)
: this()
{
ParamIs.NotNull(() => album);
Album = album;
EditedAlbum = editedAlbum;
AllowedEntryStatuses = EntryPermissionManager.AllowedEntryStatuses(permissionContext);
}
public void CopyNonEditableFields(AlbumForEditContract album)
{
ParamIs.NotNull(() => album);
AllowedEntryStatuses = EntryPermissionManager.AllowedEntryStatuses(MvcApplication.LoginManager);
ArtistLinks = album.ArtistLinks;
Deleted = album.Deleted;
Draft = album.Status == EntryStatus.Draft;
NameEnglish = album.TranslatedName.English;
NameJapanese = album.TranslatedName.Japanese;
NameRomaji = album.TranslatedName.Romaji;
ValidationResult = album.ValidationResult;
}
public void Update_Artists_Notify()
{
Save(user2.AddArtist(vocalist));
var contract = new AlbumForEditContract(album, ContentLanguagePreference.Default);
contract.ArtistLinks = contract.ArtistLinks.Concat(new [] { CreateArtistForAlbumContract(vocalist.Id) }).ToArray();
queries.UpdateBasicProperties(contract, null);
var notification = repository.List <UserMessage>().FirstOrDefault();
Assert.IsNotNull(notification, "Notification was created");
Assert.AreEqual(user2, notification.Receiver, "Receiver");
}
public async Task Update_Artists_Notify()
{
Save(_user2.AddArtist(_vocalist));
var contract = new AlbumForEditContract(_album, ContentLanguagePreference.Default, new InMemoryImagePersister());
contract.ArtistLinks = contract.ArtistLinks.Concat(new[] { CreateArtistForAlbumContract(_vocalist.Id) }).ToArray();
await _queries.UpdateBasicProperties(contract, null);
var notification = _repository.List <UserMessage>().FirstOrDefault();
notification.Should().NotBeNull("Notification was created");
notification.Receiver.Should().Be(_user2, "Receiver");
}
public void Update_Artists_CustomArtist()
{
var contract = new AlbumForEditContract(album, ContentLanguagePreference.English);
contract.ArtistLinks = new [] {
CreateArtistForAlbumContract(customArtistName: "Custom artist", roles: ArtistRoles.Composer)
};
contract = CallUpdate(contract);
var albumFromRepo = repository.Load(contract.Id);
Assert.AreEqual(1, albumFromRepo.AllArtists.Count, "Number of artists");
Assert.IsTrue(albumFromRepo.AllArtists.Any(a => a.Name == "Custom artist"), "Has custom artist");
Assert.AreEqual("Custom artist", albumFromRepo.ArtistString.Default, "Artist string");
var archivedVersion = repository.List <ArchivedAlbumVersion>().FirstOrDefault();
Assert.IsNotNull(archivedVersion, "Archived version was created");
Assert.AreEqual(AlbumEditableFields.Artists, archivedVersion.Diff.ChangedFields, "Changed fields");
}
public async Task Update_Artists_CustomArtist()
{
var contract = new AlbumForEditContract(_album, ContentLanguagePreference.English, new InMemoryImagePersister());
contract.ArtistLinks = new[] {
CreateArtistForAlbumContract(customArtistName: "Custom artist", roles: ArtistRoles.Composer)
};
contract = await CallUpdate(contract);
var albumFromRepo = _repository.Load(contract.Id);
albumFromRepo.AllArtists.Count.Should().Be(1, "Number of artists");
albumFromRepo.AllArtists.Any(a => a.Name == "Custom artist").Should().BeTrue("Has custom artist");
albumFromRepo.ArtistString.Default.Should().Be("Custom artist", "Artist string");
var archivedVersion = _repository.List <ArchivedAlbumVersion>().FirstOrDefault();
archivedVersion.Should().NotBeNull("Archived version was created");
archivedVersion.Diff.ChangedFields.Value.Should().Be(AlbumEditableFields.Artists, "Changed fields");
}
public void Update_Artists()
{
var contract = new AlbumForEditContract(album, ContentLanguagePreference.English);
contract.ArtistLinks = new [] {
CreateArtistForAlbumContract(artistId: producer.Id),
CreateArtistForAlbumContract(artistId: vocalist.Id)
};
contract = CallUpdate(contract);
var albumFromRepo = repository.Load(contract.Id);
Assert.AreEqual(2, albumFromRepo.AllArtists.Count, "Number of artists");
Assert.IsTrue(albumFromRepo.HasArtist(producer), "Has producer");
Assert.IsTrue(albumFromRepo.HasArtist(vocalist), "Has vocalist");
Assert.AreEqual("Tripshots feat. Hatsune Miku", albumFromRepo.ArtistString.Default, "Artist string");
var archivedVersion = repository.List <ArchivedAlbumVersion>().FirstOrDefault();
Assert.IsNotNull(archivedVersion, "Archived version was created");
Assert.AreEqual(AlbumEditableFields.Artists, archivedVersion.Diff.ChangedFields, "Changed fields");
}
public async Task Update_Artists()
{
var contract = new AlbumForEditContract(_album, ContentLanguagePreference.English, new InMemoryImagePersister());
contract.ArtistLinks = new[] {
CreateArtistForAlbumContract(artistId: _producer.Id),
CreateArtistForAlbumContract(artistId: _vocalist.Id)
};
contract = await CallUpdate(contract);
var albumFromRepo = _repository.Load(contract.Id);
albumFromRepo.AllArtists.Count.Should().Be(2, "Number of artists");
albumFromRepo.HasArtist(_producer).Should().BeTrue("Has producer");
albumFromRepo.HasArtist(_vocalist).Should().BeTrue("Has vocalist");
albumFromRepo.ArtistString.Default.Should().Be("Tripshots feat. Hatsune Miku", "Artist string");
var archivedVersion = _repository.List <ArchivedAlbumVersion>().FirstOrDefault();
archivedVersion.Should().NotBeNull("Archived version was created");
archivedVersion.Diff.ChangedFields.Value.Should().Be(AlbumEditableFields.Artists, "Changed fields");
}
public async Task Update_Discs()
{
var contract = new AlbumForEditContract(_album, ContentLanguagePreference.English, new InMemoryImagePersister());
_repository.Save(CreateEntry.AlbumDisc(_album));
contract.Discs = new[] {
new AlbumDiscPropertiesContract {
Id = 1, Name = "Past"
},
new AlbumDiscPropertiesContract {
Id = 2, Name = "Present"
}
};
contract = await CallUpdate(contract);
var albumFromRepo = _repository.Load(contract.Id);
albumFromRepo.Discs.Count.Should().Be(2, "Number of discs");
var disc1 = albumFromRepo.GetDisc(1);
disc1.Should().NotBeNull("disc1");
disc1.Name.Should().Be("Past", "disc1.Name");
var disc2 = albumFromRepo.GetDisc(2);
disc2.Should().NotBeNull("disc2");
disc2.Name.Should().Be("Present", "disc2.Name");
var archivedVersion = _repository.List <ArchivedAlbumVersion>().FirstOrDefault();
archivedVersion.Should().NotBeNull("Archived version was created");
archivedVersion.Diff.ChangedFields.Value.Should().Be(AlbumEditableFields.Discs, "Changed fields");
}
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);
}));
}
private AlbumForEditContract CallUpdate(AlbumForEditContract contract) {
return queries.UpdateBasicProperties(contract, null);
}
private AlbumEditViewModel CreateAlbumEditViewModel(int id, AlbumForEditContract editedAlbum)
{
return(Service.GetAlbum(id, album => new AlbumEditViewModel(new AlbumContract(album, PermissionContext.LanguagePreference), PermissionContext,
EntryPermissionManager.CanDelete(PermissionContext, album), editedAlbum)));
}
private Task <AlbumForEditContract> CallUpdate(AlbumForEditContract contract)
{
return(_queries.UpdateBasicProperties(contract, null));
}
