public void CreateEventQuerySuccessReturnsEventId()
{
// Arrange
var examination = new MedicalExaminer.Models.Examination();
var theEvent = new Mock <OtherEvent>(); // only other event has been implemented so far.
var connectionSettings = new Mock <IExaminationConnectionSettings>();
var query = new CreateEventQuery("1", theEvent.Object);
theEvent.Object.UserId = "a";
var dbAccess = new Mock <IDatabaseAccess>();
dbAccess.Setup(db => db.GetItemByIdAsync <MedicalExaminer.Models.Examination>(connectionSettings.Object,
It.IsAny <string>()))
.Returns(Task.FromResult(examination)).Verifiable();
dbAccess.Setup(db => db.UpdateItemAsync(connectionSettings.Object,
It.IsAny <MedicalExaminer.Models.Examination>())).Returns(Task.FromResult(examination)).Verifiable();
var sut = new CreateEventService(dbAccess.Object, connectionSettings.Object, _urgencySettingsMock.Object);
// Act
var result = sut.Handle(query);
// Assert
dbAccess.Verify(db => db.UpdateItemAsync(connectionSettings.Object,
It.IsAny <MedicalExaminer.Models.Examination>()), Times.Once);
Assert.NotNull(result.Result);
Assert.Equal("a", examination.LastModifiedBy);
}
public void CreateEventOnExaminationWithNoUrgencyIndicatorsSuccessReturnsExaminationWithUrgencyScoreZero()
{
// Arrange
var examination = new MedicalExaminer.Models.Examination()
{
ChildPriority = false,
CoronerPriority = false,
CulturalPriority = false,
FaithPriority = false,
OtherPriority = false,
CreatedAt = DateTime.Now.AddDays(-3)
};
var theEvent = new Mock <OtherEvent>(); // only other event has been implemented so far.
var connectionSettings = new Mock <IExaminationConnectionSettings>();
var query = new CreateEventQuery("1", theEvent.Object);
theEvent.Object.UserId = "a";
var dbAccess = new Mock <IDatabaseAccess>();
dbAccess.Setup(db => db.GetItemByIdAsync <MedicalExaminer.Models.Examination>(connectionSettings.Object,
It.IsAny <string>()))
.Returns(Task.FromResult(examination)).Verifiable();
dbAccess.Setup(db => db.UpdateItemAsync(connectionSettings.Object,
It.IsAny <MedicalExaminer.Models.Examination>())).Returns(Task.FromResult(examination)).Verifiable();
var sut = new CreateEventService(dbAccess.Object, connectionSettings.Object, _urgencySettingsMock.Object);
// Act
var result = sut.Handle(query);
// Assert
examination.IsUrgent().Should().BeFalse();
examination.LastModifiedBy.Should().Be("a");
}
public void CreateEventQueryIsNullThrowsException()
{
// Arrange
var connectionSettings = new Mock <IExaminationConnectionSettings>();
CreateEventQuery query = null;
var dbAccess = new Mock <IDatabaseAccess>();
var sut = new CreateEventService(dbAccess.Object, connectionSettings.Object, _urgencySettingsMock.Object);
// Act
Action act = () => sut.Handle(query).GetAwaiter().GetResult();
act.Should().Throw <ArgumentNullException>();
}
public SongForEditContract UpdateBasicProperties(SongForEditContract properties)
{
ParamIs.NotNull(() => properties);
VerifyManageDatabase();
return(repository.HandleTransaction(ctx => {
var song = ctx.Load(properties.Id);
VerifyEntryEdit(song);
var diff = new SongDiff(DoSnapshot(song.GetLatestVersion(), ctx.OfType <User>().GetLoggedUser(PermissionContext)));
ctx.AuditLogger.SysLog(string.Format("updating properties for {0}", song));
var oldPvCount = song.PVs.OfType(PVType.Original).Count();
diff.Notes = song.Notes.CopyFrom(properties.Notes);
var newOriginalVersion = (properties.OriginalVersion != null && properties.OriginalVersion.Id != 0 ? ctx.Load(properties.OriginalVersion.Id) : null);
if (!Equals(song.OriginalVersion, newOriginalVersion))
{
song.OriginalVersion = newOriginalVersion;
diff.OriginalVersion = true;
}
if (song.SongType != properties.SongType)
{
diff.SongType = true;
song.SongType = properties.SongType;
}
if (song.LengthSeconds != properties.LengthSeconds)
{
diff.Length = true;
song.LengthSeconds = properties.LengthSeconds;
}
if (song.TranslatedName.DefaultLanguage != properties.DefaultNameLanguage)
{
song.TranslatedName.DefaultLanguage = properties.DefaultNameLanguage;
diff.OriginalName = true;
}
var nameDiff = song.Names.Sync(properties.Names, song);
ctx.OfType <SongName>().Sync(nameDiff);
if (nameDiff.Changed)
{
diff.Names = true;
}
var webLinkDiff = WebLink.Sync(song.WebLinks, properties.WebLinks, song);
ctx.OfType <SongWebLink>().Sync(webLinkDiff);
if (webLinkDiff.Changed)
{
diff.WebLinks = true;
}
if (song.Status != properties.Status)
{
song.Status = properties.Status;
diff.Status = true;
}
var artistGetter = new Func <ArtistForSongContract, Artist>(artistForSong =>
ctx.OfType <Artist>().Load(artistForSong.Artist.Id));
var artistsDiff = song.SyncArtists(properties.Artists, artistGetter);
ctx.OfType <ArtistForSong>().Sync(artistsDiff);
if (artistsDiff.Changed)
{
diff.Artists = true;
}
var newEvent = new CreateEventQuery().FindOrCreate(ctx, PermissionContext, properties.ReleaseEvent, song);
if (!song.ReleaseEvent.NullSafeIdEquals(newEvent))
{
diff.ReleaseEvent = true;
song.SetReleaseEvent(newEvent);
}
if (!song.PublishDate.Equals(properties.PublishDate))
{
song.PublishDate = properties.PublishDate;
diff.PublishDate = true;
}
UpdatePVs(ctx, song, diff, properties.PVs);
var lyricsDiff = song.SyncLyrics(properties.Lyrics);
ctx.OfType <LyricsForSong>().Sync(lyricsDiff);
if (lyricsDiff.Changed)
{
diff.Lyrics = true;
}
var logStr = string.Format("updated properties for song {0} ({1})", entryLinkFactory.CreateEntryLink(song), diff.ChangedFieldsString)
+ (properties.UpdateNotes != string.Empty ? " " + HttpUtility.HtmlEncode(properties.UpdateNotes) : string.Empty)
.Truncate(400);
var archived = Archive(ctx, song, diff, SongArchiveReason.PropertiesUpdated, properties.UpdateNotes);
ctx.Update(song);
ctx.AuditLogger.AuditLog(logStr);
AddEntryEditedEntry(ctx.OfType <ActivityEntry>(), song, EntryEditEvent.Updated, archived);
var newPVCutoff = TimeSpan.FromDays(7);
if (oldPvCount == 0 && song.PVs.OfType(PVType.Original).Any() && song.CreateDate <= DateTime.Now - newPVCutoff)
{
new FollowedArtistNotifier().SendNotifications(ctx.OfType <UserMessage>(), song, song.ArtistList, PermissionContext.LoggedUser, entryLinkFactory, mailer);
}
var newSongCutoff = TimeSpan.FromHours(1);
if (artistsDiff.Added.Any() && song.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(ctx.OfType <UserMessage>(), song, addedArtists, PermissionContext.LoggedUser, entryLinkFactory, mailer);
}
}
return new SongForEditContract(song, 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);
}));
}
