protected override void OnNodeDeleted(object sender, NodeEventArgs e)
{
if (!Configuration.Enabled)
return;
OnNodeDeletedPhysically(sender, e);
}
protected override void OnModified(object sender, NodeEventArgs e)
{
base.OnModified(sender, e);
var oldName = RepositoryPath.GetFileName(e.OriginalSourcePath);
if (oldName.CompareTo(e.SourceNode.Name) != 0 || this.DisplayName.CompareTo(_oldDisplayName) != 0)
WikiTools.RefreshArticlesAsync(this, oldName, _oldDisplayName);
}
private void Log(NodeEventArgs e, string sourcePath, Node target)
{
if (!CreateJournalItems)
return;
var path = "[null]";
if (e.SourceNode == null)
return;
if (e.SourceNode.NodeOperation == NodeOperation.TemplateChildCopy || e.SourceNode.NodeOperation == NodeOperation.HiddenJournal)
return;
try
{
path = e.SourceNode.Path;
}
catch(Exception ee) //logged
{
Logger.WriteException(ee);
path = "[error]";
}
var userName = "******";
try
{
if (e.User != null)
userName = e.User.Name;
}
catch(Exception eee) //logged
{
Logger.WriteException(eee);
userName = "******";
}
string info = null;
if (e.ChangedData != null)
{
var sb = new StringBuilder();
foreach (var changedData in e.ChangedData)
{
if (changedData.Name == "NodeModificationDate" ||
changedData.Name == "NodeModifiedById" ||
changedData.Name == "NodeModifiedBy" ||
changedData.Name == "ModificationDate" ||
changedData.Name == "ModifiedById" ||
changedData.Name == "ModifiedBy")
continue;
sb.Append(changedData.Name + ", ");
}
info = "Changed Fields: " + sb.ToString().TrimEnd(',',' ');
}
var displayName = string.IsNullOrEmpty(e.SourceNode.DisplayName) ? e.SourceNode.Name : e.SourceNode.DisplayName;
var targetPath = target == null ? null : target.Path;
var targetDisplayName = target == null ? null : string.IsNullOrEmpty(target.DisplayName) ? target.Name : target.DisplayName;
Journals.Add(e.EventType.ToString(), path, userName, e.Time, e.SourceNode.Id, displayName, e.SourceNode.NodeType.Name, sourcePath, targetPath, targetDisplayName, info, false);
}
private static void InvalidateCache(object sender, NodeEventArgs e)
{
if (e.SourceNode is SenseNet.ContentRepository.File)
{
InvalidateCacheForPath(e.OriginalSourcePath);
if (e.OriginalSourcePath != e.SourceNode.Path)
InvalidateCacheForPath(e.SourceNode.Path);
}
}
protected override void OnNodeCreated(object sender, NodeEventArgs e)
{
if (!Configuration.Enabled)
return;
var node = e.SourceNode;
var who = GetLastModifierUserName(node);
var type = node.CopyInProgress ? NotificationType.CopiedFrom : NotificationType.Created;
Event.CreateAndSave(node, type, who);
}
protected override void OnNodeModified(object sender, NodeEventArgs e)
{
var invalidated = false;
if (e.OriginalSourcePath.CompareTo(e.SourceNode.Path) != 0)
invalidated = OnInvalidate(sender, e.OriginalSourcePath);
if (!invalidated)
OnInvalidate(sender, e.SourceNode);
}
protected override void OnNodeDeletedPhysically(object sender, NodeEventArgs e)
{
if (!Configuration.Enabled)
return;
var currentUser = User.Current;
var who = GetUserName(currentUser);
var node = e.SourceNode;
Event.CreateAndSave(node, NotificationType.Deleted, who);
}
protected override void OnCreated(object sender, Storage.Events.NodeEventArgs e)
{
base.OnCreated(sender, e);
if (_successfulFormCreation)
{
string page = HttpContext.Current.Request.Url.GetLeftPart(UriPartial.Authority);
var backUrl = HttpContext.Current.Request.Params["back"];
var link = string.Concat(page, RegistrationForm.Path, "?action=ManageFields", "&back=", backUrl);
HttpContext.Current.Response.Redirect(link);
}
}
protected override void OnLoaded(object sender, NodeEventArgs e)
{
base.OnLoaded(sender, e);
var kpiData = (IDictionary<string, object>)base.GetCachedData(CACHEDKPIDATAKEY);
if (kpiData != null)
{
SetExtendedData(kpiData);
return;
}
kpiData = GetExtendedData();
base.SetCachedData(CACHEDKPIDATAKEY, kpiData);
}
protected override void OnModified(object sender, Storage.Events.NodeEventArgs e)
{
base.OnModified(sender, e);
var image = sender as Image;
if (image == null)
{
return;
}
// refresh image width/height than save the content again
if (MustRefreshDimensions(image, e.CustomData))
{
image.Save(SavingMode.KeepVersion);
}
}
protected override void OnNodeModified(object sender, NodeEventArgs e)
{
if (!Configuration.Enabled)
return;
var node = e.SourceNode;
var who = GetLastModifierUserName(node);
var type = node.Version.Status == VersionStatus.Approved ? NotificationType.MajorVersionModified : NotificationType.MinorVersionModified;
if (node.Path == e.OriginalSourcePath)
{
Event.CreateAndSave(node, type, who);
return;
}
var currentUser = User.Current;
var creatorId = node.CreatedById;
var lastModifierId = currentUser.Id;
Event.CreateAndSave(e.OriginalSourcePath, creatorId, lastModifierId, NotificationType.RenamedTo, who);
Event.CreateAndSave(node.Path, creatorId, lastModifierId, NotificationType.RenamedFrom, who);
}
/// <summary>
/// Finalizes the object creation.
/// Do not use this method directly in your code.
/// </summary>
protected override void OnCreated(object sender, SenseNet.ContentRepository.Storage.Events.NodeEventArgs e)
{
var image = sender as Image;
if (image == null)
{
return;
}
// thumbnail has been loaded -> reference it in parent's imagefield (if such exists)
if (image.Name.ToLower().StartsWith("thumbnail"))
{
var parent = image.Parent;
var content = Content.Create(parent);
// first available imagefield is used
var imageField = content.Fields.Where(d => d.Value is ImageField).Select(d => d.Value as ImageField).FirstOrDefault();
if (imageField != null)
{
// initialize field (field inner data is not yet initialized from node properties!)
imageField.GetData();
// set reference
var result = imageField.SetThumbnailReference(image);
if (result)
{
content.Save();
}
}
}
base.OnCreated(sender, e);
// refresh image width/height than save the content again
if (MustRefreshDimensions(image, e))
{
image.Save(SavingMode.KeepVersion);
}
}
protected override void OnNodeModified(object sender, NodeEventArgs e)
{
base.OnNodeModified(sender, e);
// renamed?
if (!string.Equals(e.OriginalSourcePath, e.SourceNode.Path, StringComparison.InvariantCulture))
{
if (e.OriginalSourcePath.StartsWith(SkinObserver.SkinStartPath))
SkinManager.Instance.RemoveFromMap(e.OriginalSourcePath);
if (e.SourceNode.Path.StartsWith(SkinObserver.SkinStartPath))
SkinManager.Instance.AddToMap(e.SourceNode.Path);
}
}
protected override void OnLoaded(object sender, Storage.Events.NodeEventArgs e)
{
base.OnLoaded(sender, e);
StoreContentListDefinition();
}
protected override void OnNodeDeletedPhysically(object sender, NodeEventArgs e)
{
RouteEvent(RepositoryEvent.DeletedPhysically, sender, e.SourceNode);
}
protected override void OnNodeModified(object sender, NodeEventArgs e)
{
//renamed?
if (!string.Equals(e.OriginalSourcePath, e.SourceNode.Path, StringComparison.InvariantCulture))
SNScriptDependencyCache.Instance.RemovePath(e.OriginalSourcePath);
else
SNScriptDependencyCache.Instance.UpdateDeps(e.SourceNode.Path);
}
protected virtual void OnPermissionChanged(object sender, NodeEventArgs e)
{
}
protected virtual void OnNodeModified(object sender, NodeEventArgs e)
{
}
internal static void FireOnPermissionChanged(EventHandler <NodeEventArgs> Created, Node sender, NodeEventArgs e, List <Type> disabledObservers)
{
InvokeEventHandlers <NodeEventArgs>(Created, sender, e);
var observers = NodeTypeManager.Current.NodeObservers;
if (observers == null)
{
return;
}
if (disabledObservers == null)
{
foreach (NodeObserver observer in observers)
{
observer.OnPermissionChanged(sender, e);
}
}
else
{
foreach (NodeObserver observer in observers)
{
if (!disabledObservers.Contains(observer.GetType()))
{
observer.OnPermissionChanged(sender, e);
}
}
}
}
protected override void OnDeletedPhysically(object sender, NodeEventArgs e)
{
base.OnDeletedPhysically(sender, e);
WikiTools.RefreshArticlesAsync(this, WikiArticleAction.Delete);
}
protected override void OnCreated(object sender, NodeEventArgs e)
{
base.OnCreated(sender, e);
WikiTools.RefreshArticlesAsync(this, WikiArticleAction.Create);
}
protected override void OnNodeCreated(object sender, NodeEventArgs e)
{
base.OnNodeCreated(sender, e);
if (e.SourceNode.Path.StartsWith(SkinObserver.SkinStartPath))
SkinManager.Instance.AddToMap(e.SourceNode.Path);
}
protected override void OnLoaded(object sender, NodeEventArgs e)
{
base.OnLoaded(sender, e);
_oldDisplayName = this.DisplayName;
}
internal static void FireOnNodeDeleted(EventHandler <NodeEventArgs> Deleted, Node sender, NodeEventArgs e, List <Type> disabledObservers)
{
InvokeEventHandlers <NodeEventArgs>(Deleted, sender, e);
var observers = Providers.Instance.NodeObservers;
if (observers == null)
{
return;
}
if (disabledObservers == null)
{
foreach (NodeObserver observer in observers)
{
observer.OnNodeDeleted(sender, e);
}
}
else
{
foreach (NodeObserver observer in observers)
{
if (!disabledObservers.Contains(observer.GetType()))
{
observer.OnNodeDeleted(sender, e);
}
}
}
}
protected override void OnNodeDeleted(object sender, NodeEventArgs e)
{
SNScriptDependencyCache.Instance.RemovePath(e.SourceNode.Path);
}
protected override void OnNodeModified(object sender, NodeEventArgs e)
{
InstanceManager.NotifyContentChanged(new WorkflowNotificationEventArgs(e.SourceNode.Id, CONTENTCHANGEDNOTIFICATIONTYPE, null));
AbortRelatedWorkflows(e.SourceNode, WorkflowApplicationAbortReason.RelatedContentChanged);
}
internal static void FireOnNodeDeletedPhysically(EventHandler <NodeEventArgs> DeletedPhysically, Node sender, NodeEventArgs e, List <Type> disabledObservers)
{
InvokeEventHandlers <NodeEventArgs>(DeletedPhysically, sender, e);
var observers = NodeTypeManager.Current.NodeObservers;
if (observers == null)
{
return;
}
if (disabledObservers == null)
{
foreach (NodeObserver observer in observers)
{
observer.OnNodeDeletedPhysically(sender, e);
}
}
else
{
foreach (NodeObserver observer in observers)
{
if (!disabledObservers.Contains(observer.GetType()))
{
observer.OnNodeDeletedPhysically(sender, e);
}
}
}
}
private void Log(NodeEventArgs e)
{
Log(e, null, null);
}
protected virtual void OnNodeCreated(object sender, NodeEventArgs e)
{
}
protected override void OnNodeDeleted(object sender, NodeEventArgs e)
{
OnInvalidate(sender, e.SourceNode);
}
protected virtual void OnNodeDeletedPhysically(object sender, NodeEventArgs e)
{
}
void Node_Modified(object sender, NodeEventArgs e)
{
LogEvent("Node_Modified");
}
protected override void OnNodeDeletedPhysically(object sender, NodeEventArgs e)
{
Log(e);
}
protected override void OnNodeModified(object sender, NodeEventArgs e)
{
RouteEvent(RepositoryEvent.Modified, sender, e.SourceNode);
}
protected override void OnNodeModified(object sender, NodeEventArgs e)
{
Log(e);
}
protected override void OnNodeDeletedPhysically(object sender, NodeEventArgs e)
{
OnInvalidate(sender, e.SourceNode.Path);
}
void Node_Created(object sender, NodeEventArgs e)
{
LogEvent("Node_Created");
}
protected override void OnCreated(object sender, Storage.Events.NodeEventArgs e)
{
base.OnCreated(sender, e);
RefreshExpenseClaim();
}
protected override void OnNodeModified(object sender, NodeEventArgs e)
{
_log.Append("TestObserver.OnNodeModified").Append(Environment.NewLine);
}
public static void FireOnNodeRestored(EventHandler <NodeEventArgs> Restored, Node sender, NodeEventArgs e, List <Type> disabledObservers)
{
InvokeEventHandlers <NodeEventArgs>(Restored, sender, e);
FireNodeEvent(disabledObservers, observer => { observer.OnNodeRestored(sender, e); });
}
protected override void OnCreated(object sender, Storage.Events.NodeEventArgs e)
{
base.OnCreated(sender, e);
SendNotification();
}
protected internal virtual void OnNodeDeleted(object sender, NodeEventArgs e)
{
}
protected override void OnNodeCreated(object sender, NodeEventArgs e)
{
OnInvalidate(sender, e.SourceNode.Path);
}
protected override void OnNodeDeletedPhysically(object sender, NodeEventArgs e)
{
base.OnNodeDeletedPhysically(sender, e);
if (e.SourceNode.Path.StartsWith(SkinObserver.SkinStartPath))
SkinManager.Instance.RemoveFromMap(e.SourceNode.Path);
}
//============================================================== Overrides
protected override void OnDeletedPhysically(object sender, Storage.Events.NodeEventArgs e)
{
base.OnDeletedPhysically(sender, e);
RefreshExpenseClaim();
}
internal static void FireOnNodeModified(EventHandler <NodeEventArgs> Modified, Node sender, NodeEventArgs e, List <Type> disabledObservers)
{
InvokeEventHandlers <NodeEventArgs>(Modified, sender, e);
FireNodeEvent(disabledObservers, observer => { observer.OnNodeModified(sender, e); });
}
protected override void OnLoaded(object sender, NodeEventArgs e)
{
base.OnLoaded(sender, e);
_contentListType = (ContentListType)base.GetCachedData(CONTENTLISTTYPEKEY);
if (_contentListType != null)
{
_fieldSettings = (List<FieldSetting>)base.GetCachedData(FIELDSETTINGSKEY);
return;
}
Build();
base.SetCachedData(FIELDSETTINGSKEY, _fieldSettings);
base.SetCachedData(CONTENTLISTTYPEKEY, _contentListType);
}
internal static void FireOnNodeDeletedPhysically(EventHandler <NodeEventArgs> DeletedPhysically, Node sender, NodeEventArgs e, List <Type> disabledObservers)
{
InvokeEventHandlers <NodeEventArgs>(DeletedPhysically, sender, e);
FireNodeEvent(disabledObservers, observer => { observer.OnNodeDeletedPhysically(sender, e); });
}
