private void RemoveWorkflow(object parameter) { VersionManager verMan = new VersionManager(Tree); TreeNode node = null; // Custom logging Tree.LogEvents = false; Tree.AllowAsyncActions = false; CanceledString = ResHelper.GetString("workflowdocuments.removingcanceled", currentCulture); try { // Begin log AddLog(ResHelper.GetString("content.preparingdocuments", currentCulture)); // Get the documents DataSet documents = GetDocumentsToProcess(); if (!DataHelper.DataSourceIsEmpty(documents)) { // Begin log AddLog(ResHelper.GetString("workflowdocuments.removingwf", currentCulture)); 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 = ValidationHelper.GetString(nodeRow["SiteName"], string.Empty); // 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); // Clear workflow DocumentHelper.ClearWorkflowInformation(node); node.Update(); // Add log record AddLog(encodedAliasPath); // Add record to eventlog LogContext.LogEvent(EventLogProvider.EVENT_TYPE_INFORMATION, DateTime.Now, "Content", "REMOVEDOCWORKFLOW", currentUser.UserID, currentUser.UserName, node.NodeID, node.DocumentName, HTTPHelper.UserHostAddress, string.Format(GetString("workflowdocuments.removeworkflowsuccess"), encodedAliasPath), node.NodeSiteID, HTTPHelper.GetAbsoluteUri(), HTTPHelper.MachineName, HTTPHelper.GetUrlReferrer(), HTTPHelper.GetUserAgent()); } } CurrentInfo = GetString("workflowdocuments.removecomplete"); } else { AddError(ResHelper.GetString("workflowdocuments.nodocumentstoclear", currentCulture)); } } catch (ThreadAbortException ex) { string state = ValidationHelper.GetString(ex.ExceptionState, string.Empty); if (state == CMSThread.ABORT_REASON_STOP) { // When canceled CurrentInfo = CanceledString; } else { int siteId = (node != null) ? node.NodeSiteID : CMSContext.CurrentSiteID; // Log error LogExceptionToEventLog("REMOVEDOCWORKFLOW", "workflowdocuments.removefailed", ex, siteId); } } catch (Exception ex) { int siteId = (node != null) ? node.NodeSiteID : CMSContext.CurrentSiteID; // Log error LogExceptionToEventLog("REMOVEDOCWORKFLOW", "workflowdocuments.removefailed", ex, siteId); } }
/// <summary> /// Delete documents section. /// </summary> /// <param name="node">Node to be deleted</param> /// <param name="tree">Tree provider</param> private void DeleteDocumentSection(TreeNode node, TreeProvider tree) { // Delete all document cultures DocumentHelper.DeleteDocument(node, tree, true); }
public HelpLine() { _logger = IoC.ContainerRegistrar.Container.Resolve <ILogger>(); _editorHelper = new EditorHelper(Application.DocumentManager.MdiActiveDocument); _drawingHelper = new DocumentHelper(Application.DocumentManager.MdiActiveDocument); }
public void Should_Validate_Correctly_The_CPJ() { Assert.IsTrue(DocumentHelper.IsValidDocument(DocumentHelper.TYPE_CPJ, "1234567894")); Assert.IsFalse(DocumentHelper.IsValidDocument(DocumentHelper.TYPE_CPJ, "123456789")); }
/// <summary> /// Generate control output. /// </summary> public void GenerateContent() { string templatePath = DepartmentTemplatePath; if (String.IsNullOrEmpty(templatePath)) { ltlContent.Text = ResHelper.GetString("departmentsectionsmanager.notemplate"); ltlContent.Visible = true; } else { if (!DataHelper.DataSourceIsEmpty(TemplateDocuments)) { int counter = 0; Table tb = new Table(); string value = ValidationHelper.GetString(mSelectedValue, ""); string docAliases = ";" + value.ToLowerCSafe() + ";"; TreeNode editedNode = (TreeNode)Form.EditedObject; if (Form.IsInsertMode) { // Alias path for new department has to have special 'child node path' because of correct check for document type scopes editedNode.SetValue("NodeAliasPath", ((TreeNode)Form.ParentObject).NodeAliasPath + "/department"); } TableRow tr = new TableRow(); foreach (DataRow drDoc in TemplateDocuments.Tables[0].Rows) { // For each section td element is generated string docAlias = ValidationHelper.GetString(drDoc["NodeAlias"], ""); TableCell td = new TableCell(); CMSCheckBox cbCell = new CMSCheckBox(); cbCell.ID = "chckSection" + counter; cbCell.Text = docAlias; cbCell.Attributes.Add("Value", docAlias); // Check if child allowed int sourceClassId = ValidationHelper.GetInteger(drDoc["NodeClassID"], 0); if (!DocumentHelper.IsDocumentTypeAllowed(editedNode, sourceClassId)) { cbCell.Enabled = false; cbCell.ToolTip = ResHelper.GetString("departmentsectionsmanager.notallowedchild"); } // Disable default hidden documents if (HIDDEN_DOCUMENT_ALIAS.Contains(";" + docAlias.ToLowerCSafe() + ";")) { cbCell.Checked = cbCell.Enabled; cbCell.Enabled = false; } // Check for selected value if (docAliases.Contains(";" + docAlias.ToLowerCSafe() + ";") || ((mSelectedValue == null) && (Form.Mode == FormModeEnum.Insert))) { if (cbCell.Enabled) { cbCell.Checked = true; } } // If editing existing document register alert script if ((Form.Mode != FormModeEnum.Insert) && cbCell.Checked) { cbCell.Attributes.Add("OnClick", "if(!this.checked){alert(" + ScriptHelper.GetString(ResHelper.GetString("departmentsectionsmanagerformcontrol.removesectionwarning")) + ");}"); } // Add reference to checkbox arraylist CheckboxReferences.Add(cbCell); counter++; td.Controls.Add(cbCell); tr.Cells.Add(td); // If necessary create new row if ((counter % ITEMS_PER_ROW) == 0) { tr.CssClass = "Row"; tb.Rows.Add(tr); tr = new TableRow(); } } // If last row contains data add it if (counter > 0) { tb.Rows.Add(tr); } pnlContent.Controls.Add(tb); } else { ltlContent.Text = ResHelper.GetString("departmentsectionsmanager.notemplate"); ltlContent.Visible = true; } } }
public void Should_Validate_Correctly_The_CI() { Assert.IsTrue(DocumentHelper.IsValidDocument(DocumentHelper.TYPE_CI, "1002606430")); }
public void Should_Validate_Correctly_The_DNI() { Assert.IsTrue(DocumentHelper.IsValidDocument(DocumentHelper.TYPE_DNI, "12345678")); Assert.IsFalse(DocumentHelper.IsValidDocument(DocumentHelper.TYPE_DNI, "1234859")); }
/// <summary> /// Provides operations necessary to create and store new content file. /// </summary> private void HandleContentUpload() { string message = string.Empty; bool newDocumentCreated = false; try { if (NodeParentNodeID == 0) { throw new Exception(GetString("dialogs.document.parentmissing")); } // Check license limitations if (!LicenseHelper.LicenseVersionCheck(RequestContext.CurrentDomain, FeatureEnum.Documents, ObjectActionEnum.Insert)) { throw new LicenseException(GetString("cmsdesk.documentslicenselimits")); } // Check if class exists DataClassInfo ci = DataClassInfoProvider.GetDataClassInfo(SystemDocumentTypes.File); if (ci == null) { throw new Exception(string.Format(GetString("dialogs.newfile.classnotfound"), SystemDocumentTypes.File)); } #region "Check permissions" // Get the node TreeNode parentNode = TreeProvider.SelectSingleNode(NodeParentNodeID, LocalizationContext.PreferredCultureCode, true); if (parentNode != null) { // Check whether node class is allowed on site and parent node if (!DocumentHelper.IsDocumentTypeAllowed(parentNode, ci.ClassID) || (ClassSiteInfoProvider.GetClassSiteInfo(ci.ClassID, parentNode.NodeSiteID) == null)) { throw new Exception(GetString("Content.ChildClassNotAllowed")); } } // Check user permissions if (!RaiseOnCheckPermissions("Create", this)) { if (!MembershipContext.AuthenticatedUser.IsAuthorizedToCreateNewDocument(parentNode, SystemDocumentTypes.File)) { throw new Exception(string.Format(GetString("dialogs.newfile.notallowed"), NodeClassName)); } } #endregion // Check the allowed extensions CheckAllowedExtensions(); // Create new document string fileName = Path.GetFileNameWithoutExtension(ucFileUpload.FileName); string ext = Path.GetExtension(ucFileUpload.FileName); if (IncludeExtension) { fileName += ext; } // Make sure the file name with extension respects maximum file name fileName = TreePathUtils.EnsureMaxFileNameLength(fileName, ci.ClassName); node = TreeNode.New(SystemDocumentTypes.File, TreeProvider); node.DocumentCulture = LocalizationContext.PreferredCultureCode; node.DocumentName = fileName; if (NodeGroupID > 0) { node.SetValue("NodeGroupID", NodeGroupID); } // Load default values FormHelper.LoadDefaultValues(node.NodeClassName, node); node.SetValue("FileDescription", ""); node.SetValue("FileName", fileName); node.SetValue("FileAttachment", Guid.Empty); // Set default template ID node.SetDefaultPageTemplateID(ci.ClassDefaultPageTemplateID); // Insert the document DocumentHelper.InsertDocument(node, parentNode, TreeProvider); newDocumentCreated = true; // Add the file DocumentHelper.AddAttachment(node, "FileAttachment", ucFileUpload.PostedFile, ResizeToWidth, ResizeToHeight, ResizeToMaxSideSize); // Update the document DocumentHelper.UpdateDocument(node, TreeProvider); // Get workflow info wi = node.GetWorkflow(); // Check if auto publish changes is allowed if ((wi != null) && wi.WorkflowAutoPublishChanges && !wi.UseCheckInCheckOut(SiteContext.CurrentSiteName)) { // Automatically publish document node.MoveToPublishedStep(null); } } catch (Exception ex) { // Delete the document if something failed if (newDocumentCreated && (node != null) && (node.DocumentID > 0)) { DocumentHelper.DeleteDocument(node, TreeProvider, false, true); } message = ex.Message; } finally { // Create node info string string nodeInfo = ""; if ((node != null) && (node.NodeID > 0) && (IncludeNewItemInfo)) { nodeInfo = node.NodeID.ToString(); } // Ensure message text message = TextHelper.EnsureLineEndings(message, " "); string containerId = QueryHelper.GetString("containerid", ""); // Call function to refresh parent window string afterSaveScript = null; if (!string.IsNullOrEmpty(AfterSaveJavascript)) { afterSaveScript = String.Format( @" if (window.{0} != null){{ window.{0}(files); }} else if ((window.parent != null) && (window.parent.{0} != null)){{ window.parent.{0}(files); }}", AfterSaveJavascript ); } afterSaveScript += String.Format( @" if (typeof(parent.DFU) !== 'undefined') {{ parent.DFU.OnUploadCompleted({0}); }} if ((window.parent != null) && (/parentelemid={1}/i.test(window.location.href)) && (window.parent.InitRefresh_{1} != null)){{ window.parent.InitRefresh_{1}({2}, false, false{3}{4}); }} ", ScriptHelper.GetString(containerId), ParentElemID, ScriptHelper.GetString(message.Trim()), ((nodeInfo != "") ? ", '" + nodeInfo + "'" : ""), (InsertMode ? ", 'insert'" : ", 'update'") ); ScriptHelper.RegisterStartupScript(this, typeof(string), "afterSaveScript_" + ClientID, ScriptHelper.GetScript(afterSaveScript)); } }
public static Tree GetTree() { Settings = ReadSettings(); var tree = new Tree(); tree.Nodes = new List <Node>(); var rootName = DocumentHelper.RootName; if (Settings.ContainsKey(rootName)) { var setting = Settings[rootName]; if (setting != null) { var node = new Node() { ShowName = rootName, setting = setting, Url = DocumentHelper.GetTypeUrl(rootName) }; node.Nodes = new List <Node>(); var kscriptSetting = setting as KScriptSetting; foreach (var prop in kscriptSetting.Props) { var childNode = new Node() { ShowName = prop.Name, setting = prop, Url = DocumentHelper.GetTypeUrl(prop.Type) }; if (prop.Childrens.Count > 0) { foreach (var child in prop.Childrens) { childNode.Nodes = new List <Node>(); var childSetting = Settings[child.ToLower()]; if (childSetting != null) { childNode.Nodes.Add(new Node() { ShowName = child, setting = Settings[child.ToLower()], Url = DocumentHelper.GetTypeUrl(child) }); } } } node.Nodes.Add(childNode); } foreach (var method in kscriptSetting.Methods) { var paramBuilder = new StringBuilder(); foreach (var param in method.Params) { paramBuilder.Append(param.Name); } node.Nodes.Add(new Node() { ShowName = method.Name, setting = method, Url = DocumentHelper.GetMethodUrl("k", method.Name, paramBuilder.ToString()) }); } tree.Nodes.Add(node); } } return(tree); }
/// <summary> /// Page_Load event. /// </summary> protected void Page_Load(object sender, EventArgs e) { if (this.StopProcessing) { return; } // Create and set category provider UniTreeProvider categoryProvider = new UniTreeProvider(); categoryProvider.DisplayNameColumn = "DisplayName"; categoryProvider.IDColumn = "ObjectID"; categoryProvider.LevelColumn = "ObjectLevel"; categoryProvider.OrderColumn = "CategoryOrder"; categoryProvider.ParentIDColumn = "ParentID"; categoryProvider.PathColumn = "ObjectPath"; categoryProvider.ValueColumn = "ObjectID"; categoryProvider.ChildCountColumn = "CompleteChildCount"; categoryProvider.QueryName = "cms.pagetemplatecategory.selectallview"; categoryProvider.ObjectTypeColumn = "ObjectType"; categoryProvider.Columns = "DisplayName, CodeName, ObjectID, ObjectLevel, CategoryOrder, ParentID, ObjectPath, CompleteChildCount, ObjectType, CategoryChildCount, CategoryImagePath, Parameter"; categoryProvider.ImageColumn = "CategoryImagePath"; categoryProvider.ParameterColumn = "Parameter"; if (!SelectPageTemplates) { categoryProvider.WhereCondition = "ObjectType = 'pagetemplatecategory'"; categoryProvider.ChildCountColumn = "CategoryChildCount"; categoryProvider.ObjectTypeColumn = ""; treeElem.DefaultImagePath = GetImageUrl("Objects/CMS_PageTemplateCategory/list.png"); } else { categoryProvider.OrderBy = "ObjectType DESC, DisplayName ASC"; treeElem.OnGetImage += new CMSAdminControls_UI_Trees_UniTree.GetImageEventHandler(treeElem_OnGetImage); } // Do not show AdHoc category if (!this.ShowAdHocCategory) { categoryProvider.WhereCondition = SqlHelperClass.AddWhereCondition(categoryProvider.WhereCondition, "CodeName <> 'AdHoc'"); } // Do not show empty categories if (!this.ShowEmptyCategories) { categoryProvider.WhereCondition = SqlHelperClass.AddWhereCondition(categoryProvider.WhereCondition, "CategoryTemplateChildCount > 0 OR CategoryChildCount > 0"); TreeProvider tp = new TreeProvider(CMSContext.CurrentUser); TreeNode node = DocumentHelper.GetDocument(DocumentID, tp); string culture = CMSContext.PreferredCultureCode; int level = 0; string path = string.Empty; if (node != null) { level = node.NodeLevel; path = node.NodeAliasPath; if (IsNewPage) { level++; path = path + "/%"; } else { culture = node.DocumentCulture; } } // Add where condition for scopes categoryProvider.WhereCondition += " AND (ObjectLevel = 0 OR (SELECT TOP 1 ObjectID FROM View_CMS_PageTemplateCategoryPageTemplate_Joined AS X WHERE X.ObjectType = 'pagetemplate' "; categoryProvider.WhereCondition += " AND (X.PageTemplateType IS NULL OR X.PageTemplateType <> N'" + PageTemplateInfoProvider.GetPageTemplateTypeCode(PageTemplateTypeEnum.Dashboard) + "')"; if (ShowOnlySiteTemplates) { categoryProvider.WhereCondition += " AND X.ObjectID IN (SELECT PageTemplateID FROM CMS_PageTemplateSite WHERE SiteID = " + CMSContext.CurrentSiteID + ") "; } if (node != null) { categoryProvider.WhereCondition += " AND (" + PageTemplateScopeInfoProvider.GetScopeWhereCondition(path, culture, node.NodeClassName, level, CMSContext.CurrentSiteName, "X", "ObjectID") + ") "; } categoryProvider.WhereCondition += " AND (X.ObjectPath LIKE View_CMS_PageTemplateCategoryPageTemplate_Joined.ObjectPath + '/%')) IS NOT NULL)"; // Add column count column - minimal number of childs categoryProvider.Columns += @", (SELECT TOP 1 Count(*) FROM View_CMS_PageTemplateCategoryPageTemplate_Joined AS Y WHERE (Y.ObjectID = View_CMS_PageTemplateCategoryPageTemplate_Joined.ObjectID AND Y.ObjectLevel = 0) OR ( View_CMS_PageTemplateCategoryPageTemplate_Joined.ObjectType = 'PageTemplateCategory' AND View_CMS_PageTemplateCategoryPageTemplate_Joined.CategoryChildCount > 0 AND Y.ObjectType = 'PageTemplate' AND Y.ObjectLevel > View_CMS_PageTemplateCategoryPageTemplate_Joined.ObjectLevel + 1 "; if (ShowOnlySiteTemplates) { categoryProvider.Columns += "AND Y.ObjectID IN (SELECT PageTemplateID FROM CMS_PageTemplateSite WHERE SiteID = " + CMSContext.CurrentSiteID + ") "; } if (node != null) { categoryProvider.Columns += " AND ( " + PageTemplateScopeInfoProvider.GetScopeWhereCondition(path, culture, node.NodeClassName, level, CMSContext.CurrentSiteName, "Y", "ObjectID") + " ) "; } categoryProvider.Columns += " AND Y.ObjectPath LIKE View_CMS_PageTemplateCategoryPageTemplate_Joined.ObjectPath + '/%')) AS MinNumberOfChilds"; categoryProvider.ChildCountColumn = "MinNumberOfChilds"; } // Set up tree treeElem.ProviderObject = categoryProvider; if (SelectPageTemplates) { treeElem.NodeTemplate = "<span id=\"##OBJECTTYPE##_##NODEID##\" onclick=\"SelectNode(##NODEID##,'##OBJECTTYPE##', ##PARENTNODEID##, '##PARAMETER##');\" name=\"treeNode\" class=\"ContentTreeItem\">##ICON## <span class=\"Name\">##NODENAME##</span></span>"; treeElem.SelectedNodeTemplate = "<span id=\"##OBJECTTYPE##_##NODEID##\" onclick=\"SelectNode(##NODEID##,'##OBJECTTYPE##', ##PARENTNODEID##, '##PARAMETER##');\" name=\"treeNode\" class=\"ContentTreeItem ContentTreeSelectedItem\">##ICON## <span class=\"Name\">##NODENAME##</span></span>"; } else { treeElem.NodeTemplate = "<span onclick=\"SelectNode(##NODEID##, this);\" class=\"ContentTreeItem\">##ICON## <span class=\"Name\">##NODENAME##</span></span>"; treeElem.DefaultItemTemplate = "<span onclick=\"SelectNode('recentlyused', this);\" class=\"ContentTreeItem\">##ICON##<span class=\"Name\">##NODENAME##</span></span><div style=\"clear:both\"></div>"; treeElem.SelectedDefaultItemTemplate = "<span onclick=\"SelectNode('recentlyused', this);\" class=\"ContentTreeItem ContentTreeSelectedItem\">##ICON##<span class=\"Name\">##NODENAME##</span></span><div style=\"clear:both\"></div>"; treeElem.SelectedNodeTemplate = "<span onclick=\"SelectNode(##NODEID##, this);\" class=\"ContentTreeItem ContentTreeSelectedItem\">##ICON## <span class=\"Name\">##NODENAME##</span></span>"; // Register jquery ScriptHelper.RegisterJQuery(this.Page); string js = "function SelectNode(nodeid, sender){ " + "var selectedItem = $j('.ContentTreeSelectedItem'); " + "selectedItem.removeClass('ContentTreeSelectedItem'); " + "selectedItem.addClass('ContentTreeItem');" + "selectedItem = $j(sender);" + "selectedItem.removeClass('ContentTreeItem'); " + "selectedItem.addClass('ContentTreeSelectedItem'); " + "document.getElementById('" + this.treeElem.SelectedItemFieldId + "').value = nodeid;" + treeElem.GetOnSelectedItemBackEventReference() + "}"; ScriptHelper.RegisterClientScriptBlock(this, typeof(string), "SelectTreeNode", ScriptHelper.GetScript(js)); } // Setup event handler treeElem.OnItemSelected += new CMSAdminControls_UI_Trees_UniTree.ItemSelectedEventHandler(treeElem_OnItemSelected); treeElem.OnNodeCreated += new CMSAdminControls_UI_Trees_UniTree.NodeCreatedEventHandler(treeElem_OnNodeCreated); }
/// <summary> /// Provides operations necessary to create and store new attachment. /// </summary> private void HandleAttachmentUpload(bool fieldAttachment) { // New attachment DocumentAttachment newAttachment = null; string message = string.Empty; bool fullRefresh = false; bool refreshTree = false; try { // Get the existing document if (DocumentID != 0) { // Get document node = DocumentHelper.GetDocument(DocumentID, TreeProvider); if (node == null) { throw new Exception("Given page doesn't exist!"); } } #region "Check permissions" if (CheckPermissions) { CheckNodePermissions(node); } #endregion // Check the allowed extensions CheckAllowedExtensions(); // Standard attachments if (DocumentID != 0) { // Check out the document if (AutoCheck) { // Get original step Id int originalStepId = node.DocumentWorkflowStepID; // Get current step info WorkflowStepInfo si = WorkflowManager.GetStepInfo(node); if (si != null) { // Decide if full refresh is needed bool automaticPublish = wi.WorkflowAutoPublishChanges; // Document is published or archived or uses automatic publish or step is different than original (document was updated) fullRefresh = si.StepIsPublished || si.StepIsArchived || (automaticPublish && !si.StepIsPublished) || (originalStepId != node.DocumentWorkflowStepID); } using (CMSActionContext ctx = new CMSActionContext() { LogEvents = false }) { VersionManager.CheckOut(node, node.IsPublished, true); } } // Handle field attachment if (fieldAttachment) { // Extension of CMS file before saving string oldExtension = node.DocumentType; newAttachment = DocumentHelper.AddAttachment(node, AttachmentGUIDColumnName, Guid.Empty, Guid.Empty, ucFileUpload.PostedFile, ResizeToWidth, ResizeToHeight, ResizeToMaxSideSize); // Update attachment field DocumentHelper.UpdateDocument(node, TreeProvider); // Different extension if ((oldExtension != null) && !oldExtension.EqualsCSafe(node.DocumentType, true)) { refreshTree = true; } } // Handle grouped and unsorted attachments else { // Grouped attachment if (AttachmentGroupGUID != Guid.Empty) { newAttachment = DocumentHelper.AddGroupedAttachment(node, AttachmentGUID, AttachmentGroupGUID, ucFileUpload.PostedFile, ResizeToWidth, ResizeToHeight, ResizeToMaxSideSize); } // Unsorted attachment else { newAttachment = DocumentHelper.AddUnsortedAttachment(node, AttachmentGUID, ucFileUpload.PostedFile, ResizeToWidth, ResizeToHeight, ResizeToMaxSideSize); } // Log synchronization task if not under workflow if (wi == null) { DocumentSynchronizationHelper.LogDocumentChange(node, TaskTypeEnum.UpdateDocument, TreeProvider); } } // Check in the document if (AutoCheck) { using (CMSActionContext ctx = new CMSActionContext() { LogEvents = false }) { VersionManager.CheckIn(node, null, null); } } } // Temporary attachments if (FormGUID != Guid.Empty) { newAttachment = (DocumentAttachment)AttachmentInfoProvider.AddTemporaryAttachment(FormGUID, AttachmentGUIDColumnName, AttachmentGUID, AttachmentGroupGUID, ucFileUpload.PostedFile, SiteContext.CurrentSiteID, ResizeToWidth, ResizeToHeight, ResizeToMaxSideSize); } // Ensure properties update if ((newAttachment != null) && !InsertMode) { AttachmentGUID = newAttachment.AttachmentGUID; } if (newAttachment == null) { throw new Exception("The attachment hasn't been created since no DocumentID or FormGUID was supplied."); } } catch (Exception ex) { // Log the exception EventLogProvider.LogException("Content", "UploadAttachment", ex); message = ex.Message; } finally { string afterSaveScript = string.Empty; // Call aftersave javascript if exists if (!String.IsNullOrEmpty(AfterSaveJavascript)) { if ((message == string.Empty) && (newAttachment != null)) { string url = null; string safeName = URLHelper.GetSafeFileName(newAttachment.AttachmentName, SiteContext.CurrentSiteName); if (node != null) { SiteInfo si = SiteInfoProvider.GetSiteInfo(node.NodeSiteID); if (si != null) { bool usePermanent = DocumentURLProvider.UsePermanentUrls(si.SiteName); if (usePermanent) { url = ResolveUrl(AttachmentURLProvider.GetAttachmentUrl(newAttachment.AttachmentGUID, safeName)); } else { url = ResolveUrl(AttachmentURLProvider.GetAttachmentUrl(safeName, node.NodeAliasPath)); } } } else { url = ResolveUrl(AttachmentURLProvider.GetAttachmentUrl(newAttachment.AttachmentGUID, safeName)); } // Calling javascript function with parameters attachments url, name, width, height if (!string.IsNullOrEmpty(AfterSaveJavascript)) { Hashtable obj = new Hashtable(); if (ImageHelper.IsImage(newAttachment.AttachmentExtension)) { obj[DialogParameters.IMG_URL] = url; obj[DialogParameters.IMG_TOOLTIP] = newAttachment.AttachmentName; obj[DialogParameters.IMG_WIDTH] = newAttachment.AttachmentImageWidth; obj[DialogParameters.IMG_HEIGHT] = newAttachment.AttachmentImageHeight; } else if (MediaHelper.IsAudioVideo(newAttachment.AttachmentExtension)) { obj[DialogParameters.OBJECT_TYPE] = "audiovideo"; obj[DialogParameters.AV_URL] = url; obj[DialogParameters.AV_EXT] = newAttachment.AttachmentExtension; obj[DialogParameters.AV_WIDTH] = DEFAULT_OBJECT_WIDTH; obj[DialogParameters.AV_HEIGHT] = DEFAULT_OBJECT_HEIGHT; } else { obj[DialogParameters.LINK_URL] = url; obj[DialogParameters.LINK_TEXT] = newAttachment.AttachmentName; } // Calling javascript function with parameters attachments url, name, width, height afterSaveScript += ScriptHelper.GetScript(string.Format(@"{5} if (window.{0}) {{ window.{0}('{1}', '{2}', '{3}', '{4}', obj); }} else if((window.parent != null) && window.parent.{0}) {{ window.parent.{0}('{1}', '{2}', '{3}', '{4}', obj); }}", AfterSaveJavascript, url, newAttachment.AttachmentName, newAttachment.AttachmentImageWidth, newAttachment.AttachmentImageHeight, CMSDialogHelper.GetDialogItem(obj))); } } else { afterSaveScript += ScriptHelper.GetAlertScript(message); } } // Create attachment info string string attachmentInfo = ((newAttachment != null) && (newAttachment.AttachmentGUID != Guid.Empty) && (IncludeNewItemInfo)) ? String.Format("'{0}', ", newAttachment.AttachmentGUID) : ""; // Ensure message text message = TextHelper.EnsureLineEndings(message, " "); // Call function to refresh parent window afterSaveScript += ScriptHelper.GetScript(String.Format(@" if ((window.parent != null) && (/parentelemid={0}/i.test(window.location.href)) && (window.parent.InitRefresh_{0} != null)){{ window.parent.InitRefresh_{0}({1}, {2}, {3}, {4}); }}", ParentElemID, ScriptHelper.GetString(message.Trim()), (fullRefresh ? "true" : "false"), (refreshTree ? "true" : "false"), attachmentInfo + (InsertMode ? "'insert'" : "'update'"))); ScriptHelper.RegisterStartupScript(this, typeof(string), "afterSaveScript_" + ClientID, afterSaveScript); } }
/// <summary> /// Yes button click event handler. /// </summary> protected void btnYes_Click(object sender, EventArgs e) { // Prepare the where condition string where = "NodeID = " + NodeID; // Get the documents DataSet ds = null; if (chkAllCultures.Checked) { ds = TreeProvider.SelectNodes(SiteName, "/%", TreeProvider.ALL_CULTURES, true, null, where, null, -1, false); } else { ds = TreeProvider.SelectNodes(SiteName, "/%", CultureCode, false, null, where, null, -1, false); } if (!DataHelper.DataSourceIsEmpty(ds)) { // Get node alias var nodeAlias = DataHelper.GetStringValue(ds.Tables[0].Rows[0], "NodeAlias", string.Empty); // Get parent alias path var parentAliasPath = TreePathUtils.GetParentPath(DataHelper.GetStringValue(ds.Tables[0].Rows[0], "NodeAliasPath", string.Empty)); // Delete the documents foreach (DataRow dr in ds.Tables[0].Rows) { var aliasPath = ValidationHelper.GetString(dr["NodeAliasPath"], string.Empty); var culture = ValidationHelper.GetString(dr["DocumentCulture"], string.Empty); var className = ValidationHelper.GetString(dr["ClassName"], string.Empty); // Get the node var treeNode = TreeProvider.SelectSingleNode(SiteName, aliasPath, culture, false, className, false); if (treeNode != null) { // Check delete permissions var hasUserDeletePermission = !CheckPermissions || IsUserAuthorizedToDeleteDocument(treeNode, chkDestroy.Checked); if (hasUserDeletePermission) { // Delete the document try { DocumentHelper.DeleteDocument(treeNode, TreeProvider, chkAllCultures.Checked, chkDestroy.Checked); } catch (Exception ex) { var logData = new EventLogData(EventTypeEnum.Error, "Content", "DELETEDOC") { EventDescription = EventLogProvider.GetExceptionLogMessage(ex), EventUrl = RequestContext.RawURL, UserID = MembershipContext.AuthenticatedUser.UserID, UserName = MembershipContext.AuthenticatedUser.UserName, NodeID = treeNode.NodeID, DocumentName = treeNode.GetDocumentName(), IPAddress = RequestContext.UserHostAddress, SiteID = SiteContext.CurrentSiteID }; Service.Resolve <IEventLogService>().LogEvent(logData); AddAlert(GetString("ContentRequest.DeleteFailed") + ": " + ex.Message); return; } } // Access denied - not authorized to delete the document else { AddAlert(String.Format(GetString("cmsdesk.notauthorizedtodeletedocument"), HTMLHelper.HTMLEncode(treeNode.GetDocumentName()))); return; } } else { AddAlert(GetString("ContentRequest.ErrorMissingSource")); return; } } RaiseOnAfterDelete(); } else { AddAlert(GetString("DeleteDocument.CultureNotExists")); } }
private void DeleteAttachmentAction(Guid attGuid) { if (!createTempAttachment) { if (attGuid != Guid.Empty) { // Delete attachment if (FormGUID == Guid.Empty) { // Ensure automatic check-in/ check-out VersionManager vm = null; // Check out the document if (AutoCheck) { vm = VersionManager.GetInstance(TreeProvider); vm.CheckOut(Node, Node.IsPublished, true); } // If the GUID column is set, use it to process additional actions for field attachments if (!String.IsNullOrEmpty(GUIDColumnName)) { DocumentHelper.DeleteAttachment(Node, GUIDColumnName); } else { DocumentHelper.DeleteAttachment(Node, attGuid); } DocumentHelper.UpdateDocument(Node, TreeProvider); // Ensure full page refresh if (AutoCheck) { ScriptHelper.RegisterStartupScript(Page, typeof(Page), "deleteRefresh", ScriptHelper.GetScript("InitRefresh_" + ClientID + "('', true, true, '" + attGuid + "', 'delete');")); } else { string script = "if (window.RefreshTree) { RefreshTree(" + Node.NodeParentID + ", " + Node.NodeID + "); }"; ScriptHelper.RegisterStartupScript(Page, typeof(Page), "refreshTree", ScriptHelper.GetScript(script)); } // Check in the document if (AutoCheck) { if (vm != null) { vm.CheckIn(Node, null); } } // Log synchronization task if not under workflow if (!UsesWorkflow) { DocumentSynchronizationHelper.LogDocumentChange(Node, TaskTypeEnum.UpdateDocument, TreeProvider); } } else { AttachmentInfoProvider.DeleteTemporaryAttachment(attGuid, SiteContext.CurrentSiteName); } } } LastAction = "delete"; Value = Guid.Empty; }
/// <summary> /// Gets a set of documents to be processed. /// </summary> /// <returns>Set of documents based on where condition and other settings</returns> private DataSet GetDocumentsToProcess() { string columns = SqlHelperClass.MergeColumns(TreeProvider.SELECTNODES_REQUIRED_COLUMNS, "NodeAliasPath, ClassName, DocumentCulture, SiteName"); return(DocumentHelper.GetDocuments(TreeProvider.ALL_SITES, "/%", TreeProvider.ALL_CULTURES, false, TreeProvider.ALL_CLASSNAMES, GetCurrentWhere(), "NodeAliasPath DESC", -1, false, -1, columns, Tree)); }
protected void wzdImport_NextButtonClick(object sender, WizardNavigationEventArgs e) { var settings = ImportSettings; ClearErrorLabel(); switch (e.CurrentStepIndex) { // Import type case 0: { if (!siteType.SelectTemplate) { try { // Get blank web template WebTemplateInfo wi = WebTemplateInfoProvider.GetWebTemplateInfo("BlankSite"); if (wi == null) { e.Cancel = true; return; } WebTemplateID = wi.WebTemplateId; string path = Server.MapPath(wi.WebTemplateFileName); if (File.Exists(path + "\\template.zip")) { // Template from zip file path += "\\" + ZipStorageProvider.GetZipFileName("template.zip"); settings.TemporaryFilesPath = path; settings.SourceFilePath = path; settings.TemporaryFilesCreated = true; settings.RefreshMacroSecurity = true; } else { // Init the settings settings.TemporaryFilesCreated = false; settings.SourceFilePath = Server.MapPath(wi.WebTemplateFileName); settings.RefreshMacroSecurity = true; } if (!File.Exists(settings.SourceFilePath)) { try { ImportProvider.CreateTemporaryFiles(settings); } catch (Exception ex) { SetErrorLabel(ex.Message); e.Cancel = true; return; } } // Import all, but only add new data settings.ImportType = ImportTypeEnum.AllNonConflicting; settings.ImportOnlyNewObjects = true; settings.CopyFiles = false; // Allow bulk inserts for faster import, web templates must be consistent enough to allow this without collisions settings.AllowBulkInsert = true; ltlScriptAfter.Text = ScriptHelper.GetScript( "var actDiv = document.getElementById('actDiv'); \n" + "if (actDiv != null) { actDiv.style.display='block'; } \n" + "var buttonsDiv = document.getElementById('buttonsDiv'); if (buttonsDiv != null) { buttonsDiv.disabled=true; } \n" + "BTN_Disable('" + NextButton.ClientID + "'); \n" + "StartSelectionTimer();" ); // Preselect objects asynchronously ctrlAsyncSelection.Parameter = "N"; ctrlAsyncSelection.RunAsync(SelectObjects, WindowsIdentity.GetCurrent()); e.Cancel = true; } catch (Exception ex) { SetErrorLabel(ex.Message); e.Cancel = true; return; } } else { siteDetails.SiteName = null; siteDetails.SiteDisplayName = null; selectTemplate.ReloadData(); } wzdImport.ActiveStepIndex++; } break; // Template selection case 1: { if (!selectTemplate.ApplySettings()) { e.Cancel = true; return; } // Init the settings WebTemplateInfo wi = WebTemplateInfoProvider.GetWebTemplateInfo(selectTemplate.WebTemplateId); if (wi == null) { throw new Exception("Web template not found."); } settings.IsWebTemplate = true; string path = Server.MapPath(wi.WebTemplateFileName); if (File.Exists(path + "\\template.zip")) { // Template from zip file path += "\\" + ZipStorageProvider.GetZipFileName("template.zip"); settings.TemporaryFilesPath = path; settings.SourceFilePath = path; settings.TemporaryFilesCreated = true; settings.RefreshMacroSecurity = true; } else { // Template from folder settings.TemporaryFilesCreated = false; settings.SourceFilePath = path; settings.RefreshMacroSecurity = true; try { ImportProvider.CreateTemporaryFiles(settings); } catch (Exception ex) { SetErrorLabel(ex.Message); e.Cancel = true; return; } } // Import all, but only add new data settings.ImportType = ImportTypeEnum.AllNonConflicting; settings.ImportOnlyNewObjects = true; settings.CopyFiles = false; // Allow bulk inserts for faster import, web templates must be consistent enough to allow this without collisions settings.AllowBulkInsert = true; ltlScriptAfter.Text = ScriptHelper.GetScript( "var actDiv = document.getElementById('actDiv');\n" + "if (actDiv != null) { actDiv.style.display='block'; }\n" + "var buttonsDiv = document.getElementById('buttonsDiv');\n" + "if (buttonsDiv != null) { buttonsDiv.disabled=true; }\n" + "BTN_Disable('" + NextButton.ClientID + "');\n" + "BTN_Disable('" + PreviousButton.ClientID + "');\n" + "StartSelectionTimer();" ); // Preselect objects asynchronously ctrlAsyncSelection.Parameter = "T"; ctrlAsyncSelection.RunAsync(SelectObjects, WindowsIdentity.GetCurrent()); e.Cancel = true; } break; // Site details case 2: if (!siteDetails.ApplySettings()) { e.Cancel = true; return; } // Update settings ImportSettings = siteDetails.Settings; if (!siteType.SelectTemplate && (ImportSettings.SiteName == InfoHelper.CODENAME_AUTOMATIC)) { ImportSettings.SiteName = ValidationHelper.GetCodeName(settings.SiteDisplayName); } Culture = siteDetails.Culture; pnlImport.ReloadData(true); wzdImport.ActiveStepIndex++; break; // Objects selection case 3: if (!pnlImport.ApplySettings()) { e.Cancel = true; return; } // Check licenses string error = ImportExportControl.CheckLicenses(settings); if (!string.IsNullOrEmpty(error)) { SetErrorLabel(error); e.Cancel = true; return; } ImportSettings = pnlImport.Settings; PreviousButton.Enabled = false; NextButton.Enabled = false; SiteName = settings.SiteName; Domain = settings.SiteDomain; // Start asynchronous Import settings.SetSettings(ImportExportHelper.SETTINGS_DELETE_TEMPORARY_FILES, false); settings.DefaultProcessObjectType = ProcessObjectEnum.Selected; var manager = ImportManager; settings.LogContext = ctlAsyncImport.CurrentLog; manager.Settings = settings; // Import site asynchronously ctlAsyncImport.RunAsync(ImportManager.Import, WindowsIdentity.GetCurrent()); wzdImport.ActiveStepIndex++; break; // Import progress case 4: PreviousButton.Visible = false; CultureHelper.SetPreferredCulture(Culture); if (siteType.SelectTemplate) { // Done finishSite.Domain = Domain; finishSite.SiteIsRunning = SiteIsRunning; wzdImport.ActiveStepIndex = 6; } else { if (ImportManager.Settings.IsWarning()) { try { // Convert default culture TreeProvider tree = new TreeProvider(MembershipContext.AuthenticatedUser); tree.ChangeSiteDefaultCulture(SiteName, Culture, "en-US"); // Change root GUID TreeNode root = DocumentHelper.GetDocument(SiteName, "/", Culture, false, SystemDocumentTypes.Root, null, null, 1, false, null, tree); if (root != null) { root.NodeGUID = Guid.NewGuid(); DocumentHelper.UpdateDocument(root, tree); } } catch (Exception ex) { EventLogProvider.LogException("NewSiteWizard", "FINISH", ex); SetErrorLabel(ex.Message); e.Cancel = true; NextButton.Enabled = false; CancelButton.Enabled = false; mImportCanceled = true; return; } } selectMaster.SiteName = SiteName; selectMaster.ReloadData(); } break; case 5: if (!selectMaster.ApplySettings()) { e.Cancel = true; return; } finishSite.Domain = Domain; finishSite.SiteIsRunning = SiteIsRunning; break; // Other steps default: wzdImport.ActiveStepIndex = e.NextStepIndex; break; } }
/// <summary> /// Saves metadata and file name of attachment. /// </summary> /// <param name="newFileName">New attachment file name</param> /// <returns>Returns True if attachment was successfully saved.</returns> private bool SaveAttachment(string newFileName) { bool saved = false; // Save new data try { DocumentAttachment attachment = InfoObject as DocumentAttachment; if (attachment != null) { // Set new file name if (!string.IsNullOrEmpty(newFileName)) { string name = newFileName + attachment.AttachmentExtension; attachment.AttachmentName = name; if (!IsAttachmentNameUnique(attachment)) { // Attachment already exists. ShowError(GetString("img.errors.fileexists")); return(false); } } // Ensure automatic check-in/ check-out bool autoCheck = false; var wm = WorkflowManager.GetInstance(TreeProvider); if (!nodeIsParent && (Node != null)) { var wi = wm.GetNodeWorkflow(Node); if (wi != null) { autoCheck = !wi.UseCheckInCheckOut(SiteName); } // Check out the document if (autoCheck) { var nextStep = VersionManager.CheckOut(Node, Node.IsPublished); VersionHistoryID = Node.DocumentCheckedOutVersionHistoryID; if (IsWorkflowFinished(nextStep)) { attachment = (DocumentAttachment)AttachmentInfo.Provider.Get(attachment.AttachmentGUID, SiteInfoProvider.GetSiteID(SiteName)); } } } if (attachment != null) { // Set filename title and description attachment.AttachmentTitle = ObjectTitle; attachment.AttachmentDescription = ObjectDescription; attachment.AllowPartialUpdate = true; if (!nodeIsParent && (Node != null)) { DocumentHelper.UpdateAttachment(Node, attachment); // Check in the document if (autoCheck) { if (VersionManager != null) { if (VersionHistoryID > 0 && (Node != null)) { VersionManager.CheckIn(Node, null); } } } } else if (nodeIsParent) { attachment.Update(); } saved = true; string fullRefresh = "false"; if (autoCheck || (Node == null)) { fullRefresh = "true"; } // Refresh parent update panel LtlScript.Text = ScriptHelper.GetScript("RefreshMetaData(" + ScriptHelper.GetString(ExternalControlID) + ", '" + fullRefresh + "', '" + attachment.AttachmentGUID + "', 'refresh')"); } } } catch (Exception ex) { ShowError(GetString("metadata.errors.processing")); Service.Resolve <IEventLogService>().LogException("Metadata editor", "SAVEATTACHMENT", ex); } return(saved); }
// TODO Load element with XMLBeans or dynamic table // TODO Check every element/namespace for compliance public PackagePart Unmarshall(UnmarshallContext context, Stream in1) { PackagePropertiesPart coreProps = new PackagePropertiesPart(context .Package, context.PartName); // If the input stream is null then we try to get it from the // package. if (in1 == null) { if (context.ZipEntry != null) { in1 = ((ZipPackage)context.Package).ZipArchive .GetInputStream(context.ZipEntry); } else if (context.Package != null) { // Try to retrieve the part inputstream from the URI ZipEntry zipEntry; try { zipEntry = ZipHelper .GetCorePropertiesZipEntry((ZipPackage)context .Package); } catch (OpenXml4NetException) { throw new IOException( "Error while trying to get the part input stream."); } in1 = ((ZipPackage)context.Package).ZipArchive .GetInputStream(zipEntry); } else { throw new IOException( "Error while trying to get the part input stream."); } } XmlDocument xmlDoc = null; try { xmlDoc = DocumentHelper.LoadDocument(in1); nsmgr = new XmlNamespaceManager(xmlDoc.NameTable); nsmgr.AddNamespace("cp", namespaceCP); nsmgr.AddNamespace("dc", namespaceDC); nsmgr.AddNamespace("dcterms", namespaceDcTerms); nsmgr.AddNamespace("xsi", namespaceXSI); nsmgr.AddNamespace("cml", PackageNamespaces.MARKUP_COMPATIBILITY); nsmgr.AddNamespace("dcmitype", PackageNamespaces.DCMITYPE); //xmlDoc.ReadNode(reader); //try { //xmlDoc = xmlReader.read(in1); /* Check OPC compliance */ // Rule M4.2, M4.3, M4.4 and M4.5/ CheckElementForOPCCompliance(xmlDoc.DocumentElement); /* End OPC compliance */ //} catch (DocumentException e) { // throw new IOException(e.getMessage()); //} } catch (XmlException ex) { throw new IOException(ex.Message, ex); } if (xmlDoc != null && xmlDoc.DocumentElement != null) { coreProps.SetCategoryProperty(LoadCategory(xmlDoc)); coreProps.SetContentStatusProperty(LoadContentStatus(xmlDoc)); coreProps.SetContentTypeProperty(LoadContentType(xmlDoc)); coreProps.SetCreatedProperty(LoadCreated(xmlDoc)); coreProps.SetCreatorProperty(LoadCreator(xmlDoc)); coreProps.SetDescriptionProperty(LoadDescription(xmlDoc)); coreProps.SetIdentifierProperty(LoadIdentifier(xmlDoc)); coreProps.SetKeywordsProperty(LoadKeywords(xmlDoc)); coreProps.SetLanguageProperty(LoadLanguage(xmlDoc)); coreProps.SetLastModifiedByProperty(LoadLastModifiedBy(xmlDoc)); coreProps.SetLastPrintedProperty(LoadLastPrinted(xmlDoc)); coreProps.SetModifiedProperty(LoadModified(xmlDoc)); coreProps.SetRevisionProperty(LoadRevision(xmlDoc)); coreProps.SetSubjectProperty(LoadSubject(xmlDoc)); coreProps.SetTitleProperty(LoadTitle(xmlDoc)); coreProps.SetVersionProperty(LoadVersion(xmlDoc)); } return(coreProps); }
/// <summary> /// Copies document(s). /// </summary> private void Copy(object parameter) { int nodeId = 0; int oldSiteId = 0; int newSiteId = 0; TreeNode node = null; // Process Action parameters string[] parameters = ValidationHelper.GetString(parameter, "False;False").Split(';'); if (parameters.Length != 2) { parameters = "False;False".Split(';'); } bool includeChildNodes = ValidationHelper.GetBoolean(parameters[0], false); bool copyPermissions = ValidationHelper.GetBoolean(parameters[1], false); ctlAsyncLog.Parameter = null; string siteName = CurrentSite.SiteName; AddLog(GetString("ContentRequest.StartCopy")); if (targetId == 0) { AddError(GetString("ContentRequest.ErrorMissingTarget")); return; } // Get target document TreeNode targetNode = TreeProvider.SelectSingleNode(targetId, TreeProvider.ALL_CULTURES); if (targetNode == null) { AddError(GetString("ContentRequest.ErrorMissingTarget")); return; } // No pages are allowed to be created under linked page. if (targetNode.IsLink) { AddError(GetString("contentrequest.errorlinkparent")); return; } try { PrepareNodeIdsForAllDocuments(siteName); if (DataHelper.DataSourceIsEmpty(documentsToProcess)) { // Create where condition string where = new WhereCondition().WhereIn("NodeID", nodeIds).ToString(true); string columns = SqlHelper.MergeColumns(DocumentColumnLists.SELECTNODES_REQUIRED_COLUMNS, "NodeAliasPath, ClassName, DocumentCulture"); documentsToProcess = TreeProvider.SelectNodes(siteName, "/%", TreeProvider.ALL_CULTURES, true, null, where, null, TreeProvider.ALL_LEVELS, false, 0, columns); } if (!DataHelper.DataSourceIsEmpty(documentsToProcess)) { foreach (DataRow nodeRow in documentsToProcess.Tables[0].Rows) { // Get the current document nodeId = ValidationHelper.GetInteger(nodeRow["NodeID"], 0); string className = nodeRow["ClassName"].ToString(); string aliasPath = nodeRow["NodeAliasPath"].ToString(); string docCulture = nodeRow["DocumentCulture"].ToString(); node = DocumentHelper.GetDocument(siteName, aliasPath, docCulture, false, className, null, null, TreeProvider.ALL_LEVELS, false, null, TreeProvider); if (node == null) { AddLog(string.Format(GetString("ContentRequest.DocumentNoLongerExists"), HTMLHelper.HTMLEncode(aliasPath))); continue; } oldSiteId = node.NodeSiteID; // Copy the document TreeNode copiedNode = CopyNode(node, targetNode, includeChildNodes, TreeProvider, copyPermissions); if (copiedNode != null) { node = copiedNode; } newSiteId = node.NodeSiteID; } } } catch (ThreadAbortException ex) { if (!CMSThread.Stopped(ex)) { // Try to get ID of site int siteId = (node != null) ? node.NodeSiteID : SiteContext.CurrentSiteID; // Log event to event log LogExceptionToEventLog("COPYDOC", "ContentRequest.CopyFailed", nodeId, ex, siteId); } } catch (Exception ex) { // Try to get ID of site int siteId = (node != null) ? node.NodeSiteID : SiteContext.CurrentSiteID; // Log event to event log LogExceptionToEventLog("COPYDOC", "ContentRequest.CopyFailed", nodeId, ex, siteId); HandlePossibleErrors(); } finally { if (multiple) { AddLog(GetString("ContentRequest.CopyOK")); ctlAsyncLog.Parameter = GetRefreshListingScript(); } else { // Set moved document in current site or parent node if copy to other site if (oldSiteId == newSiteId) { if (nodeId == 0) { // If processed node does not exist HandleNonExistentDocument(siteName); } else { // Process result if (node != null) { nodeId = (multiple ? nodeId : node.NodeID); ctlAsyncLog.Parameter = "SelectNode(" + nodeId + ");RefreshTree(" + targetId + ", " + nodeId + ");"; } else { AddError(GetString("ContentRequest.CopyFailed")); } } } else { AddLog(GetString("ContentRequest.CopyOK")); ctlAsyncLog.Parameter = string.Empty; } } } }
public void Should_Validate_Correctly_The_RUC() { Assert.IsTrue(DocumentHelper.IsValidDocument(DocumentHelper.TYPE_RUC, "1798288377001")); Assert.IsFalse(DocumentHelper.IsValidDocument(DocumentHelper.TYPE_RUC, "1798288377")); }
/// <summary> /// Links selected document(s). /// </summary> /// <param name="targetNodeId">Target node ID</param> /// <param name="sourceNodes">Nodes</param> /// <param name="performedAction">Action to be performed</param> /// <param name="copyPermissions">Indicates if the document permissions should be copied</param> private void Link(int targetNodeId, List <int> sourceNodes, Action performedAction, bool copyPermissions) { int nodeId = 0; int oldSiteId = 0; int newSiteId = 0; TreeNode node = null; string siteName = (performedAction == Action.LinkDoc) ? targetSite.SiteName : CurrentSite.SiteName; AddLog(GetString("ContentRequest.StartLink")); if (targetNodeId == 0) { AddError(GetString("ContentRequest.ErrorMissingTarget")); return; } // Check if allow child type TreeNode targetNode = TreeProvider.SelectSingleNode(targetNodeId, TreeProvider.ALL_CULTURES); if (targetNode == null) { AddError(GetString("ContentRequest.ErrorMissingTarget")); return; } // No pages are allowed to be created under linked page. if (targetNode.IsLink) { AddError(GetString("contentrequest.errorlinkparent")); return; } try { PrepareNodeIdsForAllDocuments(siteName); if (DataHelper.DataSourceIsEmpty(documentsToProcess)) { // Create where condition string where = new WhereCondition().WhereIn("NodeID", sourceNodes).ToString(true); string columns = SqlHelper.MergeColumns(DocumentColumnLists.SELECTNODES_REQUIRED_COLUMNS, "NodeParentID, DocumentName, NodeAliasPath, NodeLinkedNodeID"); documentsToProcess = TreeProvider.SelectNodes(siteName, "/%", TreeProvider.ALL_CULTURES, true, null, where, null, TreeProvider.ALL_LEVELS, false, 0, columns); } if (!DataHelper.DataSourceIsEmpty(documentsToProcess)) { foreach (DataRow nodeRow in documentsToProcess.Tables[0].Rows) { nodeId = ValidationHelper.GetInteger(nodeRow["NodeID"], 0); string className = nodeRow["ClassName"].ToString(); string aliasPath = nodeRow["NodeAliasPath"].ToString(); string docCulture = nodeRow["DocumentCulture"].ToString(); // Get document to link node = DocumentHelper.GetDocument(siteName, aliasPath, docCulture, false, className, null, null, TreeProvider.ALL_LEVELS, false, null, TreeProvider); if (node == null) { AddLog(string.Format(GetString("ContentRequest.DocumentNoLongerExists"), HTMLHelper.HTMLEncode(aliasPath))); continue; } oldSiteId = node.NodeSiteID; // Link the document TreeNode linkedNode = LinkNode(node, targetNode, TreeProvider, copyPermissions); if (linkedNode != null) { node = linkedNode; } newSiteId = node.NodeSiteID; } } } catch (ThreadAbortException ex) { if (!CMSThread.Stopped(ex)) { // Try to get ID of site int siteId = (node != null) ? node.NodeSiteID : SiteContext.CurrentSiteID; // Log event to event log LogExceptionToEventLog("LINKDOC", "ContentRequest.LinkFailed", nodeId, ex, siteId); } } catch (Exception ex) { // Try to get ID of site int siteId = (node != null) ? node.NodeSiteID : SiteContext.CurrentSiteID; // Log event to event log LogExceptionToEventLog("LINKDOC", "ContentRequest.LinkFailed", nodeId, ex, siteId); HandlePossibleErrors(); } finally { if (multiple) { AddLog(GetString("ContentRequest.LinkOK")); ctlAsyncLog.Parameter = GetRefreshListingScript(); } else { if (nodeId == 0) { // If processed node does not exist HandleNonExistentDocument(siteName); } else { // Set linked document in current site or parent node if linked to other site if (oldSiteId == newSiteId) { if (node == null) { AddError(GetString("ContentRequest.LinkFailed")); } } else { AddLog(GetString("ContentRequest.LinkOK")); } // Process result if (node != null) { ctlAsyncLog.Parameter = "SelectNode(" + targetNodeId + ");RefreshTree(" + targetNodeId + ", " + targetNodeId + ");"; } } } } }
public void Should_Validate_Correctly_The_CRCPF() { Assert.IsTrue(DocumentHelper.IsValidDocument(DocumentHelper.TYPE_CRCPF, "123485989")); Assert.IsFalse(DocumentHelper.IsValidDocument(DocumentHelper.TYPE_CRCPF, "12348598")); Assert.IsFalse(DocumentHelper.IsValidDocument(DocumentHelper.TYPE_CRCPF, "02348598")); }
/// <summary> /// Raises event postback event. /// </summary> /// <param name="eventArgument">Event argument</param> /// <param name="uniqueCode">Unique code</param> /// <param name="variantId">Variant ID</param> public void RaisePostBackEvent(string eventArgument, string uniqueCode, int variantId) { // Check permissions if (!CheckPermissions("Manage") || stopProcessing) { return; } // Get the argument string arg = eventArgument.ToLowerCSafe(); if (arg == "remove") { // Remove variant action int documentId = 0; if (VariantMode == VariantModeEnum.MVT) { // Is MVT zone => remove the MVT variant MVTVariantInfo variantObj = MVTVariantInfoProvider.GetMVTVariantInfo(variantId); if (variantObj != null) { // Delete the variant MVTVariantInfoProvider.DeleteMVTVariantInfo(variantObj); documentId = variantObj.MVTVariantDocumentID; } } else if (VariantMode == VariantModeEnum.ContentPersonalization) { // Is Content personalization zone => remove the Content personalization variant ContentPersonalizationVariantInfo variantObj = ContentPersonalizationVariantInfoProvider.GetContentPersonalizationVariant(variantId); if (variantObj != null) { // Delete the variant ContentPersonalizationVariantInfoProvider.DeleteContentPersonalizationVariant(variantObj); documentId = variantObj.VariantDocumentID; } } else { return; } // Log widget variant synchronization if (documentId > 0) { TreeProvider tree = new TreeProvider(MembershipContext.AuthenticatedUser); TreeNode node = DocumentHelper.GetDocument(documentId, tree); DocumentSynchronizationHelper.LogDocumentChange(node, TaskTypeEnum.UpdateDocument, tree); } switch (SliderMode) { // Remove zone variant case VariantTypeEnum.Zone: if ((WebPartZoneControl != null) && (WebPartZoneControl.ZoneInstance != null)) { // Remove the variant from WebPartZoneControl.ZoneInstance.ZoneInstanceVariants. // It is necessary to remove the variants from the PartInstanceVariants list manually because the PageLoad method has already run // and the PartInstanceVariants list was populated with the old values. WebPartZoneControl.RemoveVariantFromCache(variantId); } break; // Remove web part or widget variant case VariantTypeEnum.WebPart: case VariantTypeEnum.Widget: if ((WebPartControl != null) && (WebPartControl.PartInstance != null)) { // Remove the variant from WebPartControls.PartInstance.PartInstanceVariants. // It is necessary to remove the variants from the PartInstanceVariants list manually because the PageLoad method has already run // and the PartInstanceVariants list was populated with the old values. WebPartControl.RemoveVariantFromCache(variantId); // If there are no other variants present, set the VariantMode to None to allow refreshing the add variant buttons. if ((WebPartControl.PartInstance.PartInstanceVariants == null) || (WebPartControl.PartInstance.PartInstanceVariants.Count == 0)) { mVariantMode = VariantModeEnum.None; } } break; default: break; } // Refresh the variant slider position => choose the last variant ltrScript.Text = ScriptHelper.GetScript( @"cpVariantSliderPositionElem = GetCPVariantSliderPositionElem(); UpdateVariantPosition('" + uniqueCode + @"', '-1'); SaveSlidersConfiguration();"); } }
/// <summary> /// Creates document. /// </summary> public int Save() { // Validate input data string message = new Validator().NotEmpty(txtDocumentName.Text.Trim(), GetString("om.enterdocumentname")).Result; if (message != String.Empty) { ShowError(message); return(0); } if (mNode == null) { ShowError(GetString("general.invalidparameters")); return(0); } // Select parent node TreeNode parent = mTree.SelectSingleNode(SiteContext.CurrentSiteName, ucPath.Value.ToString(), TreeProvider.ALL_CULTURES, false, null, false); if (parent == null) { ShowError(GetString("om.pathdoesnotexists")); return(0); } // Check security if (!MembershipContext.AuthenticatedUser.IsAuthorizedToCreateNewDocument(parent.NodeID, mNode.NodeClassName)) { RedirectToAccessDenied(GetString("cmsdesk.notauthorizedtocreatedocument")); return(0); } var newDocument = ProcessAction(mNode, parent, "copynode", false, true, true); if (newDocument == null) { ShowError(string.Format(GetString("om.invalidchildtype"), parent.ClassName)); return(0); } // Get all language translations var documents = DocumentHelper.GetDocuments() .All() .OnCurrentSite() .AllCultures() .WhereEquals("NodeID", newDocument.NodeID); // Limit length to 100 characters string documentName = TextHelper.LimitLength(txtDocumentName.Text.Trim(), 100, String.Empty); // Update all documents and delete all aliases foreach (var document in documents) { UpdateDocument(document, documentName); DocumentAliasInfoProvider.DeleteNodeAliases(document.NodeID); // Set new node to any updated document to have updated info newDocument = document; } // Create new AB variant if AB test defined if (!CreateABVariant(newDocument)) { return(0); } // Get the page mode if (PortalContext.ViewMode != ViewModeEnum.EditLive) { PortalContext.ViewMode = ViewModeEnum.EditForm; } txtDocumentName.Text = String.Empty; return(newDocument.NodeID); }
/// <summary> /// Returns a query that selects published pages of type Song. /// </summary> public static DocumentQuery <Song> GetSongs() { return(DocumentHelper.GetDocuments <Song>().PublishedVersion().Published()); }
/// <summary> /// Copy documents section. /// </summary> /// <param name="source">Source document</param> /// <param name="target">Target document</param> /// <param name="tree">Tree provider</param> private void CopyDocumentSection(TreeNode source, TreeNode target, TreeProvider tree) { DocumentHelper.CopyDocument(source, target, true, tree); }
private void ReloadData() { if (StopProcessing) { // Do nothing gridDocs.StopProcessing = true; editDoc.StopProcessing = true; } else { if (((AllowUsers == UserContributionAllowUserEnum.Authenticated) || (AllowUsers == UserContributionAllowUserEnum.DocumentOwner)) && !AuthenticationHelper.IsAuthenticated()) { // Not authenticated, do not display anything pnlList.Visible = false; pnlEdit.Visible = false; StopProcessing = true; } else { SetContext(); // Hide document list gridDocs.Visible = false; // If the list of documents should be displayed ... if (DisplayList) { // Get all documents of the current user TreeProvider tree = new TreeProvider(MembershipContext.AuthenticatedUser); // Generate additional where condition WhereCondition condition = new WhereCondition(WhereCondition); if (!String.IsNullOrEmpty(ClassNames)) { condition.WhereIn("ClassName", ClassNames.Split(new[] { ";" }, StringSplitOptions.RemoveEmptyEntries)); } // Add user condition if (AllowUsers == UserContributionAllowUserEnum.DocumentOwner) { condition.WhereEquals("NodeOwner", MembershipContext.AuthenticatedUser.UserID); } // Get the documents var query = DocumentHelper.GetDocuments() .OnSite(SiteName) .Path(MacroResolver.ResolveCurrentPath(Path)) .Where(condition) .OrderBy(OrderBy) .Published(SelectOnlyPublished) .NestingLevel(MaxRelativeLevel) .CheckPermissions(CheckPermissions); TreeProvider.SetQueryCultures(query, CultureCode, CombineWithDefaultCulture); // Do not apply published from / to columns to make sure the published information is correctly evaluated query.Properties.ExcludedVersionedColumns = new[] { "DocumentPublishFrom", "DocumentPublishTo" }; var ds = query.Result; if (!DataHelper.DataSourceIsEmpty(ds)) { // Display and initialize grid if datasource is not empty gridDocs.Visible = true; gridDocs.DataSource = ds; gridDocs.OrderBy = OrderBy; editDoc.AlternativeFormName = AlternativeFormName; } } bool isAuthorizedToCreateDoc = false; if (ParentNode != null) { // Check if single class name is set string className = (!string.IsNullOrEmpty(AllowedChildClasses) && !AllowedChildClasses.Contains(";")) ? AllowedChildClasses : null; // Check user's permission to create new document if allowed isAuthorizedToCreateDoc = !CheckPermissions || MembershipContext.AuthenticatedUser.IsAuthorizedToCreateNewDocument(ParentNodeID, className); // Check group's permission to create new document if allowed isAuthorizedToCreateDoc &= CheckGroupPermission("createpages"); if (!CheckDocPermissionsForInsert && CheckPermissions) { // If document permissions are not required check create permission on parent document isAuthorizedToCreateDoc = MembershipContext.AuthenticatedUser.IsAuthorizedPerDocument(ParentNode, NodePermissionsEnum.Create) == AuthorizationResultEnum.Allowed; } if (AllowUsers == UserContributionAllowUserEnum.DocumentOwner) { if (VirtualContext.ReadonlyMode) { isAuthorizedToCreateDoc = false; } else { // Check if user is document owner (or global admin) isAuthorizedToCreateDoc = isAuthorizedToCreateDoc && ((ParentNode.NodeOwner == MembershipContext.AuthenticatedUser.UserID) || MembershipContext.AuthenticatedUser.CheckPrivilegeLevel(UserPrivilegeLevelEnum.Admin)); } } } // Enable/disable inserting new document pnlNewDoc.Visible = (isAuthorizedToCreateDoc && AllowInsert); if (!gridDocs.Visible && !pnlNewDoc.Visible && pnlList.Visible) { // Not authenticated to create new docs and grid is hidden StopProcessing = true; } ReleaseContext(); } } }
/// <summary> /// Process additional department tasks. /// </summary> public void ProcessDepartment(object sender, EventArgs e) { TreeNode editedNode = Form.EditedObject as TreeNode; // Get department template source document TreeNode sourceNode = DocumentHelper.GetDocument(SiteContext.CurrentSiteName, DepartmentTemplatePath, null, true, null, null, null, TreeProvider.ALL_LEVELS, false, null, TreeProvider); // Copy relevant template data to department document. Proceed only when creating a department, updating a department must not rewrite its data with template's data. if (Form.IsInsertMode && (sourceNode != null)) { var excludeColumns = new [] { "DocumentName", "NodeAlias", "DocumentTagGroupID", "DocumentStylesheetID", "DocumentPublishFrom", "DocumentPublishTo" }; DocumentHelper.CopyNodeData(sourceNode, editedNode, new CopyNodeDataSettings(true, true, false, true, true, false, false, false, excludeColumns)); DocumentHelper.UpdateDocument(editedNode, TreeProvider); } #region "Create department tag group" // Get tag group info TagGroupInfo tgi = TagGroupInfoProvider.GetTagGroupInfo(editedNode.DocumentTagGroupID); // If not exist, create new tag group and set it to document if (tgi == null) { // Populate tag group info fields tgi = new TagGroupInfo(); tgi.TagGroupDisplayName = editedNode.GetDocumentName(); tgi.TagGroupName = editedNode.NodeGUID.ToString(); tgi.TagGroupDescription = ""; tgi.TagGroupSiteID = SiteContext.CurrentSiteID; tgi.TagGroupIsAdHoc = false; // Store tag group info to DB TagGroupInfoProvider.SetTagGroupInfo(tgi); // Update document Tag group ID editedNode.DocumentTagGroupID = tgi.TagGroupID; DocumentHelper.UpdateDocument(editedNode, TreeProvider); } #endregion if (!DataHelper.DataSourceIsEmpty(TemplateDocuments)) { // List of selected documents string selectedDocs = ";" + Value + ";"; // Get already created documents under edited document DataSet dsExistingDocs = DocumentHelper.GetDocuments(SiteContext.CurrentSiteName, editedNode.NodeAliasPath + "/%", editedNode.DocumentCulture, true, null, null, null, 1, false, 0, "NodeAlias, " + DocumentColumnLists.SELECTNODES_REQUIRED_COLUMNS, null); StringBuilder sbExistDocs = new StringBuilder(); // Process existing documents to obtain list of aliases foreach (DataRow drExistDoc in dsExistingDocs.Tables[0].Rows) { sbExistDocs.Append(";"); sbExistDocs.Append(drExistDoc["NodeAlias"].ToString().ToLowerCSafe()); } sbExistDocs.Append(";"); string existingDocs = sbExistDocs.ToString(); // Set same ordering as for original template documents bool orgUseAutomaticOrdering = TreeProvider.UseAutomaticOrdering; TreeProvider.UseAutomaticOrdering = false; // Process template documents foreach (DataRow drDoc in TemplateDocuments.Tables[0].Rows) { if (DocumentHelper.IsDocumentTypeAllowed(editedNode, ValidationHelper.GetInteger(drDoc["NodeClassID"], 0))) { string nodeAlias = drDoc["NodeAlias"].ToString().ToLowerCSafe(); string contNodeAlias = ";" + nodeAlias + ";"; // Set marks bool existing = existingDocs.Contains(contNodeAlias); bool selected = selectedDocs.Contains(contNodeAlias); int nodeId = ValidationHelper.GetInteger(drDoc["NodeID"], 0); string docCulture = ValidationHelper.GetString(drDoc["DocumentCulture"], ""); TreeNode srcNode = DocumentHelper.GetDocument(nodeId, docCulture, editedNode.TreeProvider); // Check if section exists if (srcNode != null) { // Copy or remove marked document sections if (selected) { if (!existing) { CopyDocumentSection(srcNode, editedNode, TreeProvider); } } else { if (existing) { // Select node to delete var aliasPath = editedNode.NodeAliasPath + "/" + nodeAlias; var combineWithDefaultCulture = SettingsKeyInfoProvider.GetBoolValue(SiteContext.CurrentSiteName + ".CMSCombineWithDefaultCulture"); TreeProvider tree = new TreeProvider(MembershipContext.AuthenticatedUser); TreeNode delNode = tree.SelectSingleNode(SiteContext.CurrentSiteName, aliasPath, LocalizationContext.PreferredCultureCode, combineWithDefaultCulture); if (delNode != null) { DeleteDocumentSection(delNode, TreeProvider); } } } // Process additional operations if (selected && !existing) { switch (nodeAlias) { // Create department forum case FORUM_DOCUMENT_ALIAS: CreateDepartmentForumGroup(editedNode); CreateDepartmentForumSearchIndex(editedNode); break; // Create media library case MEDIA_DOCUMENT_ALIAS: CreateDepartmentMediaLibrary(editedNode); break; } } } } } // Set previous ordering TreeProvider.UseAutomaticOrdering = orgUseAutomaticOrdering; } mDocumentSaved = true; }
/// <summary> /// Returns a query that selects published pages of type LandingPage. /// </summary> public static DocumentQuery <LandingPage> GetLandingPages() { return(DocumentHelper.GetDocuments <LandingPage>().PublishedVersion().Published()); }
protected void Page_Load(object sender, EventArgs e) { const string CONTENT_CMSDESK_FOLDER = "~/CMSModules/Content/CMSDesk/"; // Register script files ScriptHelper.RegisterScriptFile(this, CONTENT_CMSDESK_FOLDER + "EditTabs.js"); bool checkCulture = false; bool splitViewSupported = false; string action = QueryHelper.GetString("action", "edit").ToLowerCSafe(); switch (action) { // New dialog / new page form case "new": int classId = QueryHelper.GetInteger("classid", 0); if (classId <= 0) { // Get by class name if specified string className = QueryHelper.GetString("classname", string.Empty); if (className != string.Empty) { classInfo = DataClassInfoProvider.GetDataClassInfo(className); if (classInfo != null) { classId = classInfo.ClassID; } } } const string EC_PRODUCTS_FOLDER = "~/CMSModules/Ecommerce/Pages/Tools/Products/"; if (classId > 0) { viewpage = ResolveUrl(CONTENT_CMSDESK_FOLDER + "Edit/Edit.aspx"); // Check if document type is allowed under parent node if (parentNodeID > 0) { // Get the node TreeNode = Tree.SelectSingleNode(parentNodeID, TreeProvider.ALL_CULTURES); if (TreeNode != null) { if (!DocumentHelper.IsDocumentTypeAllowed(TreeNode, classId)) { viewpage = CONTENT_CMSDESK_FOLDER + "NotAllowed.aspx?action=child"; } } } // Use product page when product type is selected classInfo = classInfo ?? DataClassInfoProvider.GetDataClassInfo(classId); if ((classInfo != null) && (classInfo.ClassIsProduct)) { viewpage = ResolveUrl(EC_PRODUCTS_FOLDER + "Product_New.aspx"); } } else { if (parentNodeID > 0) { viewpage = EC_PRODUCTS_FOLDER + "New_ProductOrSection.aspx"; } else { viewpage = EC_PRODUCTS_FOLDER + "Product_New.aspx?parentNodeId=0"; } } break; case "delete": // Delete dialog viewpage = CONTENT_CMSDESK_FOLDER + "Delete.aspx"; break; default: // Edit mode viewpage = CONTENT_CMSDESK_FOLDER + "Edit/edit.aspx?mode=editform"; splitViewSupported = true; // Ensure class info if ((classInfo == null) && (Node != null)) { classInfo = DataClassInfoProvider.GetDataClassInfo(Node.NodeClassName); } // Check explicit editing page url if ((classInfo != null) && !string.IsNullOrEmpty(classInfo.ClassEditingPageURL)) { viewpage = URLHelper.AppendQuery(ResolveUrl(classInfo.ClassEditingPageURL), RequestContext.CurrentQueryString); } checkCulture = true; break; } // If culture version should be checked, check if (checkCulture) { // Check (and ensure) the proper content culture if (!CheckPreferredCulture()) { RefreshParentWindow(); } // Check split mode bool isSplitMode = PortalUIHelper.DisplaySplitMode; bool combineWithDefaultCulture = !isSplitMode && SiteInfoProvider.CombineWithDefaultCulture(SiteContext.CurrentSiteName); var nodeId = QueryHelper.GetInteger("nodeid", 0); TreeNode = Tree.SelectSingleNode(nodeId, CultureCode, combineWithDefaultCulture); if (TreeNode == null) { // Document does not exist -> redirect to new culture version creation dialog viewpage = ProductUIHelper.GetNewCultureVersionPageUrl(); } } // Apply the additional transformations to the view page URL viewpage = URLHelper.AppendQuery(viewpage, RequestContext.CurrentQueryString); viewpage = URLHelper.RemoveParameterFromUrl(viewpage, "mode"); viewpage = URLHelper.AddParameterToUrl(viewpage, "mode", "productssection"); viewpage = ResolveUrl(viewpage); viewpage = URLHelper.AddParameterToUrl(viewpage, "hash", QueryHelper.GetHash(viewpage)); // Split mode enabled if (splitViewSupported && PortalUIHelper.DisplaySplitMode && (TreeNode != null) && (action == "edit" || action == "preview" || (TreeNode.IsPublished && action == "livesite"))) { viewpage = DocumentUIHelper.GetSplitViewUrl(viewpage); } URLHelper.Redirect(UrlResolver.ResolveUrl(viewpage)); }
private void PublishAndFinish(object parameter) { TreeNode node = null; Tree.AllowAsyncActions = false; CanceledString = ResHelper.GetString("content.publishcanceled", currentCulture); try { // Begin log AddLog(ResHelper.GetString("content.preparingdocuments", currentCulture)); // Get the documents DataSet documents = GetDocumentsToProcess(); if (!DataHelper.DataSourceIsEmpty(documents)) { // Create instance of workflow manager class WorkflowManager wm = new WorkflowManager(Tree); // Begin publishing AddLog(ResHelper.GetString("content.publishingdocuments", currentCulture)); 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 = ValidationHelper.GetString(nodeRow["SiteName"], string.Empty); node = DocumentHelper.GetDocument(siteName, aliasPath, docCulture, false, className, null, null, -1, false, null, Tree); // Publish document if (!Publish(node, wm)) { // Add log record AddLog(HTMLHelper.HTMLEncode(node.NodeAliasPath + " (" + node.GetValue("DocumentCulture") + ")")); } else { AddLog(string.Format(ResHelper.GetString("content.publishedalready"), HTMLHelper.HTMLEncode(node.NodeAliasPath + " (" + node.GetValue("DocumentCulture") + ")"))); } } } CurrentInfo = GetString("workflowdocuments.publishcomplete"); } else { AddError(ResHelper.GetString("content.nothingtopublish", currentCulture)); } } catch (ThreadAbortException ex) { string state = ValidationHelper.GetString(ex.ExceptionState, string.Empty); if (state == CMSThread.ABORT_REASON_STOP) { // When canceled CurrentInfo = CanceledString; } else { int siteId = (node != null) ? node.NodeSiteID : CMSContext.CurrentSiteID; // Log error LogExceptionToEventLog("PUBLISHDOC", "content.publishfailed", ex, siteId); } } catch (Exception ex) { int siteId = (node != null) ? node.NodeSiteID : CMSContext.CurrentSiteID; // Log error LogExceptionToEventLog("PUBLISHDOC", "content.publishfailed", ex, siteId); } }