internal static bool CanAccessResourceCore(PermissionContext permissionContext)
{
var user = permissionContext.User;
var controller = permissionContext.ControllerContext.Controller;
if (controller is PracticeController)
{
var practiceController = controller as PracticeController;
var isSelf = practiceController.IsSelfUser(user);
return isSelf;
}
return false;
}
protected override void BuildRenderTreeInternal(GridRendererContext rendererContext, PermissionContext permissionContext)
{
rendererContext.OpenElement(HtmlTagNames.TableRow, rendererContext.CssClasses.TableRow);
var localActualItem = rendererContext.ActualItem;
rendererContext.AddOnClickEvent(
EventCallback.Factory.Create(this, (MouseEventArgs e) =>
{
rendererContext.TableDataSet
.GridViewEvents
.OnItemClicked?.Invoke(new ItemClickedArgs {
Item = localActualItem
});
}));
foreach (var property in rendererContext.GridItemProperties)
{
rendererContext.ActualColumnName = property.Name;
rendererContext.ActualColumnPropertyCanBeEdited = property.CanWrite;
GridPartRenderers.ForEach(renderer => renderer.BuildRendererTree(rendererContext, permissionContext));
}
rendererContext.CloseElement();
GridPartRenderersAfter.ForEach(renderer => renderer.BuildRendererTree(rendererContext, permissionContext));
}
public void Merge(int sourceId, int targetId)
{
PermissionContext.VerifyPermission(PermissionToken.MergeEntries);
if (sourceId == targetId)
{
throw new ArgumentException("Source and target artists can't be the same", "targetId");
}
HandleTransaction(session =>
{
var source = session.Load <Artist>(sourceId);
var target = session.Load <Artist>(targetId);
AuditLog($"Merging {EntryLinkFactory.CreateEntryLink(source)} to {EntryLinkFactory.CreateEntryLink(target)}", session);
NHibernateUtil.Initialize(source.Picture);
NHibernateUtil.Initialize(target.Picture);
foreach (var n in source.Names.Names.Where(n => !target.HasName(n)))
{
var name = target.CreateName(n.Value, n.Language);
session.Save(name);
}
foreach (var w in source.WebLinks.Where(w => !target.HasWebLink(w.Url)))
{
var link = target.CreateWebLink(w.Description, w.Url, w.Category, w.Disabled);
session.Save(link);
}
var groups = source.Groups.Where(g => !target.HasGroup(g.Parent)).ToArray();
foreach (var g in groups)
{
g.MoveToMember(target);
session.Update(g);
}
var members = source.Members.Where(m => !m.Member.HasGroup(target)).ToArray();
foreach (var m in members)
{
m.MoveToGroup(target);
session.Update(m);
}
var albums = source.Albums.Where(a => !target.HasAlbum(a.Album)).ToArray();
foreach (var a in albums)
{
a.Move(target);
session.Update(a);
}
var songs = source.Songs.Where(s => !target.HasSong(s.Song)).ToArray();
foreach (var s in songs)
{
s.Move(target);
session.Update(s);
}
var ownerUsers = source.OwnerUsers.Where(s => !target.HasOwnerUser(s.User)).ToArray();
foreach (var u in ownerUsers)
{
u.Move(target);
session.Update(u);
}
var pictures = source.Pictures.ToArray();
foreach (var p in pictures)
{
p.Move(target);
session.Update(p);
}
var users = source.Users.ToArray();
foreach (var u in users)
{
u.Move(target);
session.Update(u);
}
target.Description.CopyIfEmpty(source.Description);
// Create merge record
var mergeEntry = new ArtistMergeRecord(source, target);
session.Save(mergeEntry);
source.Deleted = true;
Archive(session, source, ArtistArchiveReason.Deleted, $"Merged to {target}");
Archive(session, target, ArtistArchiveReason.Merged, $"Merged from '{source}'");
NHibernateUtil.Initialize(source.Picture);
NHibernateUtil.Initialize(target.Picture);
session.Update(source);
session.Update(target);
});
}
protected override void OnPermissionPrompt(PermissionContext context)
{
context.Result = _promptPermissionHookResult;
}
private void PromptMissingPermissions(PermissionContext permissionContext, string redirectUrl)
{
AuthorizationContext filterContext = permissionContext.FilterContext;
HashSet<string> requiredPermissions = permissionContext.RequiredPermissions;
// If there were no errors it means that we will be prompted with a permission prompt.
// Therefore, invoke the permission prompt hooks and navigate to the prompt.
IEnumerable<string> declinedPermissions = permissionContext.DeclinedPermissions;
IEnumerable<string> skippedPermissions = permissionContext.SkippedPermissions;
IEnumerable<string> missingPermissions = permissionContext.MissingPermissions;
// Declined permissions and skipped permissions can persist through multiple pages. So we need to cross check
// them against the current pages permissions, this will determine if we should invoke the denied permission hook.
bool deniedPermissions = missingPermissions.Where(
permission => declinedPermissions.Contains(permission) ||
skippedPermissions.Contains(permission)).Any();
permissionContext.RedirectUrl = redirectUrl;
// See if our persisted permissions cookie doesn't exist and if we've had missing permissions before.
// Essentially this checks to see if we've tried to persist permissions before and were unsuccessful due to an
// inability to create cookies.
if (!PermissionHelper.RequestedPermissionsCookieExists(filterContext.HttpContext.Request) &&
filterContext.HttpContext.Request.QueryString.Get(MissingPermissionsQueryName) != null)
{
OnCannotCreateCookies(permissionContext);
}
else
{
// The DeniedPermissionPromptHook will only be invoked if we detect there are denied permissions.
// It is attempted instead of the permission hook to allow app creators to handle situations when a user
// skip's or revokes previously prompted permissions. Ex: redirect to a different page.
if (deniedPermissions)
{
OnDeniedPermissionPrompt(permissionContext);
}
else
{
OnPermissionPrompt(permissionContext);
}
// We persist the requested permissions in a cookie to know if a permission was denied in any way.
// The persisted data allows us to detect skipping of permissions.
PermissionHelper.PersistRequestedPermissions(filterContext, requiredPermissions);
}
filterContext.Result = permissionContext.Result;
}
/// <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)
{
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);
}
var weblinksDiff = WebLink.Sync(ev.WebLinks, contract.WebLinks, ev);
if (weblinksDiff.Changed)
{
diff.WebLinks.Set();
}
CheckDuplicateName(session, ev);
session.Save(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();
}
var oldName = ev.Name;
ev.Series = session.OfType <ReleaseEventSeries>().NullSafeLoad(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.UpdateNameFromSeries();
var weblinksDiff = WebLink.Sync(ev.WebLinks, contract.WebLinks, ev);
if (weblinksDiff.Changed)
{
diff.WebLinks.Set();
session.OfType <ReleaseEventWebLink>().Sync(weblinksDiff);
}
CheckDuplicateName(session, ev);
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);
}));
}
public RoleSeeds(PermissionContext context) : base(context)
{
}
public PermissionMutations(IAuthorizationService authorizationService, PermissionContext context, IEventService eventService) : base(authorizationService)
{
_context = context;
_eventService = eventService;
}
public virtual void OnAuthorization(AuthorizationContext filterContext)
{
if (filterContext == null)
{
throw new ArgumentNullException("filterContext");
}
IEnumerable<FacebookAuthorizeAttribute> authorizeAttributes = filterContext.ActionDescriptor
.GetCustomAttributes(typeof(FacebookAuthorizeAttribute), inherit: true)
.Union(filterContext.ActionDescriptor.ControllerDescriptor
.GetCustomAttributes(typeof(FacebookAuthorizeAttribute), inherit: true))
.OfType<FacebookAuthorizeAttribute>();
if (!authorizeAttributes.Any())
{
return;
}
FacebookClient client = _config.ClientProvider.CreateClient();
HttpRequestBase request = filterContext.HttpContext.Request;
dynamic signedRequest = FacebookRequestHelpers.GetSignedRequest(
filterContext.HttpContext,
rawSignedRequest =>
{
return client.ParseSignedRequest(rawSignedRequest);
});
string userId = null;
string accessToken = null;
if (signedRequest != null)
{
userId = signedRequest.user_id;
accessToken = signedRequest.oauth_token;
}
NameValueCollection parsedQueries = HttpUtility.ParseQueryString(request.Url.Query);
HashSet<string> requiredPermissions = PermissionHelper.GetRequiredPermissions(authorizeAttributes);
bool handleError = !String.IsNullOrEmpty(parsedQueries["error"]);
// This must occur AFTER the handleError calculation because it modifies the parsed queries.
string redirectUrl = GetRedirectUrl(request, parsedQueries);
// Check if there was an error and we should handle it.
if (handleError)
{
Uri errorUrl;
if (String.IsNullOrEmpty(_config.AuthorizationRedirectPath))
{
errorUrl = DefaultAuthorizationRedirectUrl;
}
else
{
errorUrl = GetErroredAuthorizeUri(redirectUrl, requiredPermissions);
}
filterContext.Result = CreateRedirectResult(errorUrl);
// There was an error so short circuit
return;
}
FacebookContext facebookContext = new FacebookContext
{
Client = client,
SignedRequest = signedRequest,
AccessToken = accessToken,
UserId = userId,
Configuration = _config
};
PermissionContext permissionContext = new PermissionContext
{
FacebookContext = facebookContext,
FilterContext = filterContext,
RequiredPermissions = requiredPermissions,
};
// Check if we need to prompt for default permissions.
if (signedRequest == null || String.IsNullOrEmpty(userId) || String.IsNullOrEmpty(accessToken))
{
PromptDefaultPermissions(permissionContext, redirectUrl);
}
else if (requiredPermissions.Any())
{
PermissionsStatus currentPermissionsStatus = _config.PermissionService.GetUserPermissionsStatus(userId, accessToken);
// Instead of performing another request to gather "granted" permissions just parse the status
IEnumerable<string> currentPermissions = PermissionHelper.GetGrantedPermissions(currentPermissionsStatus);
IEnumerable<string> missingPermissions = requiredPermissions.Except(currentPermissions);
// If we have missing permissions than we need to present a prompt or redirect to an error
// page if there's an error.
if (missingPermissions.Any())
{
permissionContext.MissingPermissions = missingPermissions;
permissionContext.DeclinedPermissions = PermissionHelper.GetDeclinedPermissions(currentPermissionsStatus);
permissionContext.SkippedPermissions = PermissionHelper.GetSkippedPermissions(
filterContext.HttpContext.Request,
missingPermissions,
permissionContext.DeclinedPermissions);
PromptMissingPermissions(permissionContext, redirectUrl);
}
}
}
private void PromptMissingPermissions(PermissionContext permissionContext, string redirectUrl)
{
AuthorizationContext filterContext = permissionContext.FilterContext;
HashSet<string> requiredPermissions = permissionContext.RequiredPermissions;
// If there were no errors it means that we will be prompted with a permission prompt.
// Therefore, invoke the permission prompt hooks and navigate to the prompt.
IEnumerable<string> declinedPermissions = permissionContext.DeclinedPermissions;
IEnumerable<string> skippedPermissions = permissionContext.SkippedPermissions;
IEnumerable<string> missingPermissions = permissionContext.MissingPermissions;
// Declined permissions and skipped permissions can persist through multiple pages. So we need to cross check
// them against the current pages permissions, this will determine if we should invoke the denied permission hook.
bool deniedPermissions = missingPermissions.Where(
permission => declinedPermissions.Contains(permission) ||
skippedPermissions.Contains(permission)).Any();
permissionContext.RedirectUrl = redirectUrl;
// The DeniedPermissionPromptHook will only be invoked if we detect there are denied permissions.
// It is attempted instead of the permission hook to allow app creators to handle situations when a user
// skip's or revokes previously prompted permissions. Ex: redirect to a different page.
if (deniedPermissions)
{
OnDeniedPermissionPrompt(permissionContext);
}
else
{
OnPermissionPrompt(permissionContext);
}
// We persist the requested permissions in a cookie to know if a permission was denied in any way.
// The persisted data allows us to detect skipping of permissions.
PermissionHelper.PersistRequestedPermissions(filterContext, requiredPermissions);
filterContext.Result = permissionContext.Result;
}
private void PromptDefaultPermissions(PermissionContext permissionContext, string redirectUrl)
{
FacebookClient client = permissionContext.FacebookContext.Client;
// Cannot obtain user information from signed_request, redirect to Facebook OAuth dialog.
Uri navigationUrl = client.GetLoginUrl(redirectUrl,
_config.AppId,
permissions: null);
permissionContext.FilterContext.Result = CreateRedirectResult(navigationUrl);
}
/// <summary>
/// Invoked during <see cref="OnAuthorization"/> prior to a permission prompt that is requesting permissions that have
/// not been requested before. Set the <paramref name="context"/>'s Result property to modify login flow.
/// </summary>
/// <param name="context">Provides access to permission information associated with the user.</param>
protected virtual void OnPermissionPrompt(PermissionContext context)
{
context.Result = ShowPrompt(context);
}
/// <summary>
/// Invoked during <see cref="OnAuthorization"/> when a prompt requests permissions that were skipped or revoked.
/// Set the <paramref name="context"/>'s Result property to modify login flow.
/// </summary>
/// <param name="context">Provides access to permission information associated with the user.</param>
protected virtual void OnDeniedPermissionPrompt(PermissionContext context)
{
}
/// <summary>
/// Returns an <see cref="ActionResult"/> that indicates we want to show a permission prompt. Should only be used as a
/// return value within the <see cref="OnPermissionPrompt"/> and <see cref="OnDeniedPermissionPrompt"/> methods.
/// </summary>
/// <returns>An <see cref="ActionResult"/> that indicates that we want to show a permission prompt.</returns>
protected ShowPromptResult ShowPrompt(PermissionContext context)
{
FacebookClient client = context.FacebookContext.Client;
Uri navigationUrl = client.GetLoginUrl(context.RedirectUrl,
_config.AppId,
permissions: String.Join(",", context.RequiredPermissions));
return new ShowPromptResult(navigationUrl);
}
public override bool CanAccessResource(PermissionContext permissionContext)
{
return SelfPermissionAttribute.CanAccessResourceCore(permissionContext)
|| base.CanAccessResource(permissionContext);
}
private void BuildCreateItemButtonRendererTree(GridRendererContext rendererContext, PermissionContext permissionContext)
{
rendererContext.OpenElement(HtmlTagNames.TableHeadCell, rendererContext.CssClasses.TableHeaderCell);
rendererContext.OpenElement(HtmlTagNames.Div, "create-button-wrapper");
rendererContext.OpenElement(HtmlTagNames.Button, "action-button");
rendererContext.AddOnClickEvent(
EventCallback.Factory.Create(this, (MouseEventArgs e) =>
_flexGridInterop.ShowModal(CreateItemOptions.CreateItemModalName))
);
rendererContext.OpenElement(HtmlTagNames.Span, "action-button-span");
rendererContext.OpenElement(HtmlTagNames.I, "fas fa-plus");
rendererContext.CloseElement();
rendererContext.CloseElement();
rendererContext.CloseElement();
rendererContext.CloseElement();
rendererContext.CloseElement();
}
public PermissionRepository(PermissionContext context)
{
dbContext = context;
}
public override bool CanAccessResource(PermissionContext permissionContext)
{
var user = permissionContext.User;
return user.IsOwner;
}
public bool PrivacyRoom()
{
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
return(PrivacyRoomSettings.GetEnabled(SettingsManager));
}
protected override void OnDeniedPermissionPrompt(PermissionContext context)
{
context.Result = null;
}
public int UpdateSongList(SongListForEditContract contract, UploadedFileContract uploadedFile)
{
ParamIs.NotNull(() => contract);
PermissionContext.VerifyPermission(PermissionToken.EditProfile);
return(repository.HandleTransaction(ctx => {
var user = GetLoggedUser(ctx);
SongList list;
if (contract.Id == 0)
{
list = CreateSongList(ctx, contract, uploadedFile);
}
else
{
list = ctx.Load(contract.Id);
var diff = new SongListDiff();
EntryPermissionManager.VerifyEdit(PermissionContext, list);
if (list.Description != contract.Description)
{
diff.Description.Set();
list.Description = contract.Description ?? string.Empty;
}
if (list.Name != contract.Name)
{
diff.Name.Set();
list.Name = contract.Name;
}
if (EntryPermissionManager.CanManageFeaturedLists(PermissionContext) && list.FeaturedCategory != contract.FeaturedCategory)
{
diff.FeaturedCategory.Set();
list.FeaturedCategory = contract.FeaturedCategory;
}
if (list.EventDate != contract.EventDate)
{
diff.SetChanged(SongListEditableFields.EventDate);
list.EventDate = contract.EventDate;
}
if (list.Status != contract.Status)
{
diff.Status.Set();
list.Status = contract.Status;
}
var songDiff = list.SyncSongs(contract.SongLinks, c => ctx.OfType <Song>().Load(c.Song.Id));
if (songDiff.Changed)
{
diff.Songs.Set();
}
ctx.OfType <SongInList>().Sync(songDiff);
if (uploadedFile != null)
{
diff.Thumbnail.Set();
SetThumb(list, uploadedFile);
}
ctx.Update(list);
ctx.AuditLogger.AuditLog(
string.Format("updated song list {0} ({1})", entryLinkFactory.CreateEntryLink(list), diff.ChangedFieldsString), user);
var archived = Archive(ctx, list, diff, EntryEditEvent.Updated, contract.UpdateNotes);
if (list.FeaturedList)
{
AddEntryEditedEntry(ctx.OfType <ActivityEntry>(), list, EntryEditEvent.Updated, archived);
}
}
return list.Id;
}));
}
protected override void OnCannotCreateCookies(PermissionContext context)
{
CannotCreateCookiesHookTriggered = true;
base.OnCannotCreateCookies(context);
}
protected override void OnDeniedPermissionPrompt(PermissionContext context)
{
DeniedPermissionPromptHookTriggered = true;
base.OnDeniedPermissionPrompt(context);
}
protected override void OnCannotCreateCookies(PermissionContext context)
{
context.Result = _cannotCreateCookieResult;
}
protected override void OnDeniedPermissionPrompt(PermissionContext context)
{
DeniedPermissionPromptHookTriggered = true;
base.OnDeniedPermissionPrompt(context);
}
protected override void OnPermissionPrompt(PermissionContext context)
{
context.Result = _promptPermissionHookResult;
}
protected override void OnDeniedPermissionPrompt(PermissionContext context)
{
context.Result = _deniedPermissionPromptHookResult;
}
protected override void OnDeniedPermissionPrompt(PermissionContext context)
{
context.Result = _deniedPermissionPromptHookResult;
}
public TypeObjectSeeds(PermissionContext context) : base(context)
{
}
protected override void BuildRenderTreeInternal(GridRendererContext rendererContext, PermissionContext permissionContext)
{
try
{
gridPartRenderersBefore.ForEach(renderer => renderer.BuildRendererTree(rendererContext, permissionContext));
rendererContext.OpenElement(HtmlTagNames.Div, "table-wrapper");
rendererContext.OpenElement(HtmlTagNames.Table, rendererContext.CssClasses.Table);
gridPartRenderers.ForEach(renderer => renderer.BuildRendererTree(rendererContext, permissionContext));
rendererContext.CloseElement(); // Close table
gridPartRenderersAfter.ForEach(renderer => renderer.BuildRendererTree(rendererContext, permissionContext));
rendererContext.CloseElement(); // Close table wrapper
}
catch (Exception ex)
{
logger.LogError($"Error raised during rendering GridView component. Ex: {ex}");
}
}
public UserCreatedEventConsumer(PermissionContext permissionContext)
{
_permissionContext = permissionContext;
}
/// <summary>
/// Reverts an album to an earlier archived version.
/// </summary>
/// <param name="archivedArtistVersionId">Id of the archived version to be restored.</param>
/// <returns>Result of the revert operation, with possible warnings if any. Cannot be null.</returns>
/// <remarks>Requires the RestoreRevisions permission.</remarks>
public EntryRevertedContract RevertToVersion(int archivedArtistVersionId)
{
PermissionContext.VerifyPermission(PermissionToken.RestoreRevisions);
return(HandleTransaction(session => {
var archivedVersion = session.Load <ArchivedArtistVersion>(archivedArtistVersionId);
var artist = archivedVersion.Artist;
session.AuditLogger.SysLog("reverting " + artist + " to version " + archivedVersion.Version);
var fullProperties = ArchivedArtistContract.GetAllProperties(archivedVersion);
var warnings = new List <string>();
var diff = new ArtistDiff();
artist.ArtistType = fullProperties.ArtistType;
artist.Description.Original = fullProperties.Description;
artist.Description.English = fullProperties.DescriptionEng ?? string.Empty;
artist.TranslatedName.DefaultLanguage = fullProperties.TranslatedName.DefaultLanguage;
artist.BaseVoicebank = DatabaseContextHelper.RestoreWeakRootEntityRef(session, warnings, fullProperties.BaseVoicebank);
// Picture
var versionWithPic = archivedVersion.GetLatestVersionWithField(ArtistEditableFields.Picture);
if (versionWithPic != null)
{
artist.Picture = versionWithPic.Picture;
artist.PictureMime = versionWithPic.PictureMime;
if (versionWithPic.Picture != null)
{
var thumbGenerator = new ImageThumbGenerator(imagePersister);
using (var stream = new MemoryStream(versionWithPic.Picture.Bytes)) {
var thumb = new EntryThumb(artist, versionWithPic.PictureMime);
thumbGenerator.GenerateThumbsAndMoveImage(stream, thumb, ImageSizes.Thumb | ImageSizes.SmallThumb | ImageSizes.TinyThumb);
}
}
}
else
{
artist.Picture = null;
artist.PictureMime = null;
}
// Assume picture was changed if there's a version between the current version and the restored version where the picture was changed.
diff.Picture = !Equals(artist.ArchivedVersionsManager.GetLatestVersionWithField(ArtistEditableFields.Picture, artist.Version), versionWithPic);
// Groups
DatabaseContextHelper.RestoreObjectRefs(
session, warnings, artist.AllGroups, fullProperties.Groups, (a1, a2) => (a1.Parent.Id == a2.Id),
(grp, grpRef) => (!artist.HasGroup(grp) ? artist.AddGroup(grp, grpRef.LinkType) : null),
groupForArtist => groupForArtist.Delete());
// Names
if (fullProperties.Names != null)
{
var nameDiff = artist.Names.SyncByContent(fullProperties.Names, artist);
session.Sync(nameDiff);
}
// Weblinks
if (fullProperties.WebLinks != null)
{
var webLinkDiff = WebLink.SyncByValue(artist.WebLinks, fullProperties.WebLinks, artist);
session.Sync(webLinkDiff);
}
Archive(session, artist, diff, ArtistArchiveReason.Reverted, string.Format("Reverted to version {0}", archivedVersion.Version));
AuditLog(string.Format("reverted {0} to revision {1}", entryLinkFactory.CreateEntryLink(artist), archivedVersion.Version), session);
return new EntryRevertedContract(artist, warnings);
}));
}
protected override void BuildRendererTreeInternal(GridRendererContext rendererContext, PermissionContext permissionContext)
{
var canRenderCreateItemButton = rendererContext.CreateItemIsAllowed() && permissionContext.HasCreateItemPermission;
rendererContext.OpenElement(HtmlTagNames.TableHead, rendererContext.CssClasses.TableHeader);
rendererContext.OpenElement(HtmlTagNames.TableRow, rendererContext.CssClasses.TableHeaderRow);
if (rendererContext.GridConfiguration.IsMasterTable)
{
RenderEmptyColumnHeader(rendererContext);
}
foreach (var property in rendererContext.GridItemProperties)
{
rendererContext.ActualColumnName = property.Name;
RenderColumnHeader(rendererContext, property);
}
if (canRenderCreateItemButton)
{
BuildCreateItemButtonRendererTree(rendererContext, permissionContext);
}
if (rendererContext.InlineEditItemIsAllowed() && !canRenderCreateItemButton)
{
RenderEmptyColumnHeader(rendererContext);
}
rendererContext.CloseElement();
rendererContext.CloseElement();
}
public PermissionQueries(PermissionContext context)
{
_context = context;
}
protected override void BuildRenderTreeInternal(GridRendererContext rendererContext, PermissionContext permissionContext)
{
using (new MeasurableScope(sw => _logger.LogInformation($"Grid grouped body rendering duration {sw.ElapsedMilliseconds}ms")))
{
rendererContext.OpenElement(HtmlTagNames.TableBody, rendererContext.CssClasses.TableBody);
foreach (var group in rendererContext.TableDataSet.GroupedItems)
{
try
{
rendererContext.OpenElement(HtmlTagNames.TableRow, rendererContext.CssClasses.TableGroupRow);
rendererContext.OpenElement(HtmlTagNames.TableColumn, rendererContext.CssClasses.TableGroupRowCell);
rendererContext.AddAttribute(HtmlAttributes.Colspan, rendererContext.NumberOfColumns);
rendererContext.OpenElement(HtmlTagNames.Button, "pagination-button");
rendererContext.AddOnClickEvent(
EventCallback.Factory.Create(this, (MouseEventArgs e) =>
{
rendererContext.TableDataSet.ToggleGroupRow(group.Key);
rendererContext.RequestRerenderNotification?.Invoke();
})
);
rendererContext.OpenElement(HtmlTagNames.Span, "pagination-button-arrow");
rendererContext.OpenElement(HtmlTagNames.I, !group.IsCollapsed ? "fas fa-angle-down" : "fas fa-angle-right");
rendererContext.CloseElement();
rendererContext.CloseElement();
rendererContext.CloseElement();
rendererContext.AddMarkupContent($"\t<b>{rendererContext.TableDataSet.GroupingOptions.GroupedProperty.Name}:</b> {group.Key.ToString()}\t");
rendererContext.OpenElement(HtmlTagNames.I);
rendererContext.AddContent($"({group.Count})");
rendererContext.CloseElement();
if (!group.IsCollapsed)
{
var dataAdapter = _tableDataAdapterProvider.CreateCollectionTableDataAdapter(rendererContext.TableDataSet.UnderlyingTypeOfItem(), group);
var masterTableFeature = rendererContext.FlexGridContext.Features.Get <IMasterTableFeature>();
dataAdapter = _tableDataAdapterProvider.CreateMasterTableDataAdapter(dataAdapter, masterTableFeature);
rendererContext.AddGridViewComponent(dataAdapter);
}
rendererContext.CloseElement();
rendererContext.CloseElement();
}
catch (Exception ex)
{
_logger.LogError($"Error occured during rendering grouped grid view body. Ex: {ex}");
throw ex;
}
}
rendererContext.CloseElement();
}
}
/// <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 async Task <ReleaseEventContract> Update(ReleaseEventForEditContract contract, EntryPictureFileContract pictureData)
{
ParamIs.NotNull(() => contract);
PermissionContext.VerifyManageDatabase();
return(await repository.HandleTransactionAsync(async session => {
ReleaseEvent ev;
if (contract.Id == 0)
{
var diff = new ReleaseEventDiff();
if (!contract.Series.IsNullOrDefault())
{
var series = await session.LoadAsync <ReleaseEventSeries>(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 = await session.NullSafeLoadAsync <SongList>(contract.SongList);
ev.Status = contract.Status;
ev.SetVenue(await session.NullSafeLoadAsync <Venue>(contract.Venue));
ev.VenueName = contract.VenueName;
if (contract.SongList != null)
{
diff.SongList.Set();
}
if (contract.Venue != null)
{
diff.Venue.Set();
}
if (!string.IsNullOrEmpty(contract.VenueName))
{
diff.VenueName.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);
await session.OfType <PVForAlbum>().SyncAsync(pvDiff);
if (pvDiff.Changed)
{
diff.PVs.Set();
}
var artistDiff = await ev.SyncArtists(contract.Artists, artistId => session.LoadAsync <Artist>(artistId));
if (artistDiff.Changed)
{
diff.Artists.Set();
}
await session.SaveAsync(ev);
var namesChanged = new UpdateEventNamesQuery().UpdateNames(session, ev, contract.Series, contract.CustomName, contract.SeriesNumber, contract.SeriesSuffix, contract.Names);
if (namesChanged)
{
await session.UpdateAsync(ev);
}
if (pictureData != null)
{
diff.MainPicture.Set();
SaveImage(ev, pictureData);
await session.UpdateAsync(ev);
}
var archived = Archive(session, ev, diff, EntryEditEvent.Created, string.Empty);
await AddEntryEditedEntryAsync(session.OfType <ActivityEntry>(), archived);
await session.AuditLogger.AuditLogAsync(string.Format("created {0}", entryLinkFactory.CreateEntryLink(ev)));
await followedArtistNotifier.SendNotificationsAsync(session, ev, ev.Artists.Where(a => a?.Artist != null).Select(a => a.Artist), PermissionContext.LoggedUser);
}
else
{
ev = await session.LoadAsync(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 (!ev.Venue.NullSafeIdEquals(contract.Venue))
{
diff.Venue.Set();
}
if (!string.Equals(ev.VenueName, contract.VenueName))
{
diff.VenueName.Set();
}
ev.SetSeries(await session.NullSafeLoadAsync <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 = await session.NullSafeLoadAsync <SongList>(contract.SongList);
ev.Status = contract.Status;
ev.TranslatedName.DefaultLanguage = inheritedLanguage;
ev.SetVenue(await session.NullSafeLoadAsync <Venue>(contract.Venue));
ev.VenueName = contract.VenueName;
var weblinksDiff = WebLink.Sync(ev.WebLinks, contract.WebLinks, ev);
if (weblinksDiff.Changed)
{
diff.WebLinks.Set();
await session.OfType <ReleaseEventWebLink>().SyncAsync(weblinksDiff);
}
var pvDiff = ev.PVs.Sync(contract.PVs, ev.CreatePV);
await session.OfType <PVForAlbum>().SyncAsync(pvDiff);
if (pvDiff.Changed)
{
diff.PVs.Set();
}
var artistDiff = await ev.SyncArtists(contract.Artists, artistId => session.LoadAsync <Artist>(artistId));
if (artistDiff.Changed)
{
diff.Artists.Set();
}
if (pictureData != null)
{
diff.MainPicture.Set();
SaveImage(ev, pictureData);
}
await session.UpdateAsync(ev);
var archived = Archive(session, ev, diff, EntryEditEvent.Updated, string.Empty);
await AddEntryEditedEntryAsync(session.OfType <ActivityEntry>(), archived);
var logStr = string.Format("updated properties for {0} ({1})", entryLinkFactory.CreateEntryLink(ev), diff.ChangedFieldsString);
await session.AuditLogger.AuditLogAsync(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())
{
await followedArtistNotifier.SendNotificationsAsync(session, ev, addedArtists, PermissionContext.LoggedUser);
}
}
}
return new ReleaseEventContract(ev, LanguagePreference);
}));
}
protected override void BuildRendererTreeInternal(GridRendererContext rendererContext, PermissionContext permissionContext)
{
var localActualItem = rendererContext.ActualItem;
var localActualItemIsSelected = rendererContext.TableDataSet.ItemIsSelected(localActualItem);
rendererContext.OpenElement(HtmlTagNames.TableColumn, rendererContext.CssClasses.TableCell);
rendererContext.AddOnClickEvent(() =>
BindMethods.GetEventHandlerValue((UIMouseEventArgs e) =>
rendererContext.TableDataSet.ToggleRowItem(localActualItem))
);
rendererContext.AddContent(string.Empty);
rendererContext.OpenElement(HtmlTagNames.Span, "pagination-button-arrow");
rendererContext.OpenElement(HtmlTagNames.I, localActualItemIsSelected ? "fas fa-angle-down" : "fas fa-angle-right");
rendererContext.CloseElement();
rendererContext.CloseElement();
rendererContext.CloseElement();
}
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(DoSnapshot(series, session));
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.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);
ev.TranslatedName.DefaultLanguage = contract.DefaultNameLanguage;
session.Update(ev);
}
}
Archive(session, series, diff, EntryEditEvent.Updated, string.Empty);
AuditLog(string.Format("updated {0}", entryLinkFactory.CreateEntryLink(series)), session);
}
return series.Id;
}));
}
public int Update(VenueForEditContract contract)
{
ParamIs.NotNull(() => contract);
PermissionContext.VerifyManageDatabase();
return(HandleTransaction(ctx =>
{
Venue venue;
if (contract.Id == 0)
{
venue = new Venue(contract.DefaultNameLanguage, contract.Names, contract.Description)
{
Address = contract.Address,
AddressCountryCode = contract.AddressCountryCode,
Coordinates = (contract.Coordinates != null) ? new OptionalGeoPoint(contract.Coordinates) : new OptionalGeoPoint(),
Status = contract.Status
};
ctx.Save(venue);
var diff = new VenueDiff(VenueEditableFields.OriginalName | VenueEditableFields.Names);
diff.Address.Set(!string.IsNullOrEmpty(contract.Address));
diff.AddressCountryCode.Set(!string.IsNullOrEmpty(contract.AddressCountryCode));
diff.Description.Set(!string.IsNullOrEmpty(contract.Description));
if (contract.Coordinates != null)
{
diff.Coordinates.Set();
}
var webLinkDiff = venue.WebLinks.Sync(contract.WebLinks, venue);
ctx.OfType <VenueWebLink>().Sync(webLinkDiff);
if (webLinkDiff.Changed)
{
diff.WebLinks.Set();
}
ctx.Update(venue);
var archived = Archive(ctx, venue, diff, EntryEditEvent.Created, string.Empty);
AddEntryEditedEntry(ctx.OfType <ActivityEntry>(), venue, EntryEditEvent.Created, archived);
AuditLog($"created {_entryLinkFactory.CreateEntryLink(venue)}", ctx);
}
else
{
venue = ctx.Load <Venue>(contract.Id);
_permissionContext.VerifyEntryEdit(venue);
var diff = new VenueDiff(DoSnapshot(venue, ctx));
if (venue.TranslatedName.DefaultLanguage != contract.DefaultNameLanguage)
{
venue.TranslatedName.DefaultLanguage = contract.DefaultNameLanguage;
diff.OriginalName.Set();
}
var nameDiff = venue.Names.Sync(contract.Names, venue);
ctx.Sync(nameDiff);
if (nameDiff.Changed)
{
diff.Names.Set();
}
if (venue.Address != contract.Address)
{
diff.Address.Set();
venue.Address = contract.Address;
}
if (venue.AddressCountryCode != contract.AddressCountryCode)
{
diff.AddressCountryCode.Set();
venue.AddressCountryCode = contract.AddressCountryCode;
}
if (venue.Description != contract.Description)
{
diff.Description.Set();
venue.Description = contract.Description;
}
if (!venue.Coordinates.Equals(contract.Coordinates))
{
diff.Coordinates.Set();
venue.Coordinates = (contract.Coordinates != null) ? new OptionalGeoPoint(contract.Coordinates) : new OptionalGeoPoint();
}
if (venue.Status != contract.Status)
{
diff.Status.Set();
venue.Status = contract.Status;
}
var webLinkDiff = venue.WebLinks.Sync(contract.WebLinks, venue);
ctx.OfType <VenueWebLink>().Sync(webLinkDiff);
if (webLinkDiff.Changed)
{
diff.WebLinks.Set();
}
ctx.Update(venue);
var archived = Archive(ctx, venue, diff, EntryEditEvent.Updated, string.Empty);
AddEntryEditedEntry(ctx.OfType <ActivityEntry>(), venue, EntryEditEvent.Updated, archived);
AuditLog($"updated {_entryLinkFactory.CreateEntryLink(venue)}", ctx);
}
return venue.Id;
}));
}
protected override void BuildRendererTreeInternal(GridRendererContext rendererContext, PermissionContext permissionContext)
{
var localActualItem = rendererContext.ActualItem;
var localActualItemIsSelected = rendererContext.TableDataSet.ItemIsSelected(localActualItem);
rendererContext.OpenElement(HtmlTagNames.TableColumn, rendererContext.CssClasses.TableCell);
rendererContext.AddOnClickEvent(
EventCallback.Factory.Create(this, (MouseEventArgs e) =>
{
rendererContext.TableDataSet.ToggleRowItem(localActualItem);
rendererContext.RequestRerenderNotification?.Invoke();
})
);
rendererContext.AddContent(string.Empty);
rendererContext.OpenElement(HtmlTagNames.Span, "pagination-button-arrow");
rendererContext.OpenElement(HtmlTagNames.I, localActualItemIsSelected ? "fas fa-angle-down" : "fas fa-angle-right");
rendererContext.CloseElement();
rendererContext.CloseElement();
rendererContext.CloseElement();
}
public void Merge(int sourceId, int targetId)
{
PermissionContext.VerifyPermission(PermissionToken.MergeEntries);
if (sourceId == targetId)
{
throw new ArgumentException("Source and target songs can't be the same", "targetId");
}
repository.HandleTransaction(ctx => {
var source = ctx.Load(sourceId);
var target = ctx.Load(targetId);
ctx.AuditLogger.AuditLog(string.Format("Merging {0} to {1}",
entryLinkFactory.CreateEntryLink(source), entryLinkFactory.CreateEntryLink(target)));
// Names
foreach (var n in source.Names.Names.Where(n => !target.HasName(n)))
{
var name = target.CreateName(n.Value, n.Language);
ctx.Save(name);
}
// Weblinks
foreach (var w in source.WebLinks.Where(w => !target.HasWebLink(w.Url)))
{
var link = target.CreateWebLink(w.Description, w.Url, w.Category);
ctx.Save(link);
}
// PVs
var pvs = source.PVs.Where(a => !target.HasPV(a.Service, a.PVId));
foreach (var p in pvs)
{
var pv = target.CreatePV(new PVContract(p));
ctx.Save(pv);
}
// Artist links
var artists = source.Artists.Where(a => !target.HasArtistLink(a)).ToArray();
foreach (var a in artists)
{
a.Move(target);
ctx.Update(a);
}
// Album links
var albums = source.Albums.Where(s => !target.IsOnAlbum(s.Album)).ToArray();
foreach (var s in albums)
{
s.Move(target);
ctx.Update(s);
}
// Favorites
var userFavorites = source.UserFavorites.Where(a => !target.IsFavoritedBy(a.User)).ToArray();
foreach (var u in userFavorites)
{
u.Move(target);
ctx.Update(u);
}
// Custom lists
var songLists = source.ListLinks.ToArray();
foreach (var s in songLists)
{
s.ChangeSong(target);
ctx.Update(s);
}
// Other properties
if (target.OriginalVersion == null)
{
target.OriginalVersion = source.OriginalVersion;
}
var alternateVersions = source.AlternateVersions.ToArray();
foreach (var alternate in alternateVersions)
{
alternate.OriginalVersion = target;
ctx.Update(alternate);
}
if (target.LengthSeconds == 0)
{
target.LengthSeconds = source.LengthSeconds;
}
target.Notes.CopyIfEmpty(source.Notes);
if (target.PublishDate.IsEmpty)
{
target.PublishDate = source.PublishDate;
}
// Create merge record
var mergeEntry = new SongMergeRecord(source, target);
ctx.Save(mergeEntry);
source.Deleted = true;
target.UpdateArtistString();
target.UpdateNicoId();
Archive(ctx, source, SongArchiveReason.Deleted, string.Format("Merged to {0}", target));
Archive(ctx, target, SongArchiveReason.Merged, string.Format("Merged from {0}", source));
ctx.Update(source);
ctx.Update(target);
});
}
protected override void BuildRenderTreeInternal(GridRendererContext rendererContext, PermissionContext permissionContext)
{
var actualGroupItem = (GroupItem)rendererContext.ActualItem;
bool isCollapsed = actualGroupItem.IsCollapsed;
rendererContext.OpenElement(HtmlTagNames.TableBody, isCollapsed? "table-group-row-wrapper-collapsed" : "table-group-row-wrapper");
try
{
rendererContext.OpenElement(HtmlTagNames.TableRow, rendererContext.CssClasses.TableGroupRow);
rendererContext.OpenElement(HtmlTagNames.TableColumn, rendererContext.CssClasses.TableGroupRowCell);
int numberOfColumns = rendererContext.GridItemProperties.Count;
if (rendererContext.GridConfiguration.InlineEditOptions.InlineEditIsAllowed)
{
numberOfColumns++;
}
if (rendererContext.GridConfiguration.IsMasterTable)
{
numberOfColumns++;
}
rendererContext.AddAttribute(HtmlAttributes.Colspan, numberOfColumns);
rendererContext.AddOnClickEvent(() =>
BindMethods.GetEventHandlerValue((UIMouseEventArgs e) =>
{
rendererContext.TableDataSet.ToggleGroupRow(actualGroupItem.Key);
rendererContext.RequestRerenderNotification?.Invoke();
})
);
rendererContext.OpenElement(HtmlTagNames.I, !isCollapsed ? "fas fa-angle-down" : "fas fa-angle-right");
rendererContext.CloseElement();
var keyProperty = rendererContext.ActualItem.GetType().GetProperty("Key");
var keyValue = keyProperty != null?keyProperty.GetValue(rendererContext.ActualItem) : null;
var key = keyValue != null?keyValue.ToString() : "(null)";
if (string.IsNullOrEmpty(key))
{
key = @"""";
}
rendererContext.AddContent($" {key} ");
rendererContext.OpenElement(HtmlTagNames.I);
rendererContext.AddContent($"({actualGroupItem.Count})");
rendererContext.CloseElement();
rendererContext.CloseElement();
rendererContext.CloseElement();
var subItems = (IEnumerable)(GroupItem)rendererContext.ActualItem;
foreach (var item in subItems)
{
rendererContext.ActualItem = item;
gridPartRenderers.ForEach(renderer => renderer.BuildRendererTree(rendererContext, permissionContext));
}
}
catch (Exception ex)
{
throw ex;
}
rendererContext.CloseElement();
}
protected override void BuildRendererTreeInternal(GridRendererContext rendererContext, PermissionContext permissionContext)
{
rendererContext.OpenElement(HtmlTagNames.TableColumn, rendererContext.CssClasses.TableCell);
rendererContext.OpenElement(HtmlTagNames.Div, "action-buttons-wrapper");
rendererContext.OpenElement(HtmlTagNames.Div, "action-buttons-wrapper-inner");
if (rendererContext.IsActualItemEdited)
{
RenderSaveButton(rendererContext);
RenderDiscardButton(rendererContext);
}
else
{
RenderEditButton(rendererContext);
RenderDeleteButton(rendererContext, permissionContext);
}
rendererContext.CloseElement();
rendererContext.CloseElement();
rendererContext.CloseElement();
}
protected override void BuildRendererTreeInternal(GridRendererContext rendererContext, PermissionContext permissionContext)
{
if (rendererContext.TableDataSet is IMasterTableDataSet masterTableDataSet)
{
var selectedDataAdapter = masterTableDataSet.GetSelectedDataAdapter(rendererContext.ActualItem);
rendererContext.OpenElement(HtmlTagNames.TableRow, rendererContext.CssClasses.TableRow);
rendererContext.OpenElement(HtmlTagNames.TableColumn, rendererContext.CssClasses.TableCell);
rendererContext.AddColspan();
rendererContext.OpenElement(HtmlTagNames.Div, "tabs-header");
rendererContext.OpenElement(HtmlTagNames.Div, "tabs-header-buttons");
RenderTabs(rendererContext, permissionContext, masterTableDataSet, selectedDataAdapter);
rendererContext.CloseElement();
rendererContext.CloseElement();
rendererContext.OpenElement(HtmlTagNames.Div, "tabs-content");
rendererContext.AddDetailGridViewComponent(selectedDataAdapter);
rendererContext.CloseElement();
rendererContext.CloseElement();
rendererContext.CloseElement();
}
}
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;
}));
}
protected override void OnDeniedPermissionPrompt(PermissionContext context)
{
context.Result = null;
}
public override bool CanAccessResource(PermissionContext permissionContext)
{
return CanAccessResourceCore(permissionContext);
}
/// <summary>
/// Invoked during <see cref="OnAuthorization"/> after determining that cookies cannot be created. Default behavior
/// redirects to a no cookies error page.
/// </summary>
/// <param name="context">Provides access to permission information associated with the user.</param>
protected virtual void OnCannotCreateCookies(PermissionContext context)
{
Uri redirectPath;
if (String.IsNullOrEmpty(_config.CannotCreateCookieRedirectPath))
{
redirectPath = DefaultCannotCreateCookiesRedirectPath;
}
else
{
redirectPath = GetCannotCreateCookiesUri();
}
context.Result = CreateRedirectResult(redirectPath);
}
