/// <summary>
/// Adds message to event log object and updates event type.
/// </summary>
/// <param name="logMessage">Message to log</param>
protected void AddEventLog(string logMessage)
{
// Log event to event log
LogContext.LogEventToCurrent(eventType, "Integration bus", eventCode, logMessage,
RequestContext.RawURL, currentUser.UserID, currentUser.UserName,
0, null, RequestContext.UserHostAddress, currentSiteId, SystemContext.MachineName, RequestContext.URLReferrer, RequestContext.UserAgent, DateTime.Now);
}
/// <summary>
/// When exception occurs, log it to event log and add message to asnyc log.
/// </summary>
/// <param name="errorTitle">Error to add to async log</param>
/// <param name="nodeId">ID of node which caused operation to fail</param>
/// <param name="ex">Exception to log</param>
/// <param name="siteId">Site identifier</param>
/// <param name="eventCode">Code of event</param>
private void LogExceptionToEventLog(string eventCode, string errorTitle, int nodeId, Exception ex, int siteId)
{
LogContext.LogEventToCurrent(EventType.ERROR, "Content", eventCode, EventLogProvider.GetExceptionLogMessage(ex),
RequestContext.RawURL, CurrentUser.UserID, CurrentUser.UserName, nodeId, null, RequestContext.UserHostAddress, siteId, SystemContext.MachineName, RequestContext.URLReferrer, RequestContext.UserAgent, DateTime.Now);
AddError(GetString(errorTitle));
}
/// <summary>
/// Empties recycle bin.
/// </summary>
private void EmptyBin(BinSettingsContainer settings)
{
// Begin log
AddLog(ResHelper.GetString("Recyclebin.EmptyingBin", mCurrentCulture));
try
{
DataSet recycleBin = GetRecycleBinSeletedItems(settings, "VersionID, VersionObjectType, VersionObjectID, VersionObjectDisplayName, VersionObjectSiteID");
if (!DataHelper.DataSourceIsEmpty(recycleBin))
{
foreach (DataRow dr in recycleBin.Tables[0].Rows)
{
string versionObjType = Convert.ToString(dr["VersionObjectType"]);
string objName = HTMLHelper.HTMLEncode(ResHelper.LocalizeString(ValidationHelper.GetString(dr["VersionObjectDisplayName"], string.Empty)));
SiteInfo currentSite = settings.Site;
string siteName;
if (currentSite != null)
{
siteName = currentSite.SiteName;
}
else
{
int siteId = ValidationHelper.GetInteger(dr["VersionObjectSiteID"], 0);
siteName = SiteInfoProvider.GetSiteName(siteId);
}
// Check permissions
UserInfo currentUserInfo = settings.User;
if (!currentUserInfo.IsAuthorizedPerObject(PermissionsEnum.Destroy, versionObjType, siteName))
{
CurrentError = String.Format(ResHelper.GetString("objectversioning.Recyclebin.DestructionFailedPermissions", mCurrentCulture), objName);
AddLog(CurrentError);
}
else
{
AddLog(ResHelper.GetString("general.object", mCurrentCulture) + " '" + objName + "'");
// Destroy the version
int versionObjId = ValidationHelper.GetInteger(dr["VersionObjectID"], 0);
ObjectVersionManager.DestroyObjectHistory(versionObjType, versionObjId);
LogContext.LogEventToCurrent(EventType.INFORMATION, "Objects", "DESTROYOBJECT", String.Format(ResHelper.GetString("objectversioning.Recyclebin.objectdestroyed"), objName), RequestContext.RawURL, currentUserInfo.UserID, currentUserInfo.UserName, 0, null, RequestContext.UserHostAddress, (currentSite != null) ? currentSite.SiteID : 0, SystemContext.MachineName, RequestContext.URLReferrer, RequestContext.UserAgent, DateTime.Now);
}
}
if (!String.IsNullOrEmpty(CurrentError))
{
CurrentError = ResHelper.GetString("objectversioning.recyclebin.errorsomenotdestroyed", mCurrentCulture);
AddLog(CurrentError);
}
else
{
CurrentInfo = ResHelper.GetString("ObjectVersioning.Recyclebin.DestroyOK", mCurrentCulture);
AddLog(CurrentInfo);
}
}
}
catch (ThreadAbortException ex)
{
if (!CMSThread.Stopped(ex))
{
// Log error
CurrentError = "Error occurred: " + ResHelper.GetString("general.seeeventlog", mCurrentCulture);
AddLog(CurrentError);
// Log to event log
LogException("EMPTYINGBIN", ex);
}
}
catch (Exception ex)
{
// Log error
CurrentError = "Error occurred: " + ResHelper.GetString("general.seeeventlog", mCurrentCulture);
AddLog(CurrentError);
// Log to event log
LogException("EMPTYINGBIN", ex);
}
}
private void RemoveWorkflow(object parameter)
{
VersionManager verMan = VersionManager.GetInstance(Tree);
TreeNode node = null;
// Custom logging
Tree.LogEvents = false;
Tree.AllowAsyncActions = false;
CanceledString = GetString("workflowdocuments.removingcanceled", mCurrentCulture);
try
{
// Begin log
AddLog(GetString("content.preparingdocuments", mCurrentCulture));
string where = parameter as string;
// Get the documents
DataSet documents = GetDocumentsToProcess(where);
if (!DataHelper.DataSourceIsEmpty(documents))
{
// Begin log
AddLog(GetString("workflowdocuments.removingwf", mCurrentCulture));
foreach (DataTable classTable in documents.Tables)
{
foreach (DataRow nodeRow in classTable.Rows)
{
// Get the current document
string className = ValidationHelper.GetString(nodeRow["ClassName"], string.Empty);
string aliasPath = ValidationHelper.GetString(nodeRow["NodeAliasPath"], string.Empty);
string docCulture = ValidationHelper.GetString(nodeRow["DocumentCulture"], string.Empty);
string siteName = SiteInfoProvider.GetSiteName(nodeRow["NodeSiteID"].ToInteger(0));
// Get published version
node = Tree.SelectSingleNode(siteName, aliasPath, docCulture, false, className, false);
string encodedAliasPath = HTMLHelper.HTMLEncode(ValidationHelper.GetString(aliasPath, string.Empty) + " (" + node.GetValue("DocumentCulture") + ")");
// Destroy document history
verMan.DestroyDocumentHistory(node.DocumentID);
using (new CMSActionContext {
LogEvents = false
})
{
// Clear workflow
DocumentHelper.ClearWorkflowInformation(node);
node.Update();
}
// Add log record
AddLog(encodedAliasPath);
// Add record to eventlog
LogContext.LogEventToCurrent(EventType.INFORMATION, "Content", "REMOVEDOCWORKFLOW", string.Format(GetString("workflowdocuments.removeworkflowsuccess"), encodedAliasPath), RequestContext.RawURL, mCurrentUser.UserID, mCurrentUser.UserName, node.NodeID, node.GetDocumentName(), RequestContext.UserHostAddress, node.NodeSiteID, SystemContext.MachineName, RequestContext.URLReferrer, RequestContext.UserAgent, DateTime.Now);
}
}
CurrentInfo = GetString("workflowdocuments.removecomplete");
}
else
{
AddError(GetString("workflowdocuments.nodocumentstoclear", mCurrentCulture));
}
}
catch (ThreadAbortException ex)
{
if (CMSThread.Stopped(ex))
{
// When canceled
CurrentInfo = CanceledString;
}
else
{
int siteId = (node != null) ? node.NodeSiteID : SiteContext.CurrentSiteID;
// Log error
LogExceptionToEventLog("REMOVEDOCWORKFLOW", "workflowdocuments.removefailed", ex, siteId);
}
}
catch (Exception ex)
{
int siteId = (node != null) ? node.NodeSiteID : SiteContext.CurrentSiteID;
// Log error
LogExceptionToEventLog("REMOVEDOCWORKFLOW", "workflowdocuments.removefailed", ex, siteId);
}
}
/// <summary>
/// Resets permission inheritance of node and its children.
/// </summary>
/// <param name="siteName">Name of site</param>
/// <param name="nodeAliasPath">Alias path</param>
/// <param name="recursive">Indicates whether to recursively reset all nodes below the current node</param>
/// <param name="user">Current user</param>
/// <param name="tr">Tree provider</param>
/// <returns>Whether TRUE if no permission conflict has occurred</returns>
private bool ResetNodePermission(string siteName, string nodeAliasPath, bool recursive, UserInfo user, TreeProvider tr)
{
// Check permissions
bool permissionsResult = false;
try
{
if (tr == null)
{
tr = new TreeProvider(user);
}
// Get node by alias path
TreeNode treeNode = tr.SelectSingleNode(siteName, nodeAliasPath, null, true, null, false);
permissionsResult = CanModifyPermission(!recursive, treeNode, user);
if (treeNode != null)
{
// If user has permissions
if (permissionsResult)
{
// Break inheritance of a node
if (!AclInfoProvider.DoesNodeInheritPermissions(treeNode))
{
// Restore inheritance of a node
AclInfoProvider.RestoreInheritance(treeNode);
// Log current encoded alias path
AddLog(HTMLHelper.HTMLEncode(nodeAliasPath));
// Log staging task and flush cache
DocumentSynchronizationHelper.LogDocumentChange(treeNode, TaskTypeEnum.RestoreACLInheritance, treeNode.TreeProvider, SynchronizationInfoProvider.ENABLED_SERVERS, null, treeNode.TreeProvider.AllowAsyncActions);
Node.ClearCache();
// Insert information about this event to event log.
if (DocumentManager.Tree.LogEvents)
{
if (recursive)
{
LogContext.LogEventToCurrent(EventType.INFORMATION, "Content", "DOCPERMISSIONSMODIFIED", string.Format(ResHelper.GetAPIString("security.documentpermissionsrestoredfordoc", "Permissions of the page '{0}' have been restored to the parent page permissions."), nodeAliasPath), null, user.UserID, user.UserName, treeNode.NodeID, treeNode.GetDocumentName(), ipAddress, Node.NodeSiteID, null, null, null, DateTime.Now);
}
else
{
EventLogProvider.LogEvent(EventType.INFORMATION, "Content", "DOCPERMISSIONSMODIFIED", ResHelper.GetAPIString("security.documentpermissionsrestored", "Permissions have been restored to the parent page permissions."), eventUrl, user.UserID, user.UserName, treeNode.NodeID, treeNode.GetDocumentName(), ipAddress, Node.NodeSiteID);
}
}
}
else
{
AddLog(string.Format(GetString("cmsdesk.skippingrestoring"), HTMLHelper.HTMLEncode(nodeAliasPath)));
}
}
// Recursively reset node inheritance
if (recursive)
{
// Get child nodes of current node
DataSet ds = DocumentManager.Tree.SelectNodes(siteName, treeNode.NodeAliasPath.TrimEnd('/') + "/%", TreeProvider.ALL_CULTURES, true, null, null, null, 1, false, -1, DocumentColumnLists.SELECTNODES_REQUIRED_COLUMNS + ",NodeAliasPath");
if (!DataHelper.DataSourceIsEmpty(ds))
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
string childNodeAliasPath = ValidationHelper.GetString(dr["NodeAliasPath"], string.Empty);
if (!string.IsNullOrEmpty(childNodeAliasPath))
{
bool tempPermissionsResult = ResetNodePermission(siteName, childNodeAliasPath, true, user, tr);
permissionsResult = tempPermissionsResult && permissionsResult;
}
}
}
}
}
}
catch (ThreadAbortException ex)
{
if (CMSThread.Stopped(ex))
{
// When canceled
CurrentInfo = GetString("cmsdesk.restoringcanceled");
AddLog(CurrentInfo);
}
else
{
// Log error
CurrentError = GetString("cmsdesk.restoringfailed") + ": " + ex.Message;
AddLog(CurrentError);
}
}
catch (Exception ex)
{
// Log error
CurrentError = GetString("cmsdesk.restoringfailed") + ": " + ex.Message;
AddLog(CurrentError);
}
return(permissionsResult);
}
/// <summary>
/// Empties recycle bin.
/// </summary>
private void EmptyBin(object parameter)
{
// Begin log
AddLog(ResHelper.GetString("Recyclebin.EmptyingBin", mCurrentCulture));
BinSettingsContainer settings = (BinSettingsContainer)parameter;
CurrentUserInfo currentUserInfo = settings.User;
string where = null;
DateTime modifiedFrom = DateTimeHelper.ZERO_TIME;
DateTime modifiedTo = DateTimeHelper.ZERO_TIME;
switch (settings.CurrentWhat)
{
case What.AllDocuments:
SetDocumentAge(ref modifiedFrom, ref modifiedTo);
where = GetWhereCondition(filter.WhereCondition);
break;
case What.SelectedDocuments:
// Restore selected documents
var toRestore = settings.SelectedItems;
if ((toRestore != null) && (toRestore.Count > 0))
{
where = new WhereCondition().WhereIn("VersionHistoryID", toRestore).ToString(true);
}
break;
}
DataSet recycleBin = VersionHistoryInfoProvider.GetRecycleBin((mSelectedSite != null) ? mSelectedSite.SiteID : 0, 0, @where, "DocumentNamePath ASC", -1, null, modifiedFrom, modifiedTo);
try
{
if (!DataHelper.DataSourceIsEmpty(recycleBin))
{
TreeProvider tree = new TreeProvider(currentUserInfo);
tree.AllowAsyncActions = false;
VersionManager verMan = VersionManager.GetInstance(tree);
foreach (DataRow dr in recycleBin.Tables[0].Rows)
{
int versionHistoryId = Convert.ToInt32(dr["VersionHistoryID"]);
string documentNamePath = ValidationHelper.GetString(dr["DocumentNamePath"], string.Empty);
// Check permissions
TreeNode tn;
if (!IsAuthorizedPerDocument(versionHistoryId, "Destroy", mCurrentUser, out tn, verMan))
{
CurrentError = String.Format(ResHelper.GetString("Recyclebin.DestructionFailedPermissions", mCurrentCulture), documentNamePath);
AddLog(CurrentError);
}
else
{
AddLog(ResHelper.GetString("general.document", mCurrentCulture) + "'" + HTMLHelper.HTMLEncode(ValidationHelper.GetString(dr["DocumentNamePath"], string.Empty)) + "'");
// Destroy the version
verMan.DestroyDocumentHistory(ValidationHelper.GetInteger(dr["DocumentID"], 0));
LogContext.LogEventToCurrent(EventType.INFORMATION, "Content", "DESTROYDOC", string.Format(ResHelper.GetString("Recyclebin.documentdestroyed"), documentNamePath), RequestContext.RawURL, mCurrentUser.UserID, mCurrentUser.UserName, 0, null, RequestContext.UserHostAddress, SiteContext.CurrentSiteID, SystemContext.MachineName, RequestContext.URLReferrer, RequestContext.UserAgent, DateTime.Now);
}
}
if (!String.IsNullOrEmpty(CurrentError))
{
CurrentError = ResHelper.GetString("recyclebin.errorsomenotdestroyed", mCurrentCulture);
AddLog(CurrentError);
}
else
{
CurrentInfo = ResHelper.GetString("recyclebin.destroyok", mCurrentCulture);
AddLog(CurrentInfo);
}
}
}
catch (ThreadAbortException ex)
{
if (!CMSThread.Stopped(ex))
{
// Log error
LogException("DESTROYDOC", ex);
}
}
catch (Exception ex)
{
// Log error
LogException("DESTROYDOC", ex);
}
}
/// <summary>
/// When exception occures, log it to event log.
/// </summary>
/// <param name="messageTitle">Title message</param>
/// <param name="ex">Exception to log</param>
private void LogExceptionToEventLog(string messageTitle, Exception ex)
{
AddError(messageTitle + ": " + ex.Message);
LogContext.LogEventToCurrent(EventType.ERROR, "Content", "PUBLISHDOC", EventLogProvider.GetExceptionLogMessage(ex), RequestContext.RawURL, currentUser.UserID, currentUser.UserName, 0, null, RequestContext.UserHostAddress, currentSiteId, SystemContext.MachineName, RequestContext.URLReferrer, RequestContext.UserAgent, DateTime.Now);
}