public void MoveToTrash(int listId)
{
PermissionContext.VerifyPermission(PermissionToken.EditProfile);
HandleTransaction(ctx =>
{
var user = GetLoggedUser(ctx);
var list = ctx.Load <SongList>(listId);
ctx.AuditLogger.SysLog($"deleting {list.ToString()}");
EntryPermissionManager.VerifyEdit(PermissionContext, list);
var archivedVersions = list.ArchivedVersionsManager.Versions;
ctx.DeleteAll(archivedVersions);
list.ArchivedVersionsManager.Versions.Clear();
var activityEntries = ctx.Query <SongListActivityEntry>().Where(a => a.Entry.Id == listId).ToArray();
ctx.DeleteAll(activityEntries);
ctx.Delete(list);
ctx.AuditLogger.AuditLog($"deleted {list.ToString()}", user);
});
}
private SongList CreateSongList(IRepositoryContext <SongList> ctx, SongListForEditContract contract, UploadedFileContract uploadedFile)
{
var user = GetLoggedUser(ctx);
var newList = new SongList(contract.Name, user);
newList.Description = contract.Description;
if (EntryPermissionManager.CanManageFeaturedLists(permissionContext))
{
newList.FeaturedCategory = contract.FeaturedCategory;
}
ctx.Save(newList);
var songDiff = newList.SyncSongs(contract.SongLinks, c => ctx.OfType <Song>().Load(c.SongId));
ctx.OfType <SongInList>().Sync(songDiff);
SetThumb(newList, uploadedFile);
ctx.Update(newList);
ctx.AuditLogger.AuditLog(string.Format("created song list {0}", entryLinkFactory.CreateEntryLink(newList)), user);
Archive(ctx, newList, new SongListDiff(), EntryEditEvent.Created);
return(newList);
}
private SongList CreateSongList(IDatabaseContext <SongList> ctx, SongListForEditContract contract, UploadedFileContract uploadedFile)
{
var user = GetLoggedUser(ctx);
var newList = new SongList(contract.Name, user);
newList.Description = contract.Description ?? string.Empty;
newList.EventDate = contract.EventDate;
if (EntryPermissionManager.CanManageFeaturedLists(permissionContext))
{
newList.FeaturedCategory = contract.FeaturedCategory;
}
ctx.Save(newList);
var songDiff = newList.SyncSongs(contract.SongLinks, c => ctx.OfType <Song>().Load(c.Song.Id));
ctx.OfType <SongInList>().Sync(songDiff);
SetThumb(newList, uploadedFile);
ctx.Update(newList);
ctx.AuditLogger.AuditLog(string.Format("created song list {0}", entryLinkFactory.CreateEntryLink(newList)), user);
var archived = Archive(ctx, newList, new SongListDiff(), EntryEditEvent.Created, contract.UpdateNotes);
if (newList.FeaturedList)
{
AddEntryEditedEntry(ctx.OfType <ActivityEntry>(), newList, EntryEditEvent.Created, archived);
}
return(newList);
}
public SongDetailsContract(Song song, ContentLanguagePreference languagePreference,
SongListBaseContract[] pools, ISpecialTags specialTags, IUserPermissionContext userContext, IEntryThumbPersister thumbPersister)
{
Song = new SongContract(song, languagePreference);
AdditionalNames = song.Names.GetAdditionalNamesStringForLanguage(languagePreference);
Albums = song.OnAlbums.OrderBy(a => a.OriginalReleaseDate.SortableDateTime).Select(a => new AlbumContract(a, languagePreference)).ToArray();
AlternateVersions = song.AlternateVersions.Select(s => new SongContract(s, languagePreference, getThumbUrl: false)).OrderBy(s => s.PublishDate).ToArray();
Artists = song.Artists.Select(a => new ArtistForSongContract(a, languagePreference)).OrderBy(a => a.Name).ToArray();
ArtistString = song.ArtistString[languagePreference];
CanEditPersonalDescription = EntryPermissionManager.CanEditPersonalDescription(userContext, song);
CanRemoveTagUsages = EntryPermissionManager.CanRemoveTagUsages(userContext, song);
CreateDate = song.CreateDate;
Deleted = song.Deleted;
LikeCount = song.UserFavorites.Count(f => f.Rating == SongVoteRating.Like);
LyricsFromParents = song.GetLyricsFromParents(specialTags).Select(l => new LyricsForSongContract(l, false)).ToArray();
Notes = song.Notes;
OriginalVersion = (song.OriginalVersion != null && !song.OriginalVersion.Deleted ?
new SongForApiContract(song.OriginalVersion, null, languagePreference, SongOptionalFields.AdditionalNames | SongOptionalFields.ThumbUrl) : null);
PVs = song.PVs.Select(p => new PVContract(p)).ToArray();
ReleaseEvent = song.ReleaseEvent != null && !song.ReleaseEvent.Deleted ? new ReleaseEventForApiContract(song.ReleaseEvent, languagePreference, ReleaseEventOptionalFields.None, thumbPersister, true) : null;
PersonalDescriptionText = song.PersonalDescriptionText;
var author = song.PersonalDescriptionAuthor;
PersonalDescriptionAuthor = author != null ? new ArtistForApiContract(author, languagePreference, thumbPersister, true, ArtistOptionalFields.MainPicture) : null;
SubjectsFromParents = song.GetCharactersFromParents().Select(c => new ArtistForSongContract(c, languagePreference)).ToArray();
Tags = song.Tags.ActiveUsages.Select(u => new TagUsageForApiContract(u, languagePreference)).OrderByDescending(t => t.Count).ToArray();
TranslatedName = new TranslatedStringContract(song.TranslatedName);
WebLinks = song.WebLinks.Select(w => new WebLinkContract(w)).OrderBy(w => w.DescriptionOrUrl).ToArray();
Pools = pools;
}
public AlbumDetailsContract(Album album, ContentLanguagePreference languagePreference, IUserPermissionContext userContext, IAggregatedEntryImageUrlFactory thumbPersister,
Func <Song, SongVoteRating?> getSongRating = null, Tag discTypeTag = null)
: base(album, languagePreference)
{
ArtistLinks = album.Artists.Select(a => new ArtistForAlbumContract(a, languagePreference)).OrderBy(a => a.Name).ToArray();
CanEditPersonalDescription = EntryPermissionManager.CanEditPersonalDescription(userContext, album);
CanRemoveTagUsages = EntryPermissionManager.CanRemoveTagUsages(userContext, album);
Description = album.Description;
Discs = album.Songs.Any(s => s.DiscNumber > 1) ? album.Discs.Select(d => new AlbumDiscPropertiesContract(d)).ToDictionary(a => a.DiscNumber) : new Dictionary <int, AlbumDiscPropertiesContract>(0);
DiscTypeTypeTag = discTypeTag != null ? new TagBaseContract(discTypeTag, languagePreference) : null;
OriginalRelease = (album.OriginalRelease != null ? new AlbumReleaseContract(album.OriginalRelease, languagePreference) : null);
Pictures = album.Pictures.Select(p => new EntryPictureFileContract(p, thumbPersister)).ToArray();
PVs = album.PVs.Select(p => new PVContract(p)).ToArray();
Songs = album.Songs
.OrderBy(s => s.DiscNumber).ThenBy(s => s.TrackNumber)
.Select(s => new SongInAlbumContract(s, languagePreference, false, rating: getSongRating?.Invoke(s.Song)))
.ToArray();
Tags = album.Tags.ActiveUsages.Select(u => new TagUsageForApiContract(u, languagePreference)).OrderByDescending(t => t.Count).ToArray();
WebLinks = album.WebLinks.Select(w => new WebLinkContract(w)).OrderBy(w => w.DescriptionOrUrl).ToArray();
PersonalDescriptionText = album.PersonalDescriptionText;
var author = album.PersonalDescriptionAuthor;
PersonalDescriptionAuthor = author != null ? new ArtistForApiContract(author, languagePreference, thumbPersister, ArtistOptionalFields.MainPicture) : null;
TotalLength = Songs.All(s => s.Song != null && s.Song.LengthSeconds > 0) ? TimeSpan.FromSeconds(Songs.Sum(s => s.Song.LengthSeconds)) : TimeSpan.Zero;
}
public void CopyNonEditableProperties(TagForEditContract contract, IUserPermissionContext permissionContext)
{
AllowedEntryStatuses = EntryPermissionManager.AllowedEntryStatuses(permissionContext).ToArray();
CanDelete = contract.CanDelete;
CurrentName = contract.Name;
Deleted = contract.Deleted;
Id = contract.Id;
IsEmpty = contract.IsEmpty;
Thumb = contract.Thumb;
UrlSlug = contract.UrlSlug;
string GetTagTargetTypeName(TagTargetTypes t)
{
switch (t)
{
case TagTargetTypes.Nothing:
return("Nothing");
case TagTargetTypes.All:
return("Anything");
}
return(string.Join(", ", EnumVal <EntryType> .Values.Where(e => e != EntryType.Undefined).Where(e => t.HasFlag((TagTargetTypes)e)).Select(e => Translate.EntryTypeNames[e])));
}
AllTagTargetTypes = new[] { TagTargetTypes.Album, TagTargetTypes.Artist, TagTargetTypes.Song, TagTargetTypes.Event }
.ToDictionary(t => t, GetTagTargetTypeName);
}
public EventEdit(ReleaseEventSeriesContract seriesContract, IUserPermissionContext userContext)
: this()
{
Series = seriesContract;
AllowedEntryStatuses = EntryPermissionManager.AllowedEntryStatuses(userContext).ToArray();
}
public ActionResult EditSeries(SeriesEdit model, HttpPostedFileBase pictureUpload = null)
{
ActionResult RenderEdit()
{
model.AllowedEntryStatuses = EntryPermissionManager.AllowedEntryStatuses(PermissionContext).ToArray();
return(View("EditSeries", model));
}
// Note: name is allowed to be whitespace, but not empty.
if (model.Names == null || model.Names.All(n => string.IsNullOrEmpty(n?.Value)))
{
ModelState.AddModelError("Names", "Name cannot be empty");
}
if (!ModelState.IsValid)
{
return(RenderEdit());
}
var pictureData = ParsePicture(pictureUpload, "Picture", ImagePurpose.Main);
int id;
try {
id = queries.UpdateSeries(model.ToContract(), pictureData);
} catch (DuplicateEventNameException x) {
ModelState.AddModelError("Names", x.Message);
return(RenderEdit());
}
return(RedirectToAction("SeriesDetails", new { id }));
}
public void UpdateUser(UserWithPermissionsContract contract)
{
ParamIs.NotNull(() => contract);
UpdateEntity <User>(contract.Id, (session, user) => {
if (!EntryPermissionManager.CanEditUser(PermissionContext, user.GroupId))
{
var loggedUser = GetLoggedUser(session);
var msg = string.Format("{0} (level {1}) not allowed to edit {2}", loggedUser, loggedUser.GroupId, user);
log.Error(msg);
throw new NotAllowedException(msg);
}
if (EntryPermissionManager.CanEditGroupTo(PermissionContext, contract.GroupId))
{
user.GroupId = contract.GroupId;
}
if (EntryPermissionManager.CanEditAdditionalPermissions(PermissionContext))
{
user.AdditionalPermissions = new PermissionCollection(contract.AdditionalPermissions.Select(p => PermissionToken.GetById(p.Id)));
}
var diff = OwnedArtistForUser.Sync(user.AllOwnedArtists, contract.OwnedArtistEntries, a => user.AddOwnedArtist(session.Load <Artist>(a.Artist.Id)));
SessionHelper.Sync(session, diff);
user.Active = contract.Active;
AuditLog(string.Format("updated {0}", EntryLinkFactory.CreateEntryLink(user)), session);
}, PermissionToken.ManageUserPermissions, skipLog: true);
}
public void AddSongToList(int listId, int songId, string notes)
{
PermissionContext.VerifyPermission(PermissionToken.EditProfile);
HandleTransaction(session =>
{
var list = session.Load <SongList>(listId);
var items = session.Query <SongInList>().Where(s => s.List.Id == listId);
int order = 1;
if (items.Any())
{
order = items.Max(s => s.Order) + 1;
}
EntryPermissionManager.VerifyEdit(PermissionContext, list);
var song = session.Load <Song>(songId);
var link = list.AddSong(song, order, notes);
session.Save(link);
SysLog($"added {song} to {list}");
});
}
public UserEdit()
{
var groups = EnumVal <UserGroupId> .Values.Where(g => EntryPermissionManager.CanEditGroupTo(Login.Manager, g)).ToArray();
EditableGroups = new TranslateableEnum <UserGroupId>(() => global::Resources.UserGroupNames.ResourceManager, groups);
OwnedArtists = new List <ArtistForUserContract>();
Permissions = new List <PermissionFlagEntry>();
}
public AlbumDetails(AlbumDetailsContract contract)
{
ParamIs.NotNull(() => contract);
AdditionalNames = contract.AdditionalNames;
ArtistString = contract.ArtistString;
CanEdit = EntryPermissionManager.CanEdit(MvcApplication.LoginManager, contract);
CommentCount = contract.CommentCount;
CreateDate = contract.CreateDate;
Description = contract.Description;
Deleted = contract.Deleted;
DiscType = contract.DiscType;
Draft = contract.Status == EntryStatus.Draft;
Hits = contract.Hits;
Id = contract.Id;
LatestComments = contract.LatestComments;
MergedTo = contract.MergedTo;
Name = contract.Name;
OwnedBy = contract.OwnedCount;
Pictures = contract.Pictures;
PVs = contract.PVs;
RatingAverage = contract.RatingAverage;
RatingCount = contract.RatingCount;
Songs = contract.Songs.GroupBy(s => s.DiscNumber).ToArray();
Status = contract.Status;
Tags = contract.Tags;
UserHasAlbum = contract.AlbumForUser != null;
Version = contract.Version;
WebLinks = contract.WebLinks;
WishlistedBy = contract.WishlistCount;
mime = contract.CoverPictureMime;
if (contract.AlbumForUser != null)
{
AlbumMediaType = contract.AlbumForUser.MediaType;
AlbumPurchaseStatus = contract.AlbumForUser.PurchaseStatus;
CollectionRating = contract.AlbumForUser.Rating;
}
if (contract.OriginalRelease != null)
{
CatNum = contract.OriginalRelease.CatNum;
ReleaseEvent = contract.OriginalRelease.EventName;
ReleaseDate = contract.OriginalRelease.ReleaseDate;
FullReleaseDate = ReleaseDate.Year.HasValue && ReleaseDate.Month.HasValue && ReleaseDate.Day.HasValue ? (DateTime?)new DateTime(ReleaseDate.Year.Value, ReleaseDate.Month.Value, ReleaseDate.Day.Value) : null;
}
var artists = contract.ArtistLinks;
Bands = artists.Where(a => a.Categories.HasFlag(ArtistCategories.Band)).ToArray();
Circles = artists.Where(a => a.Categories.HasFlag(ArtistCategories.Circle)).ToArray();
Labels = artists.Where(a => a.Categories.HasFlag(ArtistCategories.Label)).ToArray();
Producers = artists.Where(a => a.Categories.HasFlag(ArtistCategories.Producer)).ToArray();
Vocalists = artists.Where(a => a.Categories.HasFlag(ArtistCategories.Vocalist)).ToArray();
OtherArtists = artists.Where(a => a.Categories.HasFlag(ArtistCategories.Other) || a.Categories.HasFlag(ArtistCategories.Animator)).ToArray();
PrimaryPV = PVHelper.PrimaryPV(PVs);
}
public void CopyNonEditableFields(ArtistForEditContract artist)
{
ParamIs.NotNull(() => artist);
AllowedEntryStatuses = EntryPermissionManager.AllowedEntryStatuses(MvcApplication.LoginManager);
Deleted = artist.Deleted;
Draft = artist.Status == EntryStatus.Draft;
ValidationResult = artist.ValidationResult;
}
private void TestCanEdit(bool expected, EntryStatus entryStatus = EntryStatus.Finished, UserGroupId userGroup = UserGroupId.Regular)
{
_artist.Status = entryStatus;
_user.GroupId = userGroup;
var result = EntryPermissionManager.CanEdit(new FakePermissionContext(_user), _artist);
result.Should().Be(expected, "result");
}
public void CopyNonEditableProperties(ReleaseEventSeriesForEditContract contract, IUserPermissionContext userContext)
{
AllowedEntryStatuses = EntryPermissionManager.AllowedEntryStatuses(userContext).ToArray();
if (contract != null)
{
Deleted = contract.Deleted;
}
}
private void TestCanEdit(bool expected, EntryStatus entryStatus = EntryStatus.Finished, UserGroupId userGroup = UserGroupId.Regular)
{
artist.Status = entryStatus;
user.GroupId = userGroup;
var result = EntryPermissionManager.CanEdit(new FakePermissionContext(user), artist);
Assert.AreEqual(expected, result, "result");
}
public SongEditViewModel(SongContract song, IUserPermissionContext permissionContext,
SongForEditContract editedSong = null)
: this()
{
ParamIs.NotNull(() => song);
Song = song;
AllowedEntryStatuses = EntryPermissionManager.AllowedEntryStatuses(permissionContext);
EditedSong = editedSong;
}
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 SongListContract(SongList list, IUserPermissionContext permissionContext)
: base(list)
{
ParamIs.NotNull(() => list);
Author = new UserContract(list.Author);
CanEdit = EntryPermissionManager.CanEdit(permissionContext, list);
Description = list.Description;
FeaturedCategory = list.FeaturedCategory;
}
public ArtistEditViewModel(ArtistContract artist, IUserPermissionContext permissionContext,
ArtistForEditContract editedArtist = null)
: this()
{
ParamIs.NotNull(() => artist);
Artist = artist;
AllowedEntryStatuses = EntryPermissionManager.AllowedEntryStatuses(permissionContext);
EditedArtist = editedArtist;
}
public SongListContract(SongList list, IUserPermissionContext permissionContext)
: base(list)
{
ParamIs.NotNull(() => list);
Author = new UserWithEmailContract(list.Author);
CanEdit = EntryPermissionManager.CanEdit(permissionContext, list);
Description = list.Description;
FeaturedCategory = list.FeaturedCategory;
Thumb = (list.Thumb != null ? new EntryThumbContract(list.Thumb) : null);
}
public void CopyNonEditableProperties(TagForEditContract contract, IUserPermissionContext permissionContext)
{
AllowedEntryStatuses = EntryPermissionManager.AllowedEntryStatuses(permissionContext).ToArray();
CanDelete = contract.CanDelete;
CurrentName = contract.Name;
Deleted = contract.Deleted;
Id = contract.Id;
IsEmpty = contract.IsEmpty;
Thumb = contract.Thumb;
UrlSlug = contract.UrlSlug;
}
public AlbumEditViewModel(AlbumContract album, IUserPermissionContext permissionContext,
AlbumForEditContract editedAlbum = null)
: this()
{
ParamIs.NotNull(() => album);
Album = album;
EditedAlbum = editedAlbum;
AllowedEntryStatuses = EntryPermissionManager.AllowedEntryStatuses(permissionContext);
}
public void Delete(int id, string notes)
{
UpdateEntity <Song>(id, (session, song) => {
EntryPermissionManager.VerifyDelete(PermissionContext, song);
AuditLog(string.Format("deleting song {0}", EntryLinkFactory.CreateEntryLink(song)), session);
song.Delete();
Archive(session, song, new SongDiff(false), SongArchiveReason.Deleted, notes);
}, PermissionToken.Nothing, skipLog: true);
}
public SongListContract(SongList list, IUserPermissionContext permissionContext)
: base(list)
{
ParamIs.NotNull(() => list);
Author = new UserWithEmailContract(list.Author);
CanEdit = EntryPermissionManager.CanEdit(permissionContext, list);
Description = list.Description;
EventDate = list.EventDate;
Status = list.Status;
Thumb = (list.Thumb != null ? new EntryThumbContract(list.Thumb) : null);
Version = list.Version;
}
public void Delete(int id, string notes)
{
UpdateEntity <Album>(id, (session, a) => {
EntryPermissionManager.VerifyDelete(PermissionContext, a);
AuditLog(string.Format("deleting album {0}", EntryLinkFactory.CreateEntryLink(a)), session);
NHibernateUtil.Initialize(a.CoverPictureData);
a.Delete();
Archive(session, a, new AlbumDiff(false), AlbumArchiveReason.Deleted, notes);
}, PermissionToken.Nothing, skipLog: true);
}
public void Delete(int id, string notes)
{
UpdateEntity <Artist>(id, (session, a) => {
EntryPermissionManager.VerifyDelete(PermissionContext, a);
AuditLog(string.Format("deleting artist {0}{1}", EntryLinkFactory.CreateEntryLink(a), !string.IsNullOrEmpty(notes) ? " " + notes : string.Empty), session);
NHibernateUtil.Initialize(a.Picture);
a.Delete();
Archive(session, a, new ArtistDiff(false), ArtistArchiveReason.Deleted, notes);
}, PermissionToken.Nothing, skipLog: true);
}
public void CopyNonEditableProperties(ReleaseEventDetailsContract contract, IUserPermissionContext userContext)
{
AllowedEntryStatuses = EntryPermissionManager.AllowedEntryStatuses(userContext).ToArray();
if (contract != null)
{
Deleted = contract.Deleted;
OldName = contract.Name;
PictureMime = contract.PictureMime;
UrlSlug = contract.UrlSlug;
Version = contract.Version;
}
}
public TagForEditContract(Tag tag, bool isEmpty, IUserPermissionContext userContext)
: base(tag, userContext.LanguagePreference)
{
CanDelete = EntryPermissionManager.CanDelete(userContext, tag);
DefaultNameLanguage = tag.TranslatedName.DefaultLanguage;
Description = new EnglishTranslatedStringContract(tag.Description);
IsEmpty = isEmpty;
Names = tag.Names.Select(n => new LocalizedStringWithIdContract(n)).ToArray();
RelatedTags = tag.RelatedTags.Select(t => new TagBaseContract(t.LinkedTag, userContext.LanguagePreference, false)).ToArray();
Thumb = (tag.Thumb != null ? new EntryThumbContract(tag.Thumb) : null);
UpdateNotes = string.Empty;
WebLinks = tag.WebLinks.Links.Select(w => new WebLinkContract(w)).OrderBy(w => w.DescriptionOrUrl).ToArray();
}
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;
}
