protected override void OnNodeDeletingPhysically(object sender, CancellableNodeEventArgs e)
{
base.OnNodeDeletingPhysically(sender, e);
// Memorize user, orgunit and group ids that should be removed from the security
// component after the delete operation succeeded.
e.CustomData = GetSecurityIdentityIds(e.SourceNode);
}
protected override void OnCreating(object sender, CancellableNodeEventArgs e)
{
if (e.SourceNode.Index == 0)
{
e.CancelMessage = "Index cannot be 0";
e.Cancel = true;
}
base.OnCreating(sender, e);
}
protected override void OnModifying(object sender, CancellableNodeEventArgs e)
{
// check type in case of the name has changed
if (e.ChangedData.Any(cd => string.Compare(cd.Name, "Name", StringComparison.InvariantCultureIgnoreCase) == 0))
{
AssertExecutableType(e.SourceNode);
}
base.OnModifying(sender, e);
}
// ================================================================================= Observer methods
protected override void OnNodeCreating(object sender, CancellableNodeEventArgs e)
{
base.OnNodeCreating(sender, e);
if (e.SourceNode.CopyInProgress)
{
return;
}
DocumentPreviewProvider.InitializePreviewGeneration(e.SourceNode);
}
protected override void OnModifying(object sender, CancellableNodeEventArgs e)
{
base.OnModifying(sender, e);
// has the Members field changed?
var changedMembers = e.ChangedData.FirstOrDefault(cd => cd.Name == nameof(Members));
if (changedMembers == null)
{
return;
}
// is this group protected?
if (!ContentProtector.GetProtectedGroupIds().Contains(e.SourceNode.Id))
{
return;
}
// Protected groups must contain at least one direct member user
// who is enabled. Transitivity does not count, the user must be
// a direct member.
// If there were no members in the group, we can't remove anybody. This
// is probably an initial import scenario.
var oldMembersText = (string)changedMembers.Original;
if (string.IsNullOrEmpty(oldMembersText))
{
return;
}
// there has to be at least one member in the group
var newMembersText = (string)changedMembers.Value;
var newMemberIds = string.IsNullOrEmpty(newMembersText)
? Array.Empty <int>()
: newMembersText.Split(',').Select(int.Parse).ToArray();
if (!newMemberIds.Any())
{
throw new InvalidOperationException($"{Name} is a protected group. " +
"It has to contain at least one member.");
}
using (new SystemAccount())
{
// at least one Enabled member has to remain in the group
if (!LoadNodes(newMemberIds).Any(User.IsEnabledRegularUser))
{
throw new InvalidOperationException($"{Name} is a protected group. " +
"It has to contain at least one enabled member.");
}
}
}
protected override void OnNodeDeletingPhysically(object sender, CancellableNodeEventArgs e)
{
base.OnNodeDeletingPhysically(sender, e);
// Collect sharing group ids for publicly shared content
// in the subtree to delete them later in the background.
var sharingGroupIds = SharingHandler.GetSharingGroupIdsForSubtree(e.SourceNode);
if (sharingGroupIds?.Any() ?? false)
{
e.SetCustomData(SharingGroupIdsCustomDataKey, sharingGroupIds);
}
}
protected internal override void OnNodeModifying(object sender, CancellableNodeEventArgs e)
{
var node = e.SourceNode;
var path = $"{node.ParentPath}/{node.Name}";
if (path != DatabaseUsageHandler.DatabaseUsageCachePath)
{
return;
}
if (!ModifyingCrashEnabledOnce)
{
return;
}
ModifyingCrashEnabledOnce = false;
e.Cancel = true;
}
protected override void OnDeletingPhysically(object sender, CancellableNodeEventArgs e)
{
base.OnDeletingPhysically(sender, e);
if (!Path.StartsWith(RepositoryStructure.ImsFolderPath + RepositoryPath.PathSeparator))
{
return;
}
// If we are deleting a container under the security folder, we have to check whether
// we would delete users from protected groups. If any of the protected groups would
// become empty, this will throw an exception.
using (new SystemAccount())
{
var userInSubtree = ContentQuery.Query(SafeQueries.UsersInSubtree,
QuerySettings.AdminSettings, Path).Identifiers.ToArray();
User.AssertEnabledParentGroupMembers(userInSubtree);
}
}
protected override void OnNodeModifying(object sender, CancellableNodeEventArgs e)
{
_log.Append("TestObserver.OnNodeModifying").Append(Environment.NewLine);
}
protected override void OnNodeModifying(object sender, CancellableNodeEventArgs e)
{
RouteCancelEvent(RepositoryEvent.Modifying, sender, e.SourceNode, e);
}
private void RouteCancelEvent(RepositoryCancelEvent @event, object sender, Node contextNode, CancellableNodeEventArgs originalArgs)
{
var args = new RepositoryCancelEventArgs(contextNode);
@event.FireEvent(sender, args);
originalArgs.Cancel = args.Cancel;
originalArgs.CancelMessage = args.CancelMessage;
}
protected override void OnNodeCreating(object sender, CancellableNodeEventArgs e)
{
_log.Append("TestObserver.OnNodeCreating").AppendLine();
}
protected override void OnNodeDeletingPhysically(object sender, CancellableNodeEventArgs e)
{
RouteCancelEvent(RepositoryEvent.DeletingPhysically, sender, e.SourceNode, e);
}
protected override void OnCreating(object sender, CancellableNodeEventArgs e)
{
base.OnCreating(sender, e);
this.ReferencedWikiTitles = WikiTools.GetReferencedTitles(this);
}
protected internal override void OnNodeDeleting(object sender, CancellableNodeEventArgs e)
{
RouteCancelEvent(RepositoryEvent.Deleting, sender, e.SourceNode, e);
}
protected override void OnPermissionChanging(object sender, CancellableNodeEventArgs e)
{
_log.AppendLine("TestObserver.OnPermissionChanging");
}
void Node_Modifying(object sender, CancellableNodeEventArgs e)
{
LogEvent("Node_Modifying");
}
void Node_OverriddenCreating(object sender, CancellableNodeEventArgs e)
{
LogEvent("Node_OverriddenCreating");
}