protected EntryPictureFileContract ParsePicture(HttpPostedFileBase pictureUpload, string fieldName)
{
EntryPictureFileContract pictureData = null;
if (Request.Files.Count > 0 && pictureUpload != null && pictureUpload.ContentLength > 0)
{
if (pictureUpload.ContentLength > ImageHelper.MaxImageSizeBytes)
{
ModelState.AddModelError(fieldName, "Picture file is too large.");
return(null);
}
if (!ImageHelper.IsValidImageExtension(pictureUpload.FileName))
{
ModelState.AddModelError(fieldName, "Picture format is not valid.");
return(null);
}
pictureData = new EntryPictureFileContract();
pictureData.OriginalFileName = pictureUpload.FileName;
pictureData.UploadedFile = pictureUpload.InputStream;
pictureData.Mime = pictureUpload.ContentType ?? string.Empty;
pictureData.ContentLength = pictureUpload.ContentLength;
}
return(pictureData);
}
private void SaveImage(ReleaseEventSeries series, EntryPictureFileContract pictureData)
{
if (pictureData != null)
{
var parsed = ImageHelper.GetOriginal(pictureData.UploadedFile, pictureData.ContentLength, pictureData.Mime);
series.PictureMime = parsed.Mime;
pictureData.Id = series.Id;
pictureData.EntryType = EntryType.ReleaseEventSeries;
var thumbGenerator = new ImageThumbGenerator(imagePersister);
thumbGenerator.GenerateThumbsAndMoveImage(pictureData.UploadedFile, pictureData, ReleaseEventSeries.ImageSizes, originalSize: Constants.RestrictedImageOriginalSize);
}
}
private PictureDataContract SaveImage(IEntryImageInformation entry, EntryPictureFileContract pictureData)
{
if (pictureData == null)
{
return(null);
}
var parsed = ImageHelper.GetOriginal(pictureData.UploadedFile, pictureData.ContentLength, pictureData.Mime);
pictureData.Id = entry.Id;
pictureData.EntryType = entry.EntryType;
var thumbGenerator = new ImageThumbGenerator(imagePersister);
thumbGenerator.GenerateThumbsAndMoveImage(pictureData.UploadedFile, pictureData, ReleaseEventSeries.ImageSizes, originalSize: Constants.RestrictedImageOriginalSize);
return(parsed);
}
public int UpdateSeries(ReleaseEventSeriesForEditContract contract, EntryPictureFileContract pictureData)
{
ParamIs.NotNull(() => contract);
PermissionContext.VerifyManageDatabase();
return(HandleTransaction(session => {
ReleaseEventSeries series;
if (contract.Id == 0)
{
series = new ReleaseEventSeries(contract.DefaultNameLanguage, contract.Names, contract.Description)
{
Category = contract.Category,
Status = contract.Status
};
session.Save(series);
var diff = new ReleaseEventSeriesDiff(ReleaseEventSeriesEditableFields.OriginalName | ReleaseEventSeriesEditableFields.Names);
diff.Description.Set(!string.IsNullOrEmpty(contract.Description));
var weblinksDiff = WebLink.Sync(series.WebLinks, contract.WebLinks, series);
if (weblinksDiff.Changed)
{
diff.WebLinks.Set();
session.OfType <ReleaseEventWebLink>().Sync(weblinksDiff);
}
if (pictureData != null)
{
diff.Picture.Set();
SaveImage(series, pictureData);
session.Update(series);
}
session.Update(series);
Archive(session, series, diff, EntryEditEvent.Created, string.Empty);
AuditLog(string.Format("created {0}", entryLinkFactory.CreateEntryLink(series)), session);
}
else
{
series = session.Load <ReleaseEventSeries>(contract.Id);
permissionContext.VerifyEntryEdit(series);
var diff = new ReleaseEventSeriesDiff(ReleaseEventSeriesEditableFields.Nothing);
if (series.TranslatedName.DefaultLanguage != contract.DefaultNameLanguage)
{
series.TranslatedName.DefaultLanguage = contract.DefaultNameLanguage;
diff.OriginalName.Set();
}
var nameDiff = series.Names.Sync(contract.Names, series);
session.Sync(nameDiff);
if (nameDiff.Changed)
{
diff.Names.Set();
}
if (series.Category != contract.Category)
{
diff.Category.Set();
series.Category = contract.Category;
}
if (series.Description != contract.Description)
{
diff.Description.Set();
series.Description = contract.Description;
}
if (series.Status != contract.Status)
{
diff.Status.Set();
series.Status = contract.Status;
}
if (pictureData != null)
{
diff.Picture.Set();
SaveImage(series, pictureData);
}
var weblinksDiff = WebLink.Sync(series.WebLinks, contract.WebLinks, series);
if (weblinksDiff.Changed)
{
diff.WebLinks.Set();
session.OfType <ReleaseEventWebLink>().Sync(weblinksDiff);
}
session.Update(series);
if (diff.Names.IsChanged || diff.OriginalName.IsChanged)
{
var eventNamesQuery = new UpdateEventNamesQuery();
foreach (var ev in series.Events.Where(e => !e.CustomName))
{
eventNamesQuery.UpdateNames(session, ev, series, ev.CustomName, ev.SeriesNumber, ev.SeriesSuffix, ev.Names);
session.Update(ev);
}
}
Archive(session, series, diff, EntryEditEvent.Updated, string.Empty);
AuditLog(string.Format("updated {0}", entryLinkFactory.CreateEntryLink(series)), session);
}
return series.Id;
}));
}
private void SaveImage(ReleaseEvent ev, EntryPictureFileContract pictureData)
{
var parsed = SaveImage((IEntryImageInformation)ev, pictureData);
ev.PictureMime = parsed.Mime;
}
private void SaveImage(ReleaseEventSeries series, EntryPictureFileContract pictureData)
{
var parsed = SaveImage((IEntryImageInformation)series, pictureData);
series.PictureMime = parsed.Mime;
}
/// <summary>
/// Updates or creates release event.
///
/// Album release event names will be updated as well if the name changed.
/// </summary>
/// <param name="contract">Updated contract. Cannot be null.</param>
/// <returns>Updated release event data. Cannot be null.</returns>
/// <exception cref="DuplicateEventNameException">If the event name is already in use.</exception>
public ReleaseEventContract Update(ReleaseEventForEditContract contract, EntryPictureFileContract pictureData)
{
ParamIs.NotNull(() => contract);
PermissionContext.VerifyManageDatabase();
return(repository.HandleTransaction(session => {
ReleaseEvent ev;
if (contract.Id == 0)
{
var diff = new ReleaseEventDiff();
if (!contract.Series.IsNullOrDefault())
{
var series = session.OfType <ReleaseEventSeries>().Load(contract.Series.Id);
ev = new ReleaseEvent(contract.Description, contract.Date, series, contract.SeriesNumber, contract.SeriesSuffix,
contract.DefaultNameLanguage, contract.CustomName);
series.AllEvents.Add(ev);
}
else
{
ev = new ReleaseEvent(contract.Description, contract.Date, contract.DefaultNameLanguage);
}
ev.Category = contract.Category;
ev.EndDate = contract.EndDate;
ev.SongList = session.NullSafeLoad <SongList>(contract.SongList);
ev.Status = contract.Status;
ev.VenueName = contract.VenueName;
if (contract.SongList != null)
{
diff.SongList.Set();
}
if (!string.IsNullOrEmpty(contract.VenueName))
{
diff.Venue.Set();
}
var weblinksDiff = WebLink.Sync(ev.WebLinks, contract.WebLinks, ev);
if (weblinksDiff.Changed)
{
diff.WebLinks.Set();
}
var pvDiff = ev.PVs.Sync(contract.PVs, ev.CreatePV);
session.OfType <PVForAlbum>().Sync(pvDiff);
if (pvDiff.Changed)
{
diff.PVs.Set();
}
var artistDiff = ev.SyncArtists(contract.Artists, artistId => session.Load <Artist>(artistId));
if (artistDiff.Changed)
{
diff.Artists.Set();
}
session.Save(ev);
var namesChanged = new UpdateEventNamesQuery().UpdateNames(session, ev, contract.Series, contract.CustomName, contract.SeriesNumber, contract.SeriesSuffix, contract.Names);
if (namesChanged)
{
session.Update(ev);
}
if (pictureData != null)
{
diff.MainPicture.Set();
SaveImage(ev, pictureData);
session.Update(ev);
}
var archived = Archive(session, ev, diff, EntryEditEvent.Created, string.Empty);
AddEntryEditedEntry(session.OfType <ActivityEntry>(), archived);
session.AuditLogger.AuditLog(string.Format("created {0}", entryLinkFactory.CreateEntryLink(ev)));
new FollowedArtistNotifier().SendNotifications(session, ev, ev.Artists.Where(a => a?.Artist != null).Select(a => a.Artist), PermissionContext.LoggedUser, entryLinkFactory, mailer, enumTranslations);
}
else
{
ev = session.Load(contract.Id);
permissionContext.VerifyEntryEdit(ev);
var diff = new ReleaseEventDiff(DoSnapshot(ev, session));
if (ev.Category != contract.Category)
{
diff.Category.Set();
}
if (!ev.Date.Equals(contract.Date) || !ev.EndDate.Equals(contract.EndDate))
{
diff.Date.Set();
}
if (ev.Description != contract.Description)
{
diff.Description.Set();
}
var inheritedLanguage = ev.Series == null || contract.CustomName ? contract.DefaultNameLanguage : ev.Series.TranslatedName.DefaultLanguage;
if (ev.TranslatedName.DefaultLanguage != inheritedLanguage)
{
diff.OriginalName.Set();
}
var namesChanged = new UpdateEventNamesQuery().UpdateNames(session, ev, contract.Series, contract.CustomName, contract.SeriesNumber, contract.SeriesSuffix, contract.Names);
if (namesChanged)
{
diff.Names.Set();
}
if (!ev.Series.NullSafeIdEquals(contract.Series))
{
diff.Series.Set();
}
if (ev.SeriesNumber != contract.SeriesNumber)
{
diff.SeriesNumber.Set();
}
if (ev.SeriesSuffix != contract.SeriesSuffix)
{
diff.SeriesSuffix.Set();
}
if (!ev.SongList.NullSafeIdEquals(contract.SongList))
{
diff.SongList.Set();
}
if (ev.Status != contract.Status)
{
diff.Status.Set();
}
if (!string.Equals(ev.VenueName, contract.VenueName))
{
diff.Venue.Set();
}
ev.SetSeries(session.NullSafeLoad <ReleaseEventSeries>(contract.Series));
ev.Category = contract.Category;
ev.CustomName = contract.CustomName;
ev.Date = contract.Date;
ev.Description = contract.Description;
ev.EndDate = contract.EndDate > contract.Date ? contract.EndDate : null;
ev.SeriesNumber = contract.SeriesNumber;
ev.SeriesSuffix = contract.SeriesSuffix;
ev.SongList = session.NullSafeLoad <SongList>(contract.SongList);
ev.Status = contract.Status;
ev.TranslatedName.DefaultLanguage = inheritedLanguage;
ev.VenueName = contract.VenueName;
var weblinksDiff = WebLink.Sync(ev.WebLinks, contract.WebLinks, ev);
if (weblinksDiff.Changed)
{
diff.WebLinks.Set();
session.OfType <ReleaseEventWebLink>().Sync(weblinksDiff);
}
var pvDiff = ev.PVs.Sync(contract.PVs, ev.CreatePV);
session.OfType <PVForAlbum>().Sync(pvDiff);
if (pvDiff.Changed)
{
diff.PVs.Set();
}
var artistDiff = ev.SyncArtists(contract.Artists, artistId => session.Load <Artist>(artistId));
if (artistDiff.Changed)
{
diff.Artists.Set();
}
if (pictureData != null)
{
diff.MainPicture.Set();
SaveImage(ev, pictureData);
}
session.Update(ev);
var archived = Archive(session, ev, diff, EntryEditEvent.Updated, string.Empty);
AddEntryEditedEntry(session.OfType <ActivityEntry>(), archived);
var logStr = string.Format("updated properties for {0} ({1})", entryLinkFactory.CreateEntryLink(ev), diff.ChangedFieldsString);
session.AuditLogger.AuditLog(logStr);
var newSongCutoff = TimeSpan.FromHours(1);
if (artistDiff.Added.Any() && ev.CreateDate >= DateTime.Now - newSongCutoff)
{
var addedArtists = artistDiff.Added.Where(a => a.Artist != null).Select(a => a.Artist).Distinct().ToArray();
if (addedArtists.Any())
{
new FollowedArtistNotifier().SendNotifications(session, ev, addedArtists, PermissionContext.LoggedUser, entryLinkFactory, mailer, enumTranslations);
}
}
}
return new ReleaseEventContract(ev, 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 async Task <int> Update(ArtistForEditContract properties, EntryPictureFileContract pictureData, IUserPermissionContext permissionContext)
{
ParamIs.NotNull(() => properties);
ParamIs.NotNull(() => permissionContext);
return(await repository.HandleTransactionAsync(async ctx => {
var artist = await ctx.LoadAsync(properties.Id);
VerifyEntryEdit(artist);
var diff = new ArtistDiff(DoSnapshot(artist.GetLatestVersion(), await ctx.OfType <User>().GetLoggedUserAsync(permissionContext)));
ctx.AuditLogger.SysLog(string.Format("updating properties for {0}", artist));
if (artist.ArtistType != properties.ArtistType)
{
artist.ArtistType = properties.ArtistType;
diff.ArtistType.Set();
}
diff.Description.Set(artist.Description.CopyFrom(properties.Description));
if (artist.TranslatedName.DefaultLanguage != properties.DefaultNameLanguage)
{
artist.TranslatedName.DefaultLanguage = properties.DefaultNameLanguage;
diff.OriginalName.Set();
}
// Required because of a bug in NHibernate
NHibernateUtil.Initialize(artist.Picture);
if (pictureData != null)
{
var parsed = ImageHelper.GetOriginal(pictureData.UploadedFile, pictureData.ContentLength, pictureData.Mime);
artist.Picture = new PictureData(parsed);
artist.PictureMime = parsed.Mime;
pictureData.Id = artist.Id;
pictureData.EntryType = EntryType.Artist;
var thumbGenerator = new ImageThumbGenerator(imagePersister);
thumbGenerator.GenerateThumbsAndMoveImage(pictureData.UploadedFile, pictureData, ImageSizes.Thumb | ImageSizes.SmallThumb | ImageSizes.TinyThumb);
diff.Picture.Set();
}
if (artist.Status != properties.Status)
{
artist.Status = properties.Status;
diff.Status.Set();
}
var nameDiff = artist.Names.Sync(properties.Names, artist);
await ctx.OfType <ArtistName>().SyncAsync(nameDiff);
if (nameDiff.Changed)
{
diff.Names.Set();
}
if (!artist.BaseVoicebank.NullSafeIdEquals(properties.BaseVoicebank))
{
var newBase = await ctx.NullSafeLoadAsync(properties.BaseVoicebank);
if (artist.IsValidBaseVoicebank(newBase))
{
diff.BaseVoicebank.Set();
artist.SetBaseVoicebank(await ctx.NullSafeLoadAsync(properties.BaseVoicebank));
}
}
if (!artist.ReleaseDate.Equals(properties.ReleaseDate))
{
artist.ReleaseDate = properties.ReleaseDate;
diff.ReleaseDate.Set();
}
var webLinkDiff = WebLink.Sync(artist.WebLinks, properties.WebLinks, artist);
await ctx.OfType <ArtistWebLink>().SyncAsync(webLinkDiff);
if (webLinkDiff.Changed)
{
diff.WebLinks.Set();
}
if (diff.ArtistType.IsChanged || diff.Names.IsChanged || diff.OriginalName.IsChanged)
{
foreach (var song in artist.Songs)
{
song.Song.UpdateArtistString();
await ctx.UpdateAsync(song);
}
}
var newGroups = properties.Groups
.Select(g => new ArtistForArtistContract {
Parent = g.Parent, LinkType = ArtistLinkType.Group
})
.Concat(new[] {
new ArtistForArtistContract {
Parent = properties.Illustrator, LinkType = ArtistLinkType.Illustrator
},
new ArtistForArtistContract {
Parent = properties.VoiceProvider, LinkType = ArtistLinkType.VoiceProvider
}
})
.Concat(properties.AssociatedArtists)
.Where(a => a.Parent != null && ArtistHelper.CanHaveRelatedArtists(artist.ArtistType, a.LinkType, LinkDirection.ManyToOne))
.ToArray();
var groupsDiff = CollectionHelper.Diff(artist.Groups, newGroups, (i, i2) => (i.Parent.Id == i2.Parent.Id && i.LinkType == i2.LinkType));
foreach (var grp in groupsDiff.Removed)
{
grp.Delete();
await ctx.DeleteAsync(grp);
}
foreach (var grp in groupsDiff.Added)
{
var link = artist.AddGroup(ctx.Load(grp.Parent.Id), grp.LinkType);
await ctx.SaveAsync(link);
}
if (groupsDiff.Changed)
{
diff.Groups.Set();
}
var picsDiff = artist.Pictures.SyncPictures(properties.Pictures, ctx.OfType <User>().GetLoggedUser(permissionContext), artist.CreatePicture);
ctx.OfType <ArtistPictureFile>().Sync(picsDiff);
var entryPictureFileThumbGenerator = new ImageThumbGenerator(pictureFilePersister);
artist.Pictures.GenerateThumbsAndMoveImage(entryPictureFileThumbGenerator, picsDiff.Added, ImageSizes.Original | ImageSizes.Thumb);
if (picsDiff.Changed)
{
diff.Pictures.Set();
}
var logStr = string.Format("updated properties for artist {0} ({1})", entryLinkFactory.CreateEntryLink(artist), diff.ChangedFieldsString)
+ (properties.UpdateNotes != string.Empty ? " " + properties.UpdateNotes : string.Empty)
.Truncate(400);
var archived = await ArchiveAsync(ctx, artist, diff, ArtistArchiveReason.PropertiesUpdated, properties.UpdateNotes);
await ctx.UpdateAsync(artist);
await ctx.AuditLogger.AuditLogAsync(logStr);
await AddEntryEditedEntryAsync(ctx.OfType <ActivityEntry>(), artist, EntryEditEvent.Updated, archived);
return artist.Id;
}));
}
public int UpdateSeries(ReleaseEventSeriesForEditContract contract, EntryPictureFileContract pictureData)
{
ParamIs.NotNull(() => contract);
PermissionContext.VerifyPermission(PermissionToken.ManageEventSeries);
return(HandleTransaction(session => {
ReleaseEventSeries series;
if (contract.Id == 0)
{
series = new ReleaseEventSeries(contract.Name, contract.Description, contract.Aliases);
session.Save(series);
var diff = new ReleaseEventSeriesDiff(ReleaseEventSeriesEditableFields.Name);
diff.Description.Set(!string.IsNullOrEmpty(contract.Description));
diff.Names.Set(contract.Aliases.Any());
var weblinksDiff = WebLink.Sync(series.WebLinks, contract.WebLinks, series);
if (weblinksDiff.Changed)
{
diff.WebLinks.Set();
session.OfType <ReleaseEventWebLink>().Sync(weblinksDiff);
}
if (pictureData != null)
{
diff.Picture.Set();
SaveImage(series, pictureData);
session.Update(series);
}
session.Update(series);
Archive(session, series, diff, EntryEditEvent.Created, string.Empty);
AuditLog(string.Format("created {0}", entryLinkFactory.CreateEntryLink(series)), session);
}
else
{
series = session.Load <ReleaseEventSeries>(contract.Id);
var diff = new ReleaseEventSeriesDiff(ReleaseEventSeriesEditableFields.Name);
if (series.Name != contract.Name)
{
diff.Name.Set();
series.Name = contract.Name;
}
if (series.Description != contract.Description)
{
diff.Description.Set();
series.Description = contract.Description;
}
if (series.UpdateAliases(contract.Aliases))
{
diff.Names.Set();
}
if (pictureData != null)
{
diff.Picture.Set();
SaveImage(series, pictureData);
}
var weblinksDiff = WebLink.Sync(series.WebLinks, contract.WebLinks, series);
if (weblinksDiff.Changed)
{
diff.WebLinks.Set();
session.OfType <ReleaseEventWebLink>().Sync(weblinksDiff);
}
session.Update(series);
Archive(session, series, diff, EntryEditEvent.Updated, string.Empty);
AuditLog(string.Format("updated {0}", entryLinkFactory.CreateEntryLink(series)), session);
}
return series.Id;
}));
}
public int Update(ArtistForEditContract properties, EntryPictureFileContract pictureData, IUserPermissionContext permissionContext)
{
ParamIs.NotNull(() => properties);
ParamIs.NotNull(() => permissionContext);
return(repository.HandleTransaction(ctx => {
var artist = ctx.Load(properties.Id);
VerifyEntryEdit(artist);
var diff = new ArtistDiff(DoSnapshot(artist.GetLatestVersion(), ctx.OfType <User>().GetLoggedUser(permissionContext)));
ctx.AuditLogger.SysLog(string.Format("updating properties for {0}", artist));
if (artist.ArtistType != properties.ArtistType)
{
artist.ArtistType = properties.ArtistType;
diff.ArtistType = true;
}
if (artist.Description != properties.Description)
{
artist.Description = properties.Description;
diff.Description = true;
}
if (artist.TranslatedName.DefaultLanguage != properties.DefaultNameLanguage)
{
artist.TranslatedName.DefaultLanguage = properties.DefaultNameLanguage;
diff.OriginalName = true;
}
// Required because of a bug in NHibernate
NHibernateUtil.Initialize(artist.Picture);
if (pictureData != null)
{
var parsed = ImageHelper.GetOriginal(pictureData.UploadedFile, pictureData.ContentLength, pictureData.Mime);
artist.Picture = new PictureData(parsed);
artist.PictureMime = parsed.Mime;
pictureData.Id = artist.Id;
pictureData.EntryType = EntryType.Artist;
var thumbGenerator = new ImageThumbGenerator(imagePersister);
thumbGenerator.GenerateThumbsAndMoveImage(pictureData.UploadedFile, pictureData, ImageSizes.Thumb | ImageSizes.SmallThumb | ImageSizes.TinyThumb);
diff.Picture = true;
}
if (artist.Status != properties.Status)
{
artist.Status = properties.Status;
diff.Status = true;
}
var nameDiff = artist.Names.Sync(properties.Names, artist);
ctx.OfType <ArtistName>().Sync(nameDiff);
if (nameDiff.Changed)
{
diff.Names = true;
}
if (!artist.BaseVoicebank.NullSafeIdEquals(properties.BaseVoicebank))
{
var newBase = ctx.NullSafeLoad(properties.BaseVoicebank);
if (artist.IsValidBaseVoicebank(newBase))
{
diff.BaseVoicebank = true;
artist.SetBaseVoicebank(ctx.NullSafeLoad(properties.BaseVoicebank));
}
}
var validWebLinks = properties.WebLinks.Where(w => !string.IsNullOrEmpty(w.Url));
var webLinkDiff = WebLink.Sync(artist.WebLinks, validWebLinks, artist);
ctx.OfType <ArtistWebLink>().Sync(webLinkDiff);
if (webLinkDiff.Changed)
{
diff.WebLinks = true;
}
if (diff.ArtistType || diff.Names)
{
foreach (var song in artist.Songs)
{
song.Song.UpdateArtistString();
ctx.Update(song);
}
}
var groupsDiff = CollectionHelper.Diff(artist.Groups, properties.Groups, (i, i2) => (i.Id == i2.Id));
foreach (var grp in groupsDiff.Removed)
{
grp.Delete();
ctx.Delete(grp);
}
foreach (var grp in groupsDiff.Added)
{
var link = artist.AddGroup(ctx.Load(grp.Group.Id));
ctx.Save(link);
}
if (groupsDiff.Changed)
{
diff.Groups = true;
}
var picsDiff = artist.Pictures.SyncPictures(properties.Pictures, ctx.OfType <User>().GetLoggedUser(permissionContext), artist.CreatePicture);
ctx.OfType <ArtistPictureFile>().Sync(picsDiff);
ImageHelper.GenerateThumbsAndMoveImages(picsDiff.Added);
if (picsDiff.Changed)
{
diff.Pictures = true;
}
var logStr = string.Format("updated properties for artist {0} ({1})", entryLinkFactory.CreateEntryLink(artist), diff.ChangedFieldsString)
+ (properties.UpdateNotes != string.Empty ? " " + properties.UpdateNotes : string.Empty)
.Truncate(400);
ctx.AuditLogger.AuditLog(logStr);
AddEntryEditedEntry(ctx.OfType <ActivityEntry>(), artist, EntryEditEvent.Updated);
Archive(ctx, artist, diff, ArtistArchiveReason.PropertiesUpdated, properties.UpdateNotes);
ctx.Update(artist);
return artist.Id;
}));
}
public static string GetImageUrlThumb(EntryPictureFileContract picture)
{
return(GetImageUrl(picture.EntryType, EntryPictureFile.GetFileNameThumb(picture.Id, picture.Mime)));
}
public static string GetImagePath(EntryPictureFileContract picture)
{
return(GetImagePath(picture.EntryType, EntryPictureFile.GetFileName(picture.Id, picture.Mime)));
}
/// <summary>
/// Updates or creates release event.
///
/// Album release event names will be updated as well if the name changed.
/// </summary>
/// <param name="contract">Updated contract. Cannot be null.</param>
/// <returns>Updated release event data. Cannot be null.</returns>
public ReleaseEventContract Update(ReleaseEventDetailsContract contract, EntryPictureFileContract pictureData)
{
ParamIs.NotNull(() => contract);
PermissionContext.VerifyManageDatabase();
return(repository.HandleTransaction(session => {
ReleaseEvent ev;
if (contract.Id == 0)
{
var diff = new ReleaseEventDiff();
if (!contract.Series.IsNullOrDefault())
{
var series = session.OfType <ReleaseEventSeries>().Load(contract.Series.Id);
ev = new ReleaseEvent(contract.Description, contract.Date, series, contract.SeriesNumber, contract.SeriesSuffix,
contract.Name, contract.CustomName);
series.Events.Add(ev);
}
else
{
ev = new ReleaseEvent(contract.Description, contract.Date, contract.Name);
}
ev.SongList = session.NullSafeLoad <SongList>(contract.SongList);
ev.Venue = contract.Venue;
if (contract.SongList != null)
{
diff.SongList.Set();
}
if (!string.IsNullOrEmpty(contract.Venue))
{
diff.Venue.Set();
}
var weblinksDiff = WebLink.Sync(ev.WebLinks, contract.WebLinks, ev);
if (weblinksDiff.Changed)
{
diff.WebLinks.Set();
}
CheckDuplicateName(session, ev);
session.Save(ev);
if (pictureData != null)
{
diff.MainPicture.Set();
SaveImage(ev, pictureData);
session.Update(ev);
}
var archived = Archive(session, ev, diff, EntryEditEvent.Created, string.Empty);
AddEntryEditedEntry(session.OfType <ActivityEntry>(), archived);
session.AuditLogger.AuditLog(string.Format("created {0}", entryLinkFactory.CreateEntryLink(ev)));
}
else
{
ev = session.Load(contract.Id);
var diff = new ReleaseEventDiff(DoSnapshot(ev, session));
if (!ev.Date.Equals(contract.Date))
{
diff.Date.Set();
}
if (ev.Description != contract.Description)
{
diff.Description.Set();
}
if (ev.Name != contract.Name && (contract.Series == null || contract.CustomName))
{
diff.Name.Set();
}
if (!ev.Series.NullSafeIdEquals(contract.Series))
{
diff.Series.Set();
}
if (ev.SeriesNumber != contract.SeriesNumber)
{
diff.SeriesNumber.Set();
}
if (ev.SeriesSuffix != contract.SeriesSuffix)
{
diff.SeriesSuffix.Set();
}
if (!ev.SongList.NullSafeIdEquals(contract.SongList))
{
diff.SongList.Set();
}
if (!string.Equals(ev.Venue, contract.Venue))
{
diff.Venue.Set();
}
ev.Series = session.NullSafeLoad <ReleaseEventSeries>(contract.Series);
ev.CustomName = contract.CustomName;
ev.Date = contract.Date;
ev.Description = contract.Description;
ev.Name = contract.Name;
ev.SeriesNumber = contract.SeriesNumber;
ev.SeriesSuffix = contract.SeriesSuffix;
ev.SongList = session.NullSafeLoad <SongList>(contract.SongList);
ev.Venue = contract.Venue;
ev.UpdateNameFromSeries();
var weblinksDiff = WebLink.Sync(ev.WebLinks, contract.WebLinks, ev);
if (weblinksDiff.Changed)
{
diff.WebLinks.Set();
session.OfType <ReleaseEventWebLink>().Sync(weblinksDiff);
}
CheckDuplicateName(session, ev);
if (pictureData != null)
{
diff.MainPicture.Set();
SaveImage(ev, pictureData);
}
session.Update(ev);
var archived = Archive(session, ev, diff, EntryEditEvent.Updated, string.Empty);
AddEntryEditedEntry(session.OfType <ActivityEntry>(), archived);
var logStr = string.Format("updated properties for {0} ({1})", entryLinkFactory.CreateEntryLink(ev), diff.ChangedFieldsString);
session.AuditLogger.AuditLog(logStr);
}
return new ReleaseEventContract(ev);
}));
}
