public async Task Update_Artists()
{
var newSong = CreateEntry.Song(name: "Anger");
_repository.Save(newSong);
foreach (var name in newSong.Names)
{
_repository.Save(name);
}
var contract = new SongForEditContract(newSong, ContentLanguagePreference.English);
contract.Artists = new[] {
CreateArtistForSongContract(artistId: _producer.Id),
CreateArtistForSongContract(artistId: _vocalist.Id),
CreateArtistForSongContract(artistName: "Goomeh", roles: ArtistRoles.Vocalist),
};
contract = await _queries.UpdateBasicProperties(contract);
var songFromRepo = _repository.Load(contract.Id);
songFromRepo.AllArtists.Count.Should().Be(3, "Number of artists");
AssertHasArtist(songFromRepo, _producer);
AssertHasArtist(songFromRepo, _vocalist);
songFromRepo.ArtistString.Default.Should().Be("Tripshots feat. Hatsune Miku, Goomeh", "Artist string");
var archivedVersion = _repository.List <ArchivedSongVersion>().FirstOrDefault();
archivedVersion.Should().NotBeNull("Archived version was created");
archivedVersion.Diff.ChangedFields.Value.Should().Be(SongEditableFields.Artists, "Changed fields");
}
public void Update_Names()
{
var contract = new SongForEditContract(song, ContentLanguagePreference.English);
contract.Names.First().Value = "Replaced name";
contract.UpdateNotes = "Updated song";
contract = queries.UpdateBasicProperties(contract);
var songFromRepo = repository.Load(contract.Id);
Assert.AreEqual("Replaced name", songFromRepo.DefaultName);
Assert.AreEqual(1, songFromRepo.Version, "Version");
Assert.AreEqual(2, songFromRepo.AllArtists.Count, "Number of artists");
Assert.AreEqual(0, songFromRepo.AllAlbums.Count, "No albums");
var archivedVersion = repository.List <ArchivedSongVersion>().FirstOrDefault();
Assert.IsNotNull(archivedVersion, "Archived version was created");
Assert.AreEqual(song, archivedVersion.Song, "Archived version song");
Assert.AreEqual(SongArchiveReason.PropertiesUpdated, archivedVersion.Reason, "Archived version reason");
Assert.AreEqual(SongEditableFields.Names, archivedVersion.Diff.ChangedFields.Value, "Changed fields");
var activityEntry = repository.List <ActivityEntry>().FirstOrDefault();
Assert.IsNotNull(activityEntry, "Activity entry was created");
Assert.AreEqual(song, activityEntry.EntryBase, "Activity entry's entry");
Assert.AreEqual(EntryEditEvent.Updated, activityEntry.EditEvent, "Activity entry event type");
}
public async Task Update_Names()
{
var contract = new SongForEditContract(_song, ContentLanguagePreference.English);
contract.Names.First().Value = "Replaced name";
contract.UpdateNotes = "Updated song";
contract = await _queries.UpdateBasicProperties(contract);
var songFromRepo = _repository.Load(contract.Id);
songFromRepo.DefaultName.Should().Be("Replaced name");
songFromRepo.Version.Should().Be(1, "Version");
songFromRepo.AllArtists.Count.Should().Be(2, "Number of artists");
songFromRepo.AllAlbums.Count.Should().Be(0, "No albums");
var archivedVersion = _repository.List <ArchivedSongVersion>().FirstOrDefault();
archivedVersion.Should().NotBeNull("Archived version was created");
archivedVersion.Song.Should().Be(_song, "Archived version song");
archivedVersion.Reason.Should().Be(SongArchiveReason.PropertiesUpdated, "Archived version reason");
archivedVersion.Diff.ChangedFields.Value.Should().Be(SongEditableFields.Names, "Changed fields");
var activityEntry = _repository.List <ActivityEntry>().FirstOrDefault();
activityEntry.Should().NotBeNull("Activity entry was created");
activityEntry.EntryBase.Should().Be(_song, "Activity entry's entry");
activityEntry.EditEvent.Should().Be(EntryEditEvent.Updated, "Activity entry event type");
}
public void Update_Artists()
{
var newSong = CreateEntry.Song(name: "Anger");
repository.Save(newSong);
foreach (var name in newSong.Names)
{
repository.Save(name);
}
var contract = new SongForEditContract(newSong, ContentLanguagePreference.English);
contract.Artists = new [] {
CreateArtistForSongContract(artistId: producer.Id),
CreateArtistForSongContract(artistId: vocalist.Id),
CreateArtistForSongContract(artistName: "Goomeh", roles: ArtistRoles.Vocalist),
};
contract = queries.UpdateBasicProperties(contract);
var songFromRepo = repository.Load(contract.Id);
Assert.AreEqual(3, songFromRepo.AllArtists.Count, "Number of artists");
AssertHasArtist(songFromRepo, producer);
AssertHasArtist(songFromRepo, vocalist);
Assert.AreEqual("Tripshots feat. Hatsune Miku, Goomeh", songFromRepo.ArtistString.Default, "Artist string");
var archivedVersion = repository.List <ArchivedSongVersion>().FirstOrDefault();
Assert.IsNotNull(archivedVersion, "Archived version was created");
Assert.AreEqual(SongEditableFields.Artists, archivedVersion.Diff.ChangedFields.Value, "Changed fields");
}
public void CopyNonEditableFields(SongForEditContract song)
{
ParamIs.NotNull(() => song);
AllowedEntryStatuses = EntryPermissionManager.AllowedEntryStatuses(MvcApplication.LoginManager);
Deleted = song.Deleted;
Draft = song.Song.Status == EntryStatus.Draft;
Name = song.Song.Name;
ValidationResult = song.ValidationResult;
}
public SongEditViewModel(SongContract song, IUserPermissionContext permissionContext,
SongForEditContract editedSong = null)
: this()
{
ParamIs.NotNull(() => song);
Song = song;
AllowedEntryStatuses = EntryPermissionManager.AllowedEntryStatuses(permissionContext);
EditedSong = editedSong;
}
private async Task <SongForEditContract> Update(SongForEditContract contract)
{
return(await context.RunTestAsync(async repository => {
var queries = Queries(repository);
var updated = await queries.UpdateBasicProperties(contract);
return queries.GetSongForEdit(updated.Id);
}));
}
private SongForEditContract Update(SongForEditContract contract)
{
return(context.RunTest(repository => {
var queries = Queries(repository);
var updated = queries.UpdateBasicProperties(contract);
return queries.GetSongForEdit(updated.Id);
}));
}
public void Update_Lyrics()
{
var contract = new SongForEditContract(Db.Song2, ContentLanguagePreference.English)
{
Lyrics = new[] { CreateEntry.LyricsForSongContract(TranslationType.Original) }
};
var song = Update(contract);
Assert.AreEqual(1, song.Lyrics.Length, "Lyrics created");
}
public async Task Update_Artists_RemoveDeleted()
{
_repository.Save(_vocalist2);
_repository.Save(_song.AddArtist(_vocalist2));
_vocalist2.Deleted = true;
var contract = new SongForEditContract(_song, ContentLanguagePreference.English);
await _queries.UpdateBasicProperties(contract);
_song.AllArtists.Any(a => Equals(_vocalist2, a.Artist)).Should().BeFalse("vocalist2 was removed from song");
}
public void Update_Artists_RemoveDeleted()
{
repository.Save(vocalist2);
repository.Save(song.AddArtist(vocalist2));
vocalist2.Deleted = true;
var contract = new SongForEditContract(song, ContentLanguagePreference.English);
queries.UpdateBasicProperties(contract);
Assert.IsFalse(song.AllArtists.Any(a => Equals(vocalist2, a.Artist)), "vocalist2 was removed from song");
}
public SongEditViewModel(SongContract song, IUserPermissionContext permissionContext,
bool canDelete,
SongForEditContract editedSong = null, int?albumId = null)
: this()
{
ParamIs.NotNull(() => song);
Song = song;
AllowedEntryStatuses = EntryPermissionManager.AllowedEntryStatuses(permissionContext).ToArray();
CanDelete = canDelete;
EditedSong = editedSong;
AlbumId = albumId;
}
public void Update_Weblinks_SkipWhitespace()
{
var contract = new SongForEditContract(song, ContentLanguagePreference.English);
contract.WebLinks = new[] {
new WebLinkContract(" ", "VocaDB", WebLinkCategory.Reference)
};
contract = queries.UpdateBasicProperties(contract);
var songFromRepo = repository.Load(contract.Id);
Assert.AreEqual(0, songFromRepo.WebLinks.Count, "Number of weblinks");
}
public async Task Update_Weblinks_SkipWhitespace()
{
var contract = new SongForEditContract(_song, ContentLanguagePreference.English);
contract.WebLinks = new[] {
new WebLinkContract(" ", "VocaDB", WebLinkCategory.Reference, disabled: false)
};
contract = await _queries.UpdateBasicProperties(contract);
var songFromRepo = _repository.Load(contract.Id);
songFromRepo.WebLinks.Count.Should().Be(0, "Number of weblinks");
}
public void Update_Weblinks()
{
var contract = new SongForEditContract(song, ContentLanguagePreference.English);
contract.WebLinks = new[] {
new WebLinkContract("http://vocadb.net", "VocaDB", WebLinkCategory.Reference)
};
contract = queries.UpdateBasicProperties(contract);
var songFromRepo = repository.Load(contract.Id);
Assert.AreEqual(1, songFromRepo.WebLinks.Count, "Number of weblinks");
Assert.AreEqual("http://vocadb.net", songFromRepo.WebLinks[0].Url, "Weblink URL");
}
public void Update_Artists_Notify()
{
repository.Save(user2.AddArtist(vocalist2));
repository.Save(vocalist2);
var contract = new SongForEditContract(song, ContentLanguagePreference.English);
contract.Artists = contract.Artists.Concat(new [] { CreateArtistForSongContract(vocalist2.Id) }).ToArray();
queries.UpdateBasicProperties(contract);
var notification = repository.List <UserMessage>().FirstOrDefault();
Assert.IsNotNull(notification, "Notification was created");
Assert.AreEqual(user2, notification.Receiver, "Receiver");
}
public async Task Update_Artists_Notify()
{
_repository.Save(_user2.AddArtist(_vocalist2));
_repository.Save(_vocalist2);
var contract = new SongForEditContract(_song, ContentLanguagePreference.English);
contract.Artists = contract.Artists.Concat(new[] { CreateArtistForSongContract(_vocalist2.Id) }).ToArray();
await _queries.UpdateBasicProperties(contract);
var notification = _repository.List <UserMessage>().FirstOrDefault();
notification.Should().NotBeNull("Notification was created");
notification.Receiver.Should().Be(_user2, "Receiver");
}
public async Task Update_PublishDate_From_PVs()
{
var contract = new SongForEditContract(_song, ContentLanguagePreference.English);
contract.PVs = new[] {
CreateEntry.PVContract(id: 1, pvId: "hoLu7c2XZYU", pvType: PVType.Reprint, publishDate: new DateTime(2015, 3, 9, 10, 0, 0)),
CreateEntry.PVContract(id: 2, pvId: "mikumikumiku", pvType: PVType.Original, publishDate: new DateTime(2015, 4, 9, 16, 0, 0))
};
contract = await _queries.UpdateBasicProperties(contract);
var songFromRepo = _repository.Load(contract.Id);
songFromRepo.PVs.PVs.Count.Should().Be(2, "Number of PVs");
songFromRepo.PublishDate.DateTime.Should().Be(new DateTime(2015, 4, 9), "Song publish date was updated");
}
public void Update_PublishDate_From_PVs()
{
var contract = new SongForEditContract(song, ContentLanguagePreference.English);
contract.PVs = new[] {
CreateEntry.PVContract(id: 1, pvId: "hoLu7c2XZYU", pvType: PVType.Reprint, publishDate: new DateTime(2015, 3, 9, 10, 0, 0)),
CreateEntry.PVContract(id: 2, pvId: "mikumikumiku", pvType: PVType.Original, publishDate: new DateTime(2015, 4, 9, 16, 0, 0))
};
contract = queries.UpdateBasicProperties(contract);
var songFromRepo = repository.Load(contract.Id);
Assert.AreEqual(2, songFromRepo.PVs.PVs.Count, "Number of PVs");
Assert.AreEqual(new DateTime(2015, 4, 9), songFromRepo.PublishDate.DateTime, "Song publish date was updated");
}
public void Update_ReleaseEvent_Change()
{
context.RunTest(repository => {
var queries = Queries(repository);
var newEvent = repository.HandleTransaction(ctx => new ReleaseEventContract(ctx.Save(CreateEntry.ReleaseEvent("Mikumas")), false));
// Act
var contract = new SongForEditContract(Db.Song, ContentLanguagePreference.English)
{
ReleaseEvent = newEvent
};
var updated = queries.UpdateBasicProperties(contract);
// Assert
Assert.AreEqual(newEvent.Id, updated.ReleaseEvent?.Id, "Release event was changed");
var releaseEvent = repository.HandleQuery(ctx => ctx.Load <ReleaseEvent>(newEvent.Id));
Assert.AreEqual(1, releaseEvent.AllSongs.Count, "Song was added to event");
});
}
public SongEdit(SongForEditContract song)
: this()
{
ParamIs.NotNull(() => song);
ArtistLinks = song.Artists;
DefaultLanguageSelection = song.TranslatedName.DefaultLanguage;
Id = song.Song.Id;
Lyrics = song.Lyrics.Select(l => new LyricsForSongModel(l)).ToArray();
NameEnglish = song.TranslatedName.English;
NameJapanese = song.TranslatedName.Japanese;
NameRomaji = song.TranslatedName.Romaji;
Names = song.Names;
Notes = song.Notes;
OriginalVersion = song.OriginalVersion ?? new SongContract();
PVs = song.PVs;
SongType = song.Song.SongType;
Status = song.Song.Status;
WebLinks = song.WebLinks.Select(w => new WebLinkDisplay(w)).ToArray();
CopyNonEditableFields(song);
}
public void Update_ReleaseEvent_Remove()
{
// Preconditions (arrange)
Assert.IsNotNull(Db.Song.ReleaseEvent, "ReleaseEvent");
Assert.IsTrue(Db.ReleaseEvent.AllSongs.Contains(Db.Song), "Release event has song");
// Act
var contract = new SongForEditContract(Db.Song, ContentLanguagePreference.English)
{
ReleaseEvent = null
};
context.RunTest(repository => {
var queries = Queries(repository);
var updated = queries.UpdateBasicProperties(contract);
// Assert
Assert.IsNull(updated.ReleaseEvent, "Release event was cleared");
var releaseEvent = repository.HandleQuery(ctx => ctx.Load <ReleaseEvent>(Db.ReleaseEvent.Id));
Assert.AreEqual(0, releaseEvent.AllSongs.Count, "Song was removed from event");
});
}
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);
}));
}
