public TextContentController(TextContentManager textContentManager, TextFolderManager textFolderManager,
     WorkflowManager workflowManager, ITextContentBinder binder)
 {
     TextContentManager = textContentManager;
     TextFolderManager = textFolderManager;
     WorkflowManager = workflowManager;
     Binder = binder;
 }
    /// <summary>
    /// Refresh button click event handler.
    /// </summary>
    protected void btnRefresh_Click(object sender, EventArgs e)
    {
        if (treeNode != null)
        {
            // Check permission to modify document
            if (CMSContext.CurrentUser.IsAuthorizedPerDocument(treeNode, NodePermissionsEnum.Modify) == AuthorizationResultEnum.Allowed)
            {
                // Get curent step
                WorkflowManager wm = new WorkflowManager(tree);
                WorkflowStepInfo currentStep = wm.GetStepInfo(treeNode);
                string currentStepName = currentStep.StepName.ToLower();
                bool wasArchived = currentStepName == "archived";

                // Move to edit step
                DocumentHelper.MoveDocumentToEditStep(treeNode, tree);

                // Refresh frames and tree
                string script = "if(window.FramesRefresh){FramesRefresh(" + wasArchived.ToString().ToLower() + ", " + treeNode.NodeID + ");}";
                ScriptHelper.RegisterStartupScript(this, typeof(string), "refreshAction", ScriptHelper.GetScript(script));
            }
        }
    }
Exemple #3
0
 public RoadTestScheduledState(WorkflowManager manager)
     : base(manager, WorkflowStates.RoadTestScheduled)
 {
 }
 public void GetUserTasks()
 {
     RequestContext.Current.Add<UserContext>("UserContext", new UserContext { UserId = 1, LanguageId = 1, UserName = "******", SiteId = 1 });
     WorkflowManager workflowManager = new WorkflowManager();
     List<UserTask> tasks = workflowManager.GetUserTasks(ContextEnum.None, null, null, null, true);
 }
 /// <summary>
 /// ContentManager
 /// </summary>
 public ContentManager()
 {
     _securityManager = new SecurityManager();
     _workflowManager = new WorkflowManager();
 }
Exemple #6
0
    protected void Page_Load(object sender, EventArgs e)
    {
        // Switch the view mode
        CMSContext.ViewMode = ViewModeEnum.Preview;

        // Get the document
        int nodeId = 0;
        if (Request.QueryString["nodeid"] != null)
        {
            nodeId = ValidationHelper.GetInteger(Request.QueryString["nodeid"], 0);
        }

        string siteName = CMSContext.CurrentSiteName;
        TreeProvider tree = new TreeProvider(CMSContext.CurrentUser);
        TreeNode node = null;

        // Check split mode
        bool isSplitMode = CMSContext.DisplaySplitMode;
        bool combineWithDefaultCulture = isSplitMode ? false : SiteInfoProvider.CombineWithDefaultCulture(siteName);

        // Get the document
        node = tree.SelectSingleNode(nodeId, CMSContext.PreferredCultureCode, combineWithDefaultCulture);

        // Redirect to the live URL
        if (node != null)
        {
            // If no workflow defined, hide the menu bar
            WorkflowManager wm = new WorkflowManager(tree);
            WorkflowInfo wi = wm.GetNodeWorkflow(node);
            if (wi == null)
            {
                headersize = "0";
            }
            else
            {
                // Get current step info
                WorkflowStepInfo si = wm.GetStepInfo(node);
                if (si != null)
                {
                    switch (si.StepName.ToLower())
                    {
                        case "published":
                        case "archived":
                            headersize = "0";
                            break;
                    }
                }
            }

            // Check the document availability
            if (!node.DocumentCulture.Equals(CMSContext.PreferredCultureCode, StringComparison.InvariantCultureIgnoreCase) && (!SiteInfoProvider.CombineWithDefaultCulture(siteName) || !node.DocumentCulture.Equals(CultureHelper.GetDefaultCulture(siteName), StringComparison.InvariantCultureIgnoreCase)))
            {
                viewpage = "~/CMSMessages/PageNotAvailable.aspx?reason=missingculture";
            }
            else
            {
                // Use permanent URL to get proper preview mode
                viewpage = URLRewriter.GetEditingUrl(node);
            }
        }
        else
        {
            viewpage = isSplitMode ? "~/CMSModules/Content/CMSDesk/New/NewCultureVersion.aspx" + URLHelper.Url.Query : "~/CMSMessages/PageNotAvailable.aspx?reason=missingculture&showlink=false";
        }

        // Register synchronization script for split mode
        if (isSplitMode)
        {
            RegisterSplitModeSync(false, false);
        }

        viewpage = ResolveUrl(viewpage);
    }
    /// <summary>
    /// Publishes document.
    /// </summary>
    /// <param name="node">Node to publish</param>
    /// <param name="wm">Workflow manager</param>
    /// <param name="currentStep">Current workflow step</param>
    /// <returns>TRUE if operation fails</returns>
    private bool Publish(TreeNode node, WorkflowManager wm, WorkflowStepInfo currentStep)
    {
        string pathCulture = HTMLHelper.HTMLEncode(node.NodeAliasPath + " (" + node.DocumentCulture + ")");

        bool alreadyPublished = (currentStep == null) || currentStep.StepIsPublished;
        if (!alreadyPublished)
        {
            // Publish document
            currentStep = wm.PublishDocument(node, null);
        }

        // Document is already published, check if still under workflow
        if (alreadyPublished && (currentStep != null) && currentStep.StepIsPublished)
        {
            WorkflowScopeInfo wsi = wm.GetNodeWorkflowScope(node);
            if (wsi == null)
            {
                DocumentHelper.ClearWorkflowInformation(node);
                VersionManager vm = VersionManager.GetInstance(node.TreeProvider);
                vm.RemoveWorkflow(node);
            }
        }

        // Document already published
        if (alreadyPublished)
        {
            AddLog(string.Format(ResHelper.GetString("content.publishedalready"), pathCulture));
        }
        else if (!currentStep.StepIsPublished)
        {
            AddError(string.Format(ResHelper.GetString("content.PublishWasApproved"), pathCulture));
            return true;
        }
        else
        {
            // Add log record
            AddLog(pathCulture);
        }

        return false;
    }
 public KnowledgeTestScheduledState(WorkflowManager manager)
     : base(manager, WorkflowStates.KnowledgeTestScheduled)
 {
 }
Exemple #9
0
    protected void btnOk_Click(object sender, EventArgs e)
    {
        // Check allowed cultures
        if (!CMSContext.CurrentUser.IsCultureAllowed(CMSContext.PreferredCultureCode, CMSContext.CurrentSiteName))
        {
            lblError.Text = GetString("Content.NotAuthorizedFile");
            pnlForm.Visible = false;
            return;
        }

        TreeNode node = null;
        TreeProvider tree = new TreeProvider(CMSContext.CurrentUser);

        if ((UseFileUploader && !FileUpload.HasFile) || (!UseFileUploader && !ucDirectUploader.HasData()))
        {
            lblError.Text = GetString("NewFile.ErrorEmpty");
        }
        else
        {
            // Get file extension
            string fileExtension = UseFileUploader ? FileUpload.FileName : ucDirectUploader.AttachmentName;
            fileExtension = Path.GetExtension(fileExtension).TrimStart('.');

            // Check file extension
            if (IsExtensionAllowed(fileExtension))
            {
                bool newDocumentCreated = false;

                try
                {
                    if (UseFileUploader)
                    {
                        // Process file using file upload
                        node = ProcessFileUploader(tree);
                    }
                    else
                    {
                        // Process file using direct uploader
                        node = ProcessDirectUploader(tree);

                        // Save temporary attachments
                        DocumentHelper.SaveTemporaryAttachments(node, Guid, CMSContext.CurrentSiteName, tree);
                    }

                    newDocumentCreated = true;

                    // Create default SKU if configured
                    if (ModuleEntry.CheckModuleLicense(ModuleEntry.ECOMMERCE, URLHelper.GetCurrentDomain(), FeatureEnum.Ecommerce, VersionActionEnum.Insert))
                    {
                        bool? skuCreated = node.CreateDefaultSKU();
                        if (skuCreated.HasValue && !skuCreated.Value)
                        {
                            lblError.Text = GetString("com.CreateDefaultSKU.Error");
                        }
                    }

                    // Set additional values
                    if (!string.IsNullOrEmpty(fileExtension))
                    {
                        // Update document extensions if no custom are used
                        if (!node.DocumentUseCustomExtensions)
                        {
                            node.DocumentExtensions = "." + fileExtension;
                        }
                        node.SetValue("DocumentType", "." + fileExtension);
                    }

                    // Update the document
                    DocumentHelper.UpdateDocument(node, tree);

                    WorkflowManager workflowManager = new WorkflowManager(tree);
                    // Get workflow info
                    WorkflowInfo workflowInfo = workflowManager.GetNodeWorkflow(node);

                    // Check if auto publish changes is allowed
                    if ((workflowInfo != null) && workflowInfo.WorkflowAutoPublishChanges && !workflowInfo.UseCheckInCheckOut(CMSContext.CurrentSiteName))
                    {
                        // Automatically publish document
                        workflowManager.AutomaticallyPublish(node, workflowInfo, null);
                    }

                    bool createAnother = ValidationHelper.GetBoolean(Request.Params["hidAnother"], false);

                    // Added from CMSDesk->Content
                    if (!isDialog)
                    {
                        if (createAnother)
                        {
                            ltlScript.Text += ScriptHelper.GetScript("PassiveRefresh(" + node.NodeParentID + ", " + node.NodeParentID + "); CreateAnother();");
                        }
                        else
                        {
                            ltlScript.Text += ScriptHelper.GetScript(
                                "   RefreshTree(" + node.NodeID + ", " + node.NodeID + "); SelectNode(" + node.NodeID + "); \n"
                            );
                        }
                    }
                    // Added from dialog window
                    else
                    {
                        if (createAnother)
                        {
                            txtFileDescription.Text = "";
                            ltlScript.Text += ScriptHelper.GetScript("FileCreated(" + node.NodeID + ", " + node.NodeParentID + ", false);");
                        }
                        else
                        {
                            ltlScript.Text += ScriptHelper.GetScript("FileCreated(" + node.NodeID + ", " + node.NodeParentID + ", true);");
                        }
                    }
                }
                catch (Exception ex)
                {
                    // Delete the document if something failed
                    if (newDocumentCreated && (node != null) && (node.DocumentID > 0))
                    {
                        DocumentHelper.DeleteDocument(node, tree, false, true, true);
                    }
                    lblError.Text = GetString("NewFile.Failed") + ": " + ex.Message;
                }
            }
            else
            {
                lblError.Text = String.Format(GetString("NewFile.ExtensionNotAllowed"), fileExtension);
            }
        }
    }
Exemple #10
0
    protected void Page_Load(object sender, EventArgs e)
    {
        #region 接收参数

        // TaskID
        bool bIsValid = PageCommon.ValidateQueryString(this, "TaskID", QueryStringType.ID);
        if (bIsValid == false)
        {
            this.Response.Write("{\"ExecResult\":\"Failed\",\"ErrorMsg\":\"Missing required query string.\"}");
            return;
        }
        string sTaskID = this.Request.QueryString["TaskID"].ToString();
        int    iTaskID = Convert.ToInt32(sTaskID);

        // LoanID
        bIsValid = PageCommon.ValidateQueryString(this, "LoanID", QueryStringType.ID);
        if (bIsValid == false)
        {
            this.Response.Write("{\"ExecResult\":\"Failed\",\"ErrorMsg\":\"Missing required query string.\"}");
            return;
        }
        string sLoanID = this.Request.QueryString["LoanID"].ToString();
        int    iLoanID = Convert.ToInt32(sLoanID);

        #endregion

        // json示例
        // {"ExecResult":"Success","ErrorMsg":"","EmailTemplateID":"1", "LoanClosed":"Yes"}
        // {"ExecResult":"Failed","ErrorMsg":"执行数据库脚本时发生错误。"}

        string sErrorMsg        = string.Empty;
        string sEmailTemplateID = string.Empty;
        bool   bIsSuccess       = false;
        string LoanClosed       = "No";
        var    result           = "";
        try
        {
            #region complete task

            int iEmailTemplateId = 0;
            bIsSuccess = LPWeb.DAL.WorkflowManager.CompleteTask(iTaskID, this.CurrUser.iUserID, ref iEmailTemplateId);

            if (bIsSuccess == false)
            {
                sErrorMsg = "Failed to invoke WorkflowManager.CompleteTask.";
                return;
            }

            if (iEmailTemplateId != 0)
            {
                sEmailTemplateID = iEmailTemplateId.ToString();
            }

            #endregion

            #region update point file stage

            int iLoanStageID = 0;

            #region get loan task info

            LoanTasks LoanTaskManager = new LoanTasks();
            DataTable LoanTaskInfo    = LoanTaskManager.GetLoanTaskInfo(iTaskID);
            if (LoanTaskInfo.Rows.Count == 0)
            {
                bIsSuccess = false;
                sErrorMsg  = "Invalid task id.";
                return;
            }
            string sLoanStageID = LoanTaskInfo.Rows[0]["LoanStageId"].ToString();
            if (sLoanStageID == string.Empty)
            {
                bIsSuccess = false;
                sErrorMsg  = "Invalid loan stage id.";
                return;
            }
            iLoanStageID = Convert.ToInt32(sLoanStageID);

            #endregion
            bIsSuccess = true;
            if (!WorkflowManager.StageCompleted(iLoanStageID))
            {
                sErrorMsg = "Completed task successfully.";
                return;
            }

            #region invoke PointManager.UpdateStage()

            //add by  gdc 20111212  Bug #1306
            LPWeb.BLL.PointFiles pfile = new PointFiles();
            var model = pfile.GetModel(iLoanID);
            if (model != null && !string.IsNullOrEmpty(model.Name.Trim()))
            {
                #region check Point File Status first
                ServiceManager sm = new ServiceManager();
                using (LP2ServiceClient service = sm.StartServiceClient())
                {
                    CheckPointFileStatusReq checkFileReq = new CheckPointFileStatusReq();
                    checkFileReq.hdr               = new ReqHdr();
                    checkFileReq.hdr.UserId        = CurrUser.iUserID;
                    checkFileReq.hdr.SecurityToken = "SecurityToken";
                    checkFileReq.FileId            = iLoanID;
                    CheckPointFileStatusResp checkFileResp = service.CheckPointFileStatus(checkFileReq);
                    if (checkFileResp == null || checkFileResp.hdr == null || !checkFileResp.hdr.Successful)
                    {
                        sErrorMsg = "Unable to get Point file status from Point Manager.";
                        WorkflowManager.UnCompleteTask(iTaskID, CurrUser.iUserID);
                        bIsSuccess = false;
                        return;
                    }
                    if (checkFileResp.FileLocked)
                    {
                        sErrorMsg = checkFileResp.hdr.StatusInfo;
                        WorkflowManager.UnCompleteTask(iTaskID, CurrUser.iUserID);
                        bIsSuccess = false;
                        return;
                    }
                }
                #endregion
                #region UPdatePointFileStage  WCF
                string sError = LoanTaskCommon.UpdatePointFileStage(iLoanID, this.CurrUser.iUserID, iLoanStageID);

                // the last one, sleep 1 second
                System.Threading.Thread.Sleep(1000);

                if (sError == string.Empty) // success
                {
                    sErrorMsg = "Completed task successfully.";
                }
                else
                {
                    sErrorMsg = "Completed task successfully but failed to update stage date in Point.";
                    //sErrorMsg = "Failed to update point file stage: " + sError.Replace("\"", "\\\"");
                }
                #endregion
            }
            if (WorkflowManager.IsLoanClosed(iLoanID))
            {
                LoanClosed = "Yes";
            }
            return;

            #endregion
        }
        catch (System.ServiceModel.EndpointNotFoundException ee)
        {
            sErrorMsg = "Completed task successfully but failed to update stage date in Point.";
            return;
        }
        catch (Exception ex)
        {
            if (bIsSuccess)
            {
                sErrorMsg = "Completed task successfully but encountered an error:" + ex.Message;
            }
            else
            {
                sErrorMsg = "Failed to complete task, reason:" + ex.Message;
            }
            //sErrorMsg = "Exception happened when invoke WorkflowManager.CompleteTask: " + ex.ToString().Replace("\"", "\\\"");
            bIsSuccess = false;
            return;
        }
        finally
        {
            if (bIsSuccess)
            {
                result = "{\"ExecResult\":\"Success\",\"ErrorMsg\":\"" + sErrorMsg + "\",\"EmailTemplateID\":\"" + sEmailTemplateID + "\",\"TaskID\":\"" + sTaskID + "\",\"LoanClosed\":\"" + LoanClosed + "\"}";
            }
            //result = "{\"ExecResult\":\"Success\",\"ErrorMsg\":\"\",\"EmailTemplateID\":\"" + sEmailTemplateID + "\",\"LoanClosed\":\"" + LoanClosed + "\"}";
            else
            {
                result = "{\"ExecResult\":\"Failed\",\"ErrorMsg\":\"" + sErrorMsg + "\"}";
            }
            this.Response.Write(result);
        }

        #endregion
    }
Exemple #11
0
 public PracticalScheduledState(WorkflowManager manager)
     : base(manager, WorkflowStates.PracticalScheduled)
 {
 }
    /// <summary>
    /// Provides operations necessary to create and store new attachment.
    /// </summary>
    private void HandleAttachmentUpload(bool fieldAttachment)
    {
        TreeProvider tree = null;
        TreeNode node = null;

        // New attachment
        AttachmentInfo newAttachment = null;

        string message = string.Empty;
        bool fullRefresh = false;

        try
        {
            // Get the existing document
            if (DocumentID != 0)
            {
                // Get document
                tree = new TreeProvider(CMSContext.CurrentUser);
                node = DocumentHelper.GetDocument(DocumentID, tree);
                if (node == null)
                {
                    throw new Exception("Given document doesn't exist!");
                }
            }

            #region "Check permissions"

            if (this.CheckPermissions)
            {
                CheckNodePermissions(node);
            }

            #endregion

            // Check the allowed extensions
            CheckAllowedExtensions();

            // Standard attachments
            if (DocumentID != 0)
            {
                // Ensure automatic check-in/check-out
                bool useWorkflow = false;
                bool autoCheck = false;
                WorkflowManager workflowMan = new WorkflowManager(tree);
                VersionManager vm = null;

                // Get workflow info
                WorkflowInfo wi = workflowMan.GetNodeWorkflow(node);

                // Check if the document uses workflow
                if (wi != null)
                {
                    useWorkflow = true;
                    autoCheck = !wi.UseCheckInCheckOut(CMSContext.CurrentSiteName);
                }

                // Check out the document
                if (autoCheck)
                {
                    // Get original step Id
                    int originalStepId = node.DocumentWorkflowStepID;

                    // Get current step info
                    WorkflowStepInfo si = workflowMan.GetStepInfo(node);
                    if (si != null)
                    {
                        // Decide if full refresh is needed
                        bool automaticPublish = wi.WorkflowAutoPublishChanges;
                        string stepName = si.StepName.ToLower();
                        // Document is published or archived or uses automatic publish or step is different than original (document was updated)
                        fullRefresh = (stepName == "published") || (stepName == "archived") || (automaticPublish && (stepName != "published")) || (originalStepId != node.DocumentWorkflowStepID);
                    }

                    vm = new VersionManager(tree);
                    vm.CheckOut(node, node.IsPublished, true);
                }

                // Handle field attachment
                if (fieldAttachment)
                {
                    newAttachment = DocumentHelper.AddAttachment(node, AttachmentGUIDColumnName, Guid.Empty, Guid.Empty, ucFileUpload.PostedFile, tree, ResizeToWidth, ResizeToHeight, ResizeToMaxSideSize);
                    // Update attachment field
                    DocumentHelper.UpdateDocument(node, tree);
                }
                // Handle grouped and unsorted attachments
                else
                {
                    // Grouped attachment
                    if (AttachmentGroupGUID != Guid.Empty)
                    {
                        newAttachment = DocumentHelper.AddGroupedAttachment(node, AttachmentGUID, AttachmentGroupGUID, ucFileUpload.PostedFile, tree, ResizeToWidth, ResizeToHeight, ResizeToMaxSideSize);
                    }
                    // Unsorted attachment
                    else
                    {
                        newAttachment = DocumentHelper.AddUnsortedAttachment(node, AttachmentGUID, ucFileUpload.PostedFile, tree, ResizeToWidth, ResizeToHeight, ResizeToMaxSideSize);
                    }
                }

                // Check in the document
                if (autoCheck)
                {
                    if (vm != null)
                    {
                        vm.CheckIn(node, null, null);
                    }
                }

                // Log synchronization task if not under workflow
                if (!useWorkflow)
                {
                    DocumentSynchronizationHelper.LogDocumentChange(node, TaskTypeEnum.UpdateDocument, tree);
                }
            }

            // Temporary attachments
            if (FormGUID != Guid.Empty)
            {
                newAttachment = AttachmentManager.AddTemporaryAttachment(FormGUID, AttachmentGUIDColumnName, AttachmentGUID, AttachmentGroupGUID, ucFileUpload.PostedFile, CMSContext.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)
        {
            message = ex.Message;
            lblError.Text = message;
        }
        finally
        {
            // Call aftersave javascript if exists
            if ((string.IsNullOrEmpty(message)) && (newAttachment != null))
            {
                string closeString = "window.close();";
                // Register wopener script
                ScriptHelper.RegisterWOpenerScript(Page);

                if (!String.IsNullOrEmpty(AfterSaveJavascript))
                {
                    string url = null;
                    string saveName = URLHelper.GetSafeFileName(newAttachment.AttachmentName, CMSContext.CurrentSiteName);
                    if (node != null)
                    {
                        SiteInfo si = SiteInfoProvider.GetSiteInfo(node.NodeSiteID);
                        if (si != null)
                        {
                            bool usePermanent = SettingsKeyProvider.GetBoolValue(si.SiteName + ".CMSUsePermanentURLs");
                            if (usePermanent)
                            {
                                url = ResolveUrl(AttachmentManager.GetAttachmentUrl(newAttachment.AttachmentGUID, saveName));
                            }
                            else
                            {
                                url = ResolveUrl(AttachmentManager.GetAttachmentUrl(saveName, node.NodeAliasPath));
                            }
                        }
                    }
                    else
                    {
                        url = ResolveUrl(AttachmentManager.GetAttachmentUrl(newAttachment.AttachmentGUID, saveName));
                    }
                    // Calling javascript function with parameters attachments url, name, width, height
                    string jsParams = "('" + url + "', '" + newAttachment.AttachmentName + "', '" + newAttachment.AttachmentImageWidth + "', '" + newAttachment.AttachmentImageHeight + "');";
                    string script = "if ((wopener.parent != null) && (wopener.parent." + AfterSaveJavascript + " != null)){wopener.parent." + AfterSaveJavascript + jsParams + "}";
                    script += "else if (wopener." + AfterSaveJavascript + " != null){wopener." + AfterSaveJavascript + jsParams + "}";

                    ScriptHelper.RegisterStartupScript(this.Page, typeof(Page), "refreshAfterSave", ScriptHelper.GetScript(script + closeString));
                }

                // Create attachment info string
                string attachmentInfo = "";
                if ((newAttachment != null) && (newAttachment.AttachmentGUID != Guid.Empty) && (this.IncludeNewItemInfo))
                {
                    attachmentInfo = newAttachment.AttachmentGUID.ToString();
                }

                // Ensure message text
                message = HTMLHelper.EnsureLineEnding(message, " ");

                // Call function to refresh parent window
                ScriptHelper.RegisterStartupScript(this.Page, typeof(Page), "refresh", ScriptHelper.GetScript("if ((wopener.parent != null) && (wopener.parent.InitRefresh_" + ParentElemID + " != null)){wopener.parent.InitRefresh_" + ParentElemID + "(" + ScriptHelper.GetString(message.Trim()) + ", " + (fullRefresh ? "true" : "false") + ", false" + ((attachmentInfo != "") ? ", '" + attachmentInfo + "'" : "") + (InsertMode ? ", 'insert'" : ", 'update'") + ");}" + closeString));
            }
        }
    }
    /// <summary>
    /// Provides operations necessary to create and store new content file.
    /// </summary>
    private void HandleContentUpload()
    {
        TreeNode node = null;
        TreeProvider tree = null;

        string message = string.Empty;
        bool newDocumentCreated = false;

        try
        {
            if (this.NodeParentNodeID == 0)
            {
                throw new Exception(GetString("dialogs.document.parentmissing"));
            }

            // Check license limitations
            if (!LicenseHelper.LicenseVersionCheck(URLHelper.GetCurrentDomain(), FeatureEnum.Documents, VersionActionEnum.Insert))
            {
                throw new Exception(GetString("cmsdesk.documentslicenselimits"));
            }

            // Check if class exists
            DataClassInfo ci = DataClassInfoProvider.GetDataClass("CMS.File");
            if (ci == null)
            {
                throw new Exception("Class 'CMS.File' not found.");
            }

            #region "Check permissions"

            // Get the node
            tree = new TreeProvider(CMSContext.CurrentUser);
            TreeNode parentNode = tree.SelectSingleNode(this.NodeParentNodeID, TreeProvider.ALL_CULTURES);
            if (parentNode != null)
            {
                if (!DataClassInfoProvider.IsChildClassAllowed(ValidationHelper.GetInteger(parentNode.GetValue("NodeClassID"), 0), ci.ClassID))
                {
                    throw new Exception(GetString("Content.ChildClassNotAllowed"));
                }
            }

            // Check user permissions
            if (!RaiseOnCheckPermissions("Create", this))
            {
                if (!CMSContext.CurrentUser.IsAuthorizedToCreateNewDocument(NodeParentNodeID, NodeClassName))
                {
                    throw new Exception("You aren not allowed to create document of type '" + NodeClassName + "' in required location.");
                }
            }

            #endregion

            // Check the allowed extensions
            CheckAllowedExtensions();

            // Create new document
            string fileName = Path.GetFileNameWithoutExtension(ucFileUpload.FileName);

            node = TreeNode.New("CMS.File", tree);
            node.DocumentCulture = CMSContext.PreferredCultureCode;
            node.DocumentName = fileName;

            // Load default values
            FormHelper.LoadDefaultValues(node);

            node.SetValue("FileDescription", "");
            node.SetValue("FileName", fileName);
            node.SetValue("FileAttachment", Guid.Empty);

            // Set default template ID
            node.DocumentPageTemplateID = ci.ClassDefaultPageTemplateID;

            // Insert the document
            DocumentHelper.InsertDocument(node, parentNode, tree);

            newDocumentCreated = true;

            // Add the file
            DocumentHelper.AddAttachment(node, "FileAttachment", ucFileUpload.PostedFile, tree, this.ResizeToWidth, this.ResizeToHeight, this.ResizeToMaxSideSize);

            // Create default SKU if configured
            if (ModuleEntry.CheckModuleLicense(ModuleEntry.ECOMMERCE, URLHelper.GetCurrentDomain(), FeatureEnum.Ecommerce, VersionActionEnum.Insert))
            {
                node.CreateDefaultSKU();
            }

            // Update the document
            DocumentHelper.UpdateDocument(node, tree);

            WorkflowManager workflowManager = new WorkflowManager(tree);
            // Get workflow info
            WorkflowInfo workflowInfo = workflowManager.GetNodeWorkflow(node);

            // Check if auto publish changes is allowed
            if ((workflowInfo != null) && workflowInfo.WorkflowAutoPublishChanges && !workflowInfo.UseCheckInCheckOut(CMSContext.CurrentSiteName))
            {
                // Automatically publish document
                workflowManager.AutomaticallyPublish(node, workflowInfo, null);
            }
        }
        catch (Exception ex)
        {
            // Delete the document if something failed
            if (newDocumentCreated && (node != null) && (node.DocumentID > 0))
            {
                DocumentHelper.DeleteDocument(node, tree, false, true, true);
            }

            message = ex.Message;
            lblError.Text = message;
        }
        finally
        {
            if (string.IsNullOrEmpty(message))
            {
                // Create node info string
                string nodeInfo = "";
                if ((node != null) && (node.NodeID > 0) && (this.IncludeNewItemInfo))
                {
                    nodeInfo = node.NodeID.ToString();
                }

                // Ensure message text
                message = HTMLHelper.EnsureLineEnding(message, " ");

                // Register wopener script
                ScriptHelper.RegisterWOpenerScript(Page);

                // Call function to refresh parent window
                ScriptHelper.RegisterStartupScript(this.Page, typeof(Page), "refresh", ScriptHelper.GetScript("if ((wopener.parent != null) && (wopener.parent.InitRefresh_" + ParentElemID + " != null)){wopener.parent.InitRefresh_" + ParentElemID + "(" + ScriptHelper.GetString(message.Trim()) + ", false, false" + ((nodeInfo != "") ? ", '" + nodeInfo + "'" : "") + (InsertMode ? ", 'insert'" : ", 'update'") + ");}window.close();"));
            }
        }
    }
    protected DataSet gridAttachments_OnDataReload(string completeWhere, string currentOrder, int currentTopN, string columns, int currentOffset, int currentPageSize, ref int totalRecords)
    {
        string where = null;
        Guid attachmentFormGUID = Guid.Empty;
        string whereCondition = GetWhereConditionInternal();
        int documentVersionHistoryID = UsesWorkflow ? VersionHistoryID : 0;

        // Grouped attachments
        if (GroupGUID != Guid.Empty)
        {
            // Combine where conditions
            where = String.Format("(AttachmentGroupGUID='{0}')", GroupGUID);
        }
        // Unsorted attachments
        else
        {
            where = "(AttachmentIsUnsorted = 1)";
        }

        // Temporary attachments
        if ((attachmentFormGUID != Guid.Empty) && (documentVersionHistoryID == 0))
        {
            where += String.Format(" AND (AttachmentFormGUID='{0}')", FormGUID);
        }
        // Else document attachments
        else
        {
            if (documentVersionHistoryID == 0)
            {
                // Ensure current site name
                if (string.IsNullOrEmpty(SiteName))
                {
                    SiteName = CMSContext.CurrentSiteName;
                }

                if (Node != null)
                {
                    where += String.Format(" AND (AttachmentDocumentID = {0})", Node.DocumentID);

                    // Get attachments for latest version if not live site
                    if (!IsLiveSite)
                    {
                        WorkflowManager wm = new WorkflowManager(TreeProvider);
                        WorkflowInfo wi = wm.GetNodeWorkflow(Node);
                        if (wi != null)
                        {
                            documentVersionHistoryID = Node.DocumentCheckedOutVersionHistoryID;
                        }
                    }
                }
                else
                {
                    return null;
                }
            }
        }

        // Ensure additional where condition
        whereCondition = SqlHelperClass.AddWhereCondition(whereCondition, where);

        // Ensure [AttachmentID] column
        List<String> cols = new List<string>(columns.Split(new char[] { ',', ';' }));
        if (!cols.Contains("AttachmentID") && !cols.Contains("[AttachmentID]"))
        {
            columns = SqlHelperClass.MergeColumns("AttachmentID", columns);
        }

        DataSet ds = null;

        // Get attachments for published document
        if (documentVersionHistoryID == 0)
        {
            currentOrder = "AttachmentOrder, AttachmentName, AttachmentID";
            ds = AttachmentManager.GetAttachments(whereCondition, currentOrder, true, currentTopN, columns);
        }
        else
        {
            currentOrder = "AttachmentOrder, AttachmentName, AttachmentHistoryID";

            VersionManager vm = new VersionManager(TreeProvider);
            ds = vm.GetVersionAttachments(documentVersionHistoryID, whereCondition, currentOrder, true, currentTopN, columns.Replace("AttachmentID", "AttachmentHistoryID"));
        }

        // Ensure consistent ID column name
        if (!DataHelper.DataSourceIsEmpty(ds))
        {
            ds.Tables[0].Columns[0].ColumnName = "AttachmentID";
        }

        return ds;
    }
    /// <summary>
    /// Publishes document(s).
    /// </summary>
    private void PublishAll(object parameter)
    {
        if (parameter == null)
        {
            return;
        }

        TreeProvider tree = new TreeProvider(currentUser);
        tree.AllowAsyncActions = false;

        try
        {
            // Begin log
            AddLog(ResHelper.GetString("content.publishingdocuments", currentCulture));

            string[] parameters = ((string)parameter).Split(';');

            string siteName = parameters[1];

            // Get identifiers
            int[] workNodes = nodeIds.ToArray();

            // Prepare the where condition
            string where = SqlHelperClass.GetWhereCondition("NodeID", workNodes);
            string columns = SqlHelperClass.MergeColumns(TreeProvider.SELECTNODES_REQUIRED_COLUMNS, "NodeAliasPath, ClassName, DocumentCulture");

            // Get cultures
            string cultureCode = chkAllCultures.Checked ? TreeProvider.ALL_CULTURES : parameters[0];

            // Get the documents
            DataSet documents = tree.SelectNodes(siteName, "/%", cultureCode, false, null, where, "NodeAliasPath DESC", TreeProvider.ALL_LEVELS, false, 0, columns);

            // Create instance of workflow manager class
            WorkflowManager wm = new WorkflowManager(tree);

            if (!DataHelper.DataSourceIsEmpty(documents))
            {
                foreach (DataRow nodeRow in documents.Tables[0].Rows)
                {
                    // Get the current document
                    TreeNode node = GetDocument(tree, siteName, nodeRow);

                    // Publish document
                    if (PerformPublish(wm, tree, siteName, nodeRow))
                    {
                        return;
                    }

                    // Process underlying documents
                    if (chkUnderlying.Checked && (node.NodeChildNodesCount > 0))
                    {
                        if (PublishSubDocuments(node, tree, wm, cultureCode, siteName))
                        {
                            return;
                        }
                    }
                }
            }
            else
            {
                AddError(ResHelper.GetString("content.nothingtopublish", currentCulture));
            }
        }
        catch (ThreadAbortException ex)
        {
            string state = ValidationHelper.GetString(ex.ExceptionState, string.Empty);
            if (state != CMSThread.ABORT_REASON_STOP)
            {
                // Log error
                LogExceptionToEventLog(ResHelper.GetString("content.publishfailed", currentCulture), ex);
            }
        }
        catch (Exception ex)
        {
            // Log error
            LogExceptionToEventLog(ResHelper.GetString("content.publishfailed", currentCulture), ex);
        }
    }
    /// <summary>
    /// Publishes document.
    /// </summary>
    /// <param name="node">Node to publish</param>
    /// <param name="wm">Workflow manager</param>
    /// <param name="currentStep">Current workflow step</param>
    /// <returns>Whether node is already published</returns>
    private static bool Publish(TreeNode node, WorkflowManager wm, WorkflowStepInfo currentStep)
    {
        bool toReturn = true;
        if (currentStep != null)
        {
            // For archive step start new version
            if (currentStep.StepName.ToLower() == "archived")
            {
                VersionManager vm = new VersionManager(node.TreeProvider);
                currentStep = vm.CheckOut(node, node.IsPublished, true);
                vm.CheckIn(node, null, null);
            }

            // Approve until the step is publish
            while ((currentStep != null) && (currentStep.StepName.ToLower() != "published"))
            {
                currentStep = wm.MoveToNextStep(node, string.Empty);
                toReturn = false;
            }

            // Document is already published, check if still under workflow
            if (toReturn && (currentStep.StepName.ToLower() == "published"))
            {
                WorkflowScopeInfo wsi = wm.GetNodeWorkflowScope(node);
                if (wsi == null)
                {
                    DocumentHelper.ClearWorkflowInformation(node);
                    VersionManager vm = new VersionManager(node.TreeProvider);
                    vm.RemoveWorkflow(node);
                }
            }
        }

        return toReturn;
    }
Exemple #17
0
    /// <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
        {
            AttachmentInfo attachmentInfo = InfoObject as AttachmentInfo;

            if (attachmentInfo != null)
            {
                // Set new file name
                if (!string.IsNullOrEmpty(newFileName))
                {
                    string name = newFileName + attachmentInfo.AttachmentExtension;

                    // Use correct identifier if attachment is under workflow
                    int identifier = VersionHistoryID > 0 ? AttachmentHistoryID : attachmentInfo.AttachmentID;

                    if (IsAttachmentNameUnique(identifier, attachmentInfo.AttachmentExtension, name))
                    {
                        attachmentInfo.AttachmentName = name;
                    }
                    else
                    {
                        // Attachment already exists.
                        ShowError(GetString("img.errors.fileexists"));
                        return(false);
                    }
                }

                // Ensure automatic check-in/ check-out
                bool            useWorkflow = false;
                bool            autoCheck   = false;
                WorkflowManager workflowMan = WorkflowManager.GetInstance(TreeProvider);

                if (!nodeIsParent && (Node != null))
                {
                    // Get workflow info
                    WorkflowInfo wi = workflowMan.GetNodeWorkflow(Node);

                    // Check if the document uses workflow
                    if (wi != null)
                    {
                        useWorkflow = true;
                        autoCheck   = !wi.UseCheckInCheckOut(SiteName);
                    }

                    // Check out the document
                    if (autoCheck)
                    {
                        VersionManager.CheckOut(Node, Node.IsPublished, true);
                        VersionHistoryID = Node.DocumentCheckedOutVersionHistoryID;
                    }

                    // Workflow has been lost, get published attachment
                    if (useWorkflow && (VersionHistoryID == 0))
                    {
                        attachmentInfo = AttachmentInfoProvider.GetAttachmentInfo(attachmentInfo.AttachmentGUID, SiteName);
                    }
                }

                if (attachmentInfo != null)
                {
                    // Set filename title and description
                    attachmentInfo.AttachmentTitle       = ObjectTitle;
                    attachmentInfo.AttachmentDescription = ObjectDescription;

                    // Document uses workflow and document is already saved (attachment is not temporary)
                    if (!nodeIsParent && (VersionHistoryID > 0))
                    {
                        attachmentInfo.AllowPartialUpdate = true;
                        VersionManager.SaveAttachmentVersion(attachmentInfo, VersionHistoryID);
                    }
                    else
                    {
                        // Update without binary
                        attachmentInfo.AllowPartialUpdate = true;
                        AttachmentInfoProvider.SetAttachmentInfo(attachmentInfo);

                        // Log the synchronization and search task for the document
                        if (!nodeIsParent && (Node != null))
                        {
                            // Update search index for given document
                            if (DocumentHelper.IsSearchTaskCreationAllowed(Node))
                            {
                                SearchTaskInfoProvider.CreateTask(SearchTaskTypeEnum.Update, TreeNode.OBJECT_TYPE, SearchFieldsConstants.ID, Node.GetSearchID(), Node.DocumentID);
                            }

                            DocumentSynchronizationHelper.LogDocumentChange(Node, TaskTypeEnum.UpdateDocument, TreeProvider);
                        }
                    }

                    if (!nodeIsParent && (Node != null))
                    {
                        // Check in the document
                        if (autoCheck)
                        {
                            if (VersionManager != null)
                            {
                                if (VersionHistoryID > 0 && (Node != null))
                                {
                                    VersionManager.CheckIn(Node, null, null);
                                }
                            }
                        }
                    }

                    saved = true;

                    string fullRefresh = "false";

                    if (autoCheck || (Node == null))
                    {
                        fullRefresh = "true";
                    }

                    // Refresh parent update panel
                    LtlScript.Text = ScriptHelper.GetScript("RefreshMetaData(" + ScriptHelper.GetString(ExternalControlID) + ", '" + fullRefresh + "', '" + attachmentInfo.AttachmentGUID + "', 'refresh')");
                }
            }
        }
        catch (Exception ex)
        {
            ShowError(GetString("metadata.errors.processing"));
            EventLogProvider.LogException("Metadata editor", "SAVEATTACHMENT", ex);
        }

        return(saved);
    }
Exemple #18
0
        /// <summary>
        /// Provides operations necessary to create and store new attachment.
        /// </summary>
        /// <param name="args">Upload arguments.</param>
        /// <param name="context">HttpContext instance.</param>
        private void HandleAttachmentUpload(UploaderHelper args, HttpContext context)
        {
            AttachmentInfo newAttachment = null;
            bool           refreshTree   = false;

            try
            {
                args.IsExtensionAllowed();

                // Get existing document
                if (args.AttachmentArgs.DocumentID != 0)
                {
                    node = DocumentHelper.GetDocument(args.AttachmentArgs.DocumentID, TreeProvider);
                    if (node == null)
                    {
                        throw new Exception("Given document doesn't exist!");
                    }
                    else
                    {
                        #region "Check permissions"

                        // For new document
                        if (args.AttachmentArgs.FormGuid != Guid.Empty)
                        {
                            if (args.AttachmentArgs.ParentNodeID == 0)
                            {
                                throw new Exception(ResHelper.GetString("attach.document.parentmissing"));
                            }

                            if (!CMSContext.CurrentUser.IsAuthorizedToCreateNewDocument(args.AttachmentArgs.ParentNodeID, args.AttachmentArgs.NodeClassName))
                            {
                                throw new Exception(ResHelper.GetString("attach.actiondenied"));
                            }
                        }
                        // For existing document
                        else if (args.AttachmentArgs.DocumentID > 0)
                        {
                            if (CMSContext.CurrentUser.IsAuthorizedPerDocument(node, NodePermissionsEnum.Modify) == AuthorizationResultEnum.Denied)
                            {
                                throw new Exception(ResHelper.GetString("attach.actiondenied"));
                            }
                        }

                        #endregion


                        args.IsExtensionAllowed();

                        // Check out the document
                        if (AutoCheck && args.IsLastUpload)
                        {
                            // Get current step info
                            WorkflowStepInfo si = WorkflowManager.GetStepInfo(node);
                            if (si != null)
                            {
                                // Decide if full refresh is needed
                                args.FullRefresh = si.StepIsPublished || si.StepIsArchived;
                            }

                            VersionManager.CheckOut(node, node.IsPublished, true);
                        }

                        // Handle field attachment
                        if (args.AttachmentArgs.FieldAttachment)
                        {
                            // Extension of CMS file before saving
                            string oldExtension = node.DocumentType;

                            newAttachment = DocumentHelper.AddAttachment(node, args.AttachmentArgs.AttachmentGuidColumnName, Guid.Empty, Guid.Empty, args.FilePath, TreeProvider, args.ResizeToWidth, args.ResizeToHeight, args.ResizeToMaxSide);
                            DocumentHelper.UpdateDocument(node, TreeProvider);

                            // Different extension
                            if ((oldExtension != null) && !oldExtension.EqualsCSafe(node.DocumentType, true))
                            {
                                refreshTree = true;
                            }
                        }
                        else
                        {
                            // Handle grouped and unsorted attachments
                            if (args.AttachmentArgs.AttachmentGroupGuid != Guid.Empty)
                            {
                                // Grouped attachment
                                newAttachment = DocumentHelper.AddGroupedAttachment(node, args.AttachmentArgs.AttachmentGUID, args.AttachmentArgs.AttachmentGroupGuid, args.FilePath, TreeProvider, args.ResizeToWidth, args.ResizeToHeight, args.ResizeToMaxSide);
                            }
                            else
                            {
                                // Unsorted attachment
                                newAttachment = DocumentHelper.AddUnsortedAttachment(node, args.AttachmentArgs.AttachmentGUID, args.FilePath, TreeProvider, args.ResizeToWidth, args.ResizeToHeight, args.ResizeToMaxSide);
                            }

                            // Log synchronization task if not under workflow
                            if (wi == null)
                            {
                                DocumentSynchronizationHelper.LogDocumentChange(node, TaskTypeEnum.UpdateDocument, TreeProvider);
                            }
                        }

                        // Check in the document
                        if (AutoCheck)
                        {
                            VersionManager.CheckIn(node, null, null);
                        }
                    }
                }
                else if (args.AttachmentArgs.FormGuid != Guid.Empty)
                {
                    newAttachment = AttachmentInfoProvider.AddTemporaryAttachment(args.AttachmentArgs.FormGuid, args.AttachmentArgs.AttachmentGuidColumnName, args.AttachmentArgs.AttachmentGUID, args.AttachmentArgs.AttachmentGroupGuid, args.FilePath, CMSContext.CurrentSiteID, args.ResizeToWidth, args.ResizeToHeight, args.ResizeToMaxSide);
                }

                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);

                // Store exception message
                args.Message = ex.Message;
            }
            finally
            {
                // Call after save javascript if exists
                if (!string.IsNullOrEmpty(args.AfterSaveJavascript))
                {
                    if ((args.Message == string.Empty) && (newAttachment != null))
                    {
                        string url      = null;
                        string saveName = URLHelper.GetSafeFileName(newAttachment.AttachmentName, CMSContext.CurrentSiteName);
                        if (node != null)
                        {
                            SiteInfo si = SiteInfoProvider.GetSiteInfo(node.NodeSiteID);
                            if (si != null)
                            {
                                url = SettingsKeyProvider.GetBoolValue(si.SiteName + ".CMSUsePermanentURLs") ?
                                      URLHelper.ResolveUrl(AttachmentInfoProvider.GetAttachmentUrl(newAttachment.AttachmentGUID, saveName))
                                    : URLHelper.ResolveUrl(AttachmentInfoProvider.GetAttachmentUrl(saveName, node.NodeAliasPath));
                            }
                        }
                        else
                        {
                            url = URLHelper.ResolveUrl(AttachmentInfoProvider.GetAttachmentUrl(newAttachment.AttachmentGUID, saveName));
                        }

                        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.IsFlash(newAttachment.AttachmentExtension))
                        {
                            obj[DialogParameters.OBJECT_TYPE]  = "flash";
                            obj[DialogParameters.FLASH_URL]    = url;
                            obj[DialogParameters.FLASH_EXT]    = newAttachment.AttachmentExtension;
                            obj[DialogParameters.FLASH_TITLE]  = newAttachment.AttachmentName;
                            obj[DialogParameters.FLASH_WIDTH]  = DEFAULT_OBJECT_WIDTH;
                            obj[DialogParameters.FLASH_HEIGHT] = DEFAULT_OBJECT_HEIGHT;
                        }
                        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
                        args.AfterScript += 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);
                        }}", args.AfterSaveJavascript, url, newAttachment.AttachmentName, newAttachment.AttachmentImageWidth, newAttachment.AttachmentImageHeight, CMSDialogHelper.GetDialogItem(obj));
                    }
                    else
                    {
                        args.AfterScript += ScriptHelper.GetAlertScript(args.Message, false);
                    }
                }

                // Create attachment info string
                string attachmentInfo = ((newAttachment != null) && (newAttachment.AttachmentGUID != Guid.Empty) && (args.IncludeNewItemInfo)) ? String.Format("'{0}', ", newAttachment.AttachmentGUID) : "";

                // Create after script and return it to the silverlight application, this script will be evaluated by the SL application in the end
                args.AfterScript += string.Format(@"
                if (window.InitRefresh_{0})
                {{
                    window.InitRefresh_{0}('{1}', {2}, {3}, {4});
                }}
                else {{ 
                    if ('{1}' != '') {{
                        alert('{1}');
                    }}
                }}",
                                                  args.ParentElementID,
                                                  ScriptHelper.GetString(args.Message.Trim(), false),
                                                  args.FullRefresh.ToString().ToLowerCSafe(),
                                                  refreshTree.ToString().ToLowerCSafe(),
                                                  attachmentInfo + (args.IsInsertMode ? "'insert'" : "'update'"));

                args.AddEventTargetPostbackReference();
                context.Response.Write(args.AfterScript);
                context.Response.Flush();
            }
        }
Exemple #19
0
    protected void Page_Load(object sender, EventArgs e)
    {
        #region 检查必要参数

        string sErrorJs = string.Empty;
        if (this.Request.QueryString["CloseDialogCodes"] == null)
        {
            sErrorJs = "window.parent.RefreshPage();";
        }
        else
        {
            sErrorJs = this.Request.QueryString["CloseDialogCodes"] + ";";
        }

        bool bIsValid = PageCommon.ValidateQueryString(this, "LoanID", QueryStringType.ID);
        if (bIsValid == false)
        {
            PageCommon.RegisterJsMsg(this, "Missing required query string.", sErrorJs);
            return;
        }

        this.iLoanID = Convert.ToInt32(this.Request.QueryString["LoanID"]);

        #endregion

        #region 校验LoanId

        DataTable LoanInfo = this.LoanManager.GetLoanInfo(this.iLoanID);
        if (LoanInfo.Rows.Count == 0)
        {
            PageCommon.RegisterJsMsg(this, "Invalid required query string.", sErrorJs);
            return;
        }

        // 存储Loan.EstCloseDate
        if (LoanInfo.Rows[0]["EstCloseDate"] != DBNull.Value)
        {
            this.hdnEstCloseDate.Value = Convert.ToDateTime(LoanInfo.Rows[0]["EstCloseDate"]).ToString("MM/dd/yyyy");
        }

        this.iCurrentLoanStageId = WorkflowManager.GetCurrentLoanStageId(this.iLoanID);

        bIsValid = PageCommon.ValidateQueryString(this, "Stage", QueryStringType.ID);
        if (bIsValid == true)
        {
            int    iout   = 0;
            string sStage = this.Request.QueryString["Stage"];
            if (Int32.TryParse(sStage, out iout))
            {
                this.iCurrentLoanStageId = iout;
            }
        }

        #endregion

        if (this.IsPostBack == false)
        {
            #region 加载Owner

            DataTable OwnerList = this.LoanTaskManager.GetLoanTaskOwers(this.iLoanID);

            DataRow EmptyOwnerRow = OwnerList.NewRow();
            EmptyOwnerRow["UserID"]   = 0;
            EmptyOwnerRow["FullName"] = "-- select --";
            OwnerList.Rows.InsertAt(EmptyOwnerRow, 0);

            this.ddlOwner.DataSource = OwnerList;
            this.ddlOwner.DataBind();

            // 绑定Owner
            this.ddlOwner.SelectedValue = this.CurrUser.iUserID.ToString();

            #endregion

            #region 加载ddlTaskList for TaskNaem

            LeadTaskList LeadTaskListMgr = new LeadTaskList();

            string sOrderBy = string.Empty;
            if (this.CurrUser.SortTaskPickList == "S")
            {
                sOrderBy = "SequenceNumber";
            }
            else
            {
                sOrderBy = "TaskName";
            }

            DataTable LeadTaskList1 = LeadTaskListMgr.GetLeadTaskList(" and Enabled=1", sOrderBy);

            DataRow EmptyTaskRow = LeadTaskList1.NewRow();
            EmptyTaskRow["TaskName"] = "-- select --";
            LeadTaskList1.Rows.InsertAt(EmptyTaskRow, 0);

            this.ddlTaskList.DataSource = LeadTaskList1;
            this.ddlTaskList.DataBind();

            #endregion

            // set default value
            this.txtDueDate.Text = DateTime.Now.ToString("MM/dd/yyyy");
            //this.txtDueTime.Text = DateTime.Now.AddMinutes(15).ToShortTimeString();
            this.ddlDueTime_hour.SelectedValue = DateTime.Now.Hour.ToString("00");
            this.ddlDueTime_min.SelectedValue  = (DateTime.Now.AddMinutes(15).Minute / 5 * 5).ToString();

            #region 加载Prerequisite

            DataTable PrerequisiteList    = this.LoanTaskManager.GetPrerequisiteList(" and FileID=" + this.iLoanID + " and LoanStageId = " + iCurrentLoanStageId + " and PrerequisiteTaskId is null");
            DataRow   NonePrerequisiteRow = PrerequisiteList.NewRow();
            NonePrerequisiteRow["LoanTaskId"] = 0;
            NonePrerequisiteRow["Name"]       = "None";
            PrerequisiteList.Rows.InsertAt(NonePrerequisiteRow, 0);

            this.ddlPrerequisite.DataSource = PrerequisiteList;
            this.ddlPrerequisite.DataBind();

            this.ddlPrerequisite2.DataSource = PrerequisiteList;
            this.ddlPrerequisite2.DataBind();

            #endregion

            #region 加载email template

            Template_Email EmailTempManager = new Template_Email();
            DataTable      EmailTemplates   = EmailTempManager.GetEmailTemplate(" and Enabled = 1");

            DataRow NoneEmailTemplateRow = EmailTemplates.NewRow();
            NoneEmailTemplateRow["TemplEmailId"] = 0;
            NoneEmailTemplateRow["Name"]         = "None";
            EmailTemplates.Rows.InsertAt(NoneEmailTemplateRow, 0);

            this.ddlWarningEmail.DataSource = EmailTemplates;
            this.ddlWarningEmail.DataBind();

            this.ddlOverdueEmail.DataSource = EmailTemplates;
            this.ddlOverdueEmail.DataBind();

            this.ddlEmailTemplate.DataSource = EmailTemplates;
            this.ddlEmailTemplate.DataBind();

            #endregion

            #region completion email list

            gridCompletetionEmails.DataSource = null;
            gridCompletetionEmails.DataBind();

            #endregion


            #region Stage

            //Template_Stages stage = new Template_Stages();
            //var dtStage = stage.GetStageTemplateList(" And [Enabled] = 1 order by  SequenceNumber ");

            LoanStages ls      = new LoanStages();
            var        dtStage = ls.GetLoanStageSetupInfo(iLoanID);

            ddlStage.DataSource = dtStage;
            ddlStage.DataBind();

            ddlStage.SelectedValue = this.iCurrentLoanStageId.ToString();
            #endregion
        }
    }
Exemple #20
0
        protected void btnSave_Click(object sender, EventArgs e)
        {
            Model.ProspectTasks prospectTasks = null;
            if ("0" == Mode)
            {
                prospectTasks = new Model.ProspectTasks();
                GetValue(ref prospectTasks);

                // check duplicate
                if (ptManager.IsProspectTaskNameExists(-1, prospectTasks.TaskName))
                {
                    PageCommon.AlertMsg(this, "Duplicate task name.");
                    return;
                }

                try
                {
                    // save the new added prospect task info
                    
                        int iNewProspectID= ptManager.Add(prospectTasks);
                        ProspectTaskId = iNewProspectID;
                        bool bAlert = WorkflowManager.CreateProspectTaskAlerts(iNewProspectID);
                    Mode = "1";
                    this.btnDelete.Enabled = true;
                    this.btnClone.Enabled = true;
                    //ClientFun("savesuccess", "alert('Saved successfully!');");
                    PageCommon.RegisterJsMsg(this, "Saved successfully!", "parent.closeProspectTaskSetupWin();");
                }
                catch (Exception ex)
                {
                    ClientFun("failedToSave", "alert('Failed to save task info, please check your data and try again.');");
                    LPLog.LogMessage(LogType.Logerror, "Error occured when save the task: " + ex.Message);
                    return;
                }
            }
            else if ("1" == Mode)
            {
                prospectTasks = ptManager.GetModel(ProspectTaskId.Value);
                GetValue(ref prospectTasks);

                // check name duplicate
                if (ptManager.IsProspectTaskNameExists(ProspectTaskId.Value, prospectTasks.TaskName))
                {
                    ClientFun("duplicateName", "alert('Duplicate task name.');");
                    return;
                }

                try
                {
                    // update current prospect task info
                    ptManager.Update(prospectTasks);
                    ptManager.CheckProspectTaskAlert(Convert.ToInt32(ProspectTaskId));
                   //ClientFun("savesuccess", "alert('Saved successfully!');");
                   PageCommon.RegisterJsMsg(this, "Saved successfully!", "parent.closeProspectTaskSetupWin();");
                }
                catch (Exception ex)
                {
                    ClientFun("failedToSave", "alert('Failed to save the task, please check your data and try again.');");
                    LPLog.LogMessage(LogType.Logerror, "Error occured when save the task: " + ex.Message);
                    return;
                }
            }
        }
Exemple #21
0
    /// <summary>
    /// Reloads the page data.
    /// </summary>
    protected void ReloadData()
    {
        string where = string.Format("StepType IN ({0}, {1}, {2})", (int)WorkflowStepTypeEnum.DocumentEdit, (int)WorkflowStepTypeEnum.DocumentPublished, (int)WorkflowStepTypeEnum.DocumentArchived);
        // Hide custom steps if license doesn't allow them or check automatically publish changes
        if (!WorkflowInfoProvider.IsCustomStepAllowed())
        {
            gridSteps.WhereCondition = SqlHelper.AddWhereCondition(gridSteps.WhereCondition, where);
        }
        // Hide custom steps (without actual step) if functionality 'Automatically publish changes' is allowed
        else if ((WorkflowInfo != null) && WorkflowInfo.WorkflowAutoPublishChanges)
        {
            gridSteps.WhereCondition = SqlHelper.AddWhereCondition(gridSteps.WhereCondition, where);
            // Get current step info
            WorkflowStepInfo currentStep = WorkflowManager.GetStepInfo(Node);

            if (currentStep != null)
            {
                if (!currentStep.StepIsDefault)
                {
                    gridSteps.WhereCondition = SqlHelper.AddWhereCondition(gridSteps.WhereCondition, "(StepName = '" + SqlHelper.EscapeQuotes(currentStep.StepName) + "')", "OR");
                }
            }
        }

        // Do not display steps without order - advanced workflow steps
        gridSteps.WhereCondition = SqlHelper.AddWhereCondition(gridSteps.WhereCondition, "StepOrder IS NOT NULL");


        // Prepare the query parameters
        QueryDataParameters parameters = new QueryDataParameters();

        parameters.Add("@DocumentID", 0);

        // Prepare the steps query parameters
        QueryDataParameters stepsParameters = new QueryDataParameters();

        stepsParameters.Add("@StepWorkflowID", 0);

        if (Node != null)
        {
            // Check read permissions
            if (MembershipContext.AuthenticatedUser.IsAuthorizedPerDocument(Node, NodePermissionsEnum.Read) == AuthorizationResultEnum.Denied)
            {
                RedirectToAccessDenied(String.Format(GetString("cmsdesk.notauthorizedtoreaddocument"), Node.NodeAliasPath));
            }

            // Prepare parameters
            parameters.Add("@DocumentID", Node.DocumentID);
            currentStepId = ValidationHelper.GetInteger(Node.GetValue("DocumentWorkflowStepID"), 0);

            if (WorkflowInfo != null)
            {
                plcBasic.Visible    = WorkflowInfo.IsBasic;
                plcAdvanced.Visible = !plcBasic.Visible;
                if (plcAdvanced.Visible)
                {
                    ucDesigner.WorkflowID     = WorkflowInfo.WorkflowID;
                    ucDesigner.SelectedStepID = currentStepId;
                    ucDesigner.WorkflowType   = WorkflowTypeEnum.Approval;
                }
                else
                {
                    stepsParameters.Add("@StepWorkflowID", WorkflowInfo.WorkflowID);
                }

                // Initialize grids
                gridHistory.OnExternalDataBound += gridHistory_OnExternalDataBound;
                gridSteps.OnExternalDataBound   += gridSteps_OnExternalDataBound;
                gridHistory.ZeroRowsText         = GetString("workflowproperties.nohistoryyet");
            }
        }
        else
        {
            pnlWorkflow.Visible = false;
        }

        // Initialize query parameters of grids
        gridSteps.QueryParameters   = stepsParameters;
        gridHistory.QueryParameters = parameters;

        SetupForm();
        gridHistory.ReloadData();
        if (plcBasic.Visible)
        {
            gridSteps.ReloadData();
        }
    }
    protected void gridHistory_OnAction(string actionName, object actionArgument)
    {
        int versionHistoryId = ValidationHelper.GetInteger(actionArgument, 0);

        switch (actionName.ToLowerInvariant())
        {
        case "rollback":
            if (versionHistoryId > 0)
            {
                if (CheckedOutByUserID > 0)
                {
                    // Document is checked out
                    ShowError(GetString("VersionProperties.CannotRollbackCheckedOut"));
                }
                else
                {
                    // Check permissions
                    if (!WorkflowManager.CheckStepPermissions(Node, WorkflowActionEnum.Approve) || !CanModify || (CheckedOutByAnotherUser && !CanCheckIn) || (versionHistoryId == Node.DocumentCheckedOutVersionHistoryID))
                    {
                        ShowError(String.Format(GetString("cmsdesk.notauthorizedtoeditdocument"), Node.NodeAliasPath));
                    }
                    else
                    {
                        try
                        {
                            VersionManager.RollbackVersion(versionHistoryId);

                            if (!IsLiveSite)
                            {
                                // Refresh content tree (for the case that document name has been changed)
                                ScriptHelper.RefreshTree(Page, NodeID, Node.NodeParentID);
                            }

                            // Refresh node instance
                            InvalidateNode();
                            ShowConfirmation(GetString("VersionProperties.RollbackOK"));
                        }
                        catch (Exception ex)
                        {
                            ShowError(ex.Message);
                        }
                    }
                }
            }
            break;

        case "destroy":
            if (versionHistoryId > 0)
            {
                if (Node != null)
                {
                    // Check permissions
                    if (!CanDestroy || (CheckedOutByAnotherUser && !CanCheckIn) || (versionHistoryId == Node.DocumentCheckedOutVersionHistoryID))
                    {
                        ShowError(GetString("History.ErrorNotAllowedToDestroy"));
                    }
                    else
                    {
                        // Refresh node instance
                        InvalidateNode();
                        VersionManager.DestroyDocumentVersion(versionHistoryId);
                        ShowConfirmation(GetString("VersionProperties.DestroyOK"));
                    }
                }
            }
            break;
        }
    }
Exemple #23
0
 public WorkflowController(WorkflowManager manager)
 {
     Manager = manager;
 }
Exemple #24
0
    /// <summary>
    /// Provides operations necessary to create and store new content file.
    /// </summary>
    private void HandleContentUpload()
    {
        TreeNode     node = null;
        TreeProvider tree = null;

        string message            = string.Empty;
        bool   newDocumentCreated = false;

        try
        {
            if (this.NodeParentNodeID == 0)
            {
                throw new Exception(GetString("dialogs.document.parentmissing"));
            }

            // Check license limitations
            if (!LicenseHelper.LicenseVersionCheck(URLHelper.GetCurrentDomain(), FeatureEnum.Documents, VersionActionEnum.Insert))
            {
                throw new Exception(GetString("cmsdesk.documentslicenselimits"));
            }

            // Check if class exists
            DataClassInfo ci = DataClassInfoProvider.GetDataClass("CMS.File");
            if (ci == null)
            {
                throw new Exception("Class 'CMS.File' not found.");
            }

            #region "Check permissions"

            // Get the node
            tree = new TreeProvider(CMSContext.CurrentUser);
            TreeNode parentNode = tree.SelectSingleNode(this.NodeParentNodeID, TreeProvider.ALL_CULTURES);
            if (parentNode != null)
            {
                if (!DataClassInfoProvider.IsChildClassAllowed(ValidationHelper.GetInteger(parentNode.GetValue("NodeClassID"), 0), ci.ClassID))
                {
                    throw new Exception(GetString("Content.ChildClassNotAllowed"));
                }
            }

            // Check user permissions
            if (!RaiseOnCheckPermissions("Create", this))
            {
                if (!CMSContext.CurrentUser.IsAuthorizedToCreateNewDocument(NodeParentNodeID, NodeClassName))
                {
                    throw new Exception("You aren not allowed to create document of type '" + NodeClassName + "' in required location.");
                }
            }

            #endregion

            // Check the allowed extensions
            CheckAllowedExtensions();

            // Create new document
            string fileName = Path.GetFileNameWithoutExtension(ucFileUpload.FileName);

            node = TreeNode.New("CMS.File", tree);
            node.DocumentCulture = CMSContext.PreferredCultureCode;
            node.DocumentName    = fileName;

            // Load default values
            FormHelper.LoadDefaultValues(node);

            node.SetValue("FileDescription", "");
            node.SetValue("FileName", fileName);
            node.SetValue("FileAttachment", Guid.Empty);

            // Set default template ID
            node.DocumentPageTemplateID = ci.ClassDefaultPageTemplateID;

            // Insert the document
            DocumentHelper.InsertDocument(node, parentNode, tree);

            newDocumentCreated = true;

            // Add the file
            DocumentHelper.AddAttachment(node, "FileAttachment", ucFileUpload.PostedFile, tree, this.ResizeToWidth, this.ResizeToHeight, this.ResizeToMaxSideSize);

            // Create default SKU if configured
            if (ModuleEntry.CheckModuleLicense(ModuleEntry.ECOMMERCE, URLHelper.GetCurrentDomain(), FeatureEnum.Ecommerce, VersionActionEnum.Insert))
            {
                node.CreateDefaultSKU();
            }

            // Update the document
            DocumentHelper.UpdateDocument(node, tree);

            WorkflowManager workflowManager = new WorkflowManager(tree);
            // Get workflow info
            WorkflowInfo workflowInfo = workflowManager.GetNodeWorkflow(node);

            // Check if auto publish changes is allowed
            if ((workflowInfo != null) && workflowInfo.WorkflowAutoPublishChanges && !workflowInfo.UseCheckInCheckOut(CMSContext.CurrentSiteName))
            {
                // Automatically publish document
                workflowManager.AutomaticallyPublish(node, workflowInfo, null);
            }
        }
        catch (Exception ex)
        {
            // Delete the document if something failed
            if (newDocumentCreated && (node != null) && (node.DocumentID > 0))
            {
                DocumentHelper.DeleteDocument(node, tree, false, true, true);
            }

            message       = ex.Message;
            lblError.Text = message;
        }
        finally
        {
            if (string.IsNullOrEmpty(message))
            {
                // Create node info string
                string nodeInfo = "";
                if ((node != null) && (node.NodeID > 0) && (this.IncludeNewItemInfo))
                {
                    nodeInfo = node.NodeID.ToString();
                }

                // Ensure message text
                message = HTMLHelper.EnsureLineEnding(message, " ");

                // Register wopener script
                ScriptHelper.RegisterWOpenerScript(Page);

                // Call function to refresh parent window
                ScriptHelper.RegisterStartupScript(this.Page, typeof(Page), "refresh", ScriptHelper.GetScript("if ((wopener.parent != null) && (wopener.parent.InitRefresh_" + ParentElemID + " != null)){wopener.parent.InitRefresh_" + ParentElemID + "(" + ScriptHelper.GetString(message.Trim()) + ", false, false" + ((nodeInfo != "") ? ", '" + nodeInfo + "'" : "") + (InsertMode ? ", 'insert'" : ", 'update'") + ");}window.close();"));
            }
        }
    }
 /// <summary>
 /// Performs necessary checks and publishes document.
 /// </summary>
 /// <returns>TRUE if operation fails and whole process should be canceled.</returns>
 private bool PerformPublish(WorkflowManager wm, TreeProvider tree, string siteName, DataRow nodeRow)
 {
     string aliasPath = ValidationHelper.GetString(nodeRow["NodeAliasPath"], string.Empty);
     return PerformPublish(wm, tree, GetDocument(tree, siteName, nodeRow), aliasPath);
 }
Exemple #26
0
    /// <summary>
    /// Provides operations necessary to create and store new attachment.
    /// </summary>
    private void HandleAttachmentUpload(bool fieldAttachment)
    {
        TreeProvider tree = null;
        TreeNode     node = null;

        // New attachment
        AttachmentInfo newAttachment = null;

        string message     = string.Empty;
        bool   fullRefresh = false;

        try
        {
            // Get the existing document
            if (DocumentID != 0)
            {
                // Get document
                tree = new TreeProvider(CMSContext.CurrentUser);
                node = DocumentHelper.GetDocument(DocumentID, tree);
                if (node == null)
                {
                    throw new Exception("Given document doesn't exist!");
                }
            }


            #region "Check permissions"

            if (CheckPermissions)
            {
                CheckNodePermissions(node);
            }

            #endregion


            // Check the allowed extensions
            CheckAllowedExtensions();

            // Standard attachments
            if (DocumentID != 0)
            {
                // Ensure automatic check-in/check-out
                bool            useWorkflow = false;
                bool            autoCheck   = false;
                bool            checkin     = false;
                WorkflowManager workflowMan = WorkflowManager.GetInstance(tree);
                VersionManager  vm          = null;

                // Get workflow info
                WorkflowInfo wi = workflowMan.GetNodeWorkflow(node);

                // Check if the document uses workflow
                if (wi != null)
                {
                    useWorkflow = true;
                    autoCheck   = !wi.UseCheckInCheckOut(CMSContext.CurrentSiteName);
                }

                // Check out the document
                if (autoCheck)
                {
                    // Get original step Id
                    int originalStepId = node.DocumentWorkflowStepID;

                    // Get current step info
                    WorkflowStepInfo si = workflowMan.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);
                    }

                    vm = VersionManager.GetInstance(tree);
                    var step = vm.CheckOut(node, node.IsPublished, true);
                    checkin = (step != null);
                }

                // Handle field attachment
                if (fieldAttachment)
                {
                    newAttachment = DocumentHelper.AddAttachment(node, AttachmentGUIDColumnName, Guid.Empty, Guid.Empty, ucFileUpload.PostedFile, tree, ResizeToWidth, ResizeToHeight, ResizeToMaxSideSize);
                    // Update attachment field
                    DocumentHelper.UpdateDocument(node, tree);
                }
                // Handle grouped and unsorted attachments
                else
                {
                    // Grouped attachment
                    if (AttachmentGroupGUID != Guid.Empty)
                    {
                        newAttachment = DocumentHelper.AddGroupedAttachment(node, AttachmentGUID, AttachmentGroupGUID, ucFileUpload.PostedFile, tree, ResizeToWidth, ResizeToHeight, ResizeToMaxSideSize);
                    }
                    // Unsorted attachment
                    else
                    {
                        newAttachment = DocumentHelper.AddUnsortedAttachment(node, AttachmentGUID, ucFileUpload.PostedFile, tree, ResizeToWidth, ResizeToHeight, ResizeToMaxSideSize);
                    }
                }

                // Check in the document
                if (autoCheck)
                {
                    if ((vm != null) && checkin)
                    {
                        vm.CheckIn(node, null, null);
                    }
                }

                // Log synchronization task if not under workflow
                if (!useWorkflow)
                {
                    DocumentSynchronizationHelper.LogDocumentChange(node, TaskTypeEnum.UpdateDocument, tree);
                }
            }

            // Temporary attachments
            if (FormGUID != Guid.Empty)
            {
                newAttachment = AttachmentInfoProvider.AddTemporaryAttachment(FormGUID, AttachmentGUIDColumnName, AttachmentGUID, AttachmentGroupGUID, ucFileUpload.PostedFile, CMSContext.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)
        {
            message       = ex.Message;
            lblError.Text = message;
        }
        finally
        {
            // Call aftersave javascript if exists
            if ((string.IsNullOrEmpty(message)) && (newAttachment != null))
            {
                string closeString = "CloseDialog();";
                // Register wopener script
                ScriptHelper.RegisterWOpenerScript(Page);

                if (!String.IsNullOrEmpty(AfterSaveJavascript))
                {
                    string url      = null;
                    string saveName = URLHelper.GetSafeFileName(newAttachment.AttachmentName, CMSContext.CurrentSiteName);
                    if (node != null)
                    {
                        SiteInfo si = SiteInfoProvider.GetSiteInfo(node.NodeSiteID);
                        if (si != null)
                        {
                            bool usePermanent = SettingsKeyProvider.GetBoolValue(si.SiteName + ".CMSUsePermanentURLs");
                            if (usePermanent)
                            {
                                url = ResolveUrl(AttachmentInfoProvider.GetAttachmentUrl(newAttachment.AttachmentGUID, saveName));
                            }
                            else
                            {
                                url = ResolveUrl(AttachmentInfoProvider.GetAttachmentUrl(saveName, node.NodeAliasPath));
                            }
                        }
                    }
                    else
                    {
                        url = ResolveUrl(AttachmentInfoProvider.GetAttachmentUrl(newAttachment.AttachmentGUID, saveName));
                    }
                    // Calling javascript function with parameters attachments url, name, width, height
                    string jsParams = "('" + url + "', '" + newAttachment.AttachmentName + "', '" + newAttachment.AttachmentImageWidth + "', '" + newAttachment.AttachmentImageHeight + "');";
                    string script   = "if ((wopener.parent != null) && (wopener.parent." + AfterSaveJavascript + " != null)){wopener.parent." + AfterSaveJavascript + jsParams + "}";
                    script += "else if (wopener." + AfterSaveJavascript + " != null){wopener." + AfterSaveJavascript + jsParams + "}";

                    ScriptHelper.RegisterStartupScript(Page, typeof(Page), "refreshAfterSave", ScriptHelper.GetScript(script + closeString));
                }

                // Create attachment info string
                string attachmentInfo = "";
                if ((newAttachment != null) && (newAttachment.AttachmentGUID != Guid.Empty) && (IncludeNewItemInfo))
                {
                    attachmentInfo = newAttachment.AttachmentGUID.ToString();
                }

                // Ensure message text
                message = HTMLHelper.EnsureLineEnding(message, " ");

                // Call function to refresh parent window
                ScriptHelper.RegisterStartupScript(Page, typeof(Page), "refresh", ScriptHelper.GetScript("if ((wopener.parent != null) && (wopener.parent.InitRefresh_" + ParentElemID + " != null)){wopener.parent.InitRefresh_" + ParentElemID + "(" + ScriptHelper.GetString(message.Trim()) + ", " + (fullRefresh ? "true" : "false") + ", false" + ((attachmentInfo != "") ? ", '" + attachmentInfo + "'" : "") + (InsertMode ? ", 'insert'" : ", 'update'") + ");}" + closeString));
            }
        }
    }
    /// <summary>
    /// Handles attachment action.
    /// </summary>
    /// <param name="argument">Argument coming from upload control</param>
    private void HandleAttachmentAction(string argument, bool isUpdate)
    {
        // Get attachment URL first
        Guid attachmentGuid = ValidationHelper.GetGuid(argument, Guid.Empty);
        if (attachmentGuid != Guid.Empty)
        {
            // Get attachment info
            TreeProvider tree = new TreeProvider(CMSContext.CurrentUser);

            // Ensure site information
            SiteInfo si = CMSContext.CurrentSite;
            if ((TreeNodeObj != null) && (si.SiteID != TreeNodeObj.NodeSiteID))
            {
                si = SiteInfoProvider.GetSiteInfo(TreeNodeObj.NodeSiteID);
            }

            AttachmentInfo ai = DocumentHelper.GetAttachment(attachmentGuid, tree, si.SiteName, false);
            if (ai != null)
            {
                string nodeAliasPath = (TreeNodeObj != null) ? TreeNodeObj.NodeAliasPath : null;

                if (CMSDialogHelper.IsItemSelectable(SelectableContent, ai.AttachmentExtension))
                {
                    // Get attachment URL
                    string url = mediaView.GetAttachmentItemUrl(ai.AttachmentGUID, ai.AttachmentName, nodeAliasPath, 0, 0, 0);

                    // Remember last selected attachment GUID
                    if (SourceType == MediaSourceEnum.DocumentAttachments)
                    {
                        LastAttachmentGuid = ai.AttachmentGUID;
                    }

                    // Get the node workflow
                    int versionHistoryId = 0;
                    if (TreeNodeObj != null)
                    {
                        WorkflowManager wm = new WorkflowManager(TreeNodeObj.TreeProvider);
                        WorkflowInfo wi = wm.GetNodeWorkflow(TreeNodeObj);
                        if (wi != null)
                        {
                            // Ensure the document version
                            VersionManager vm = new VersionManager(TreeNodeObj.TreeProvider);
                            versionHistoryId = vm.EnsureVersion(TreeNodeObj, TreeNodeObj.IsPublished);
                        }
                    }

                    MediaItem item = InitializeMediaItem(ai.AttachmentName, ai.AttachmentExtension, ai.AttachmentImageWidth, ai.AttachmentImageHeight, ai.AttachmentSize, url, null, versionHistoryId, 0, "");

                    SelectMediaItem(item);

                    ItemToColorize = attachmentGuid;

                    ColorizeRow(ItemToColorize.ToString());
                }
                else
                {
                    // Unselect old attachment and clear properties
                    ColorizeRow("");
                    Properties.ClearProperties(true);
                    pnlUpdateProperties.Update();
                }

                mediaView.InfoText = (isUpdate ? GetString("dialogs.attachment.updated") : GetString("dialogs.attachment.created"));

                pnlUpdateView.Update();
            }
        }

        ClearActionElems();
    }
Exemple #28
0
 public WorkflowController()
 {
     Manager = ServiceFactory.WorkflowManager;
 }
    /// <summary>
    /// Publishes document.
    /// </summary>
    /// <param name="node">Node to publish</param>
    /// <param name="wm">Workflow manager</param>
    /// <returns>Whether node is already published</returns>
    private static bool Publish(TreeNode node, WorkflowManager wm)
    {
        WorkflowStepInfo currentStep = wm.GetStepInfo(node);
        bool toReturn = true;
        if (currentStep != null)
        {
            // For archive step start new version
            if (currentStep.StepName.ToLower() == "archived")
            {
                VersionManager vm = new VersionManager(node.TreeProvider);
                currentStep = vm.CheckOut(node, node.IsPublished, true);
                vm.CheckIn(node, null, null);
            }

            // Remove possible checkout
            if (node.GetIntegerValue("DocumentCheckedOutByUserID") > 0)
            {
                TreeProvider.ClearCheckoutInformation(node);
                node.Update();
            }

            // Approve until the document is published
            while ((currentStep != null) && (currentStep.StepName.ToLower() != "published"))
            {
                currentStep = wm.MoveToNextStep(node, string.Empty);
                toReturn = false;
            }
        }
        return toReturn;
    }
 public NewCustomerState(WorkflowManager manager)
     : base(manager, WorkflowStates.NewCustomer)
 {
 }
    /// <summary>
    /// Publishes document.
    /// </summary>
    /// <param name="node">Node to publish</param>
    /// <param name="wm">Workflow manager</param>
    /// <returns>Whether node is already published</returns>
    private bool Publish(TreeNode node, WorkflowManager wm)
    {
        string pathCulture = HTMLHelper.HTMLEncode(node.NodeAliasPath + " (" + node.DocumentCulture + ")");
        WorkflowStepInfo currentStep = wm.GetStepInfo(node);
        bool alreadyPublished = (currentStep == null) || currentStep.StepIsPublished;

        if (!alreadyPublished)
        {
            using (new CMSActionContext { LogEvents = false })
            {
                // Remove possible checkout
                if (node.DocumentCheckedOutByUserID > 0)
                {
                    TreeProvider.ClearCheckoutInformation(node);
                    node.Update();
                }
            }

            // Publish document
            currentStep = wm.PublishDocument(node);
        }

        // Document is already published, check if still under workflow
        if (alreadyPublished && (currentStep != null) && currentStep.StepIsPublished)
        {
            WorkflowScopeInfo wsi = wm.GetNodeWorkflowScope(node);
            if (wsi == null)
            {
                VersionManager vm = VersionManager.GetInstance(node.TreeProvider);
                vm.RemoveWorkflow(node);
            }
        }

        // Document already published
        if (alreadyPublished)
        {
            AddLog(string.Format(ResHelper.GetString("content.publishedalready"), pathCulture));
        }
        else if ((currentStep == null) || !currentStep.StepIsPublished)
        {
            AddError(string.Format(ResHelper.GetString("content.PublishWasApproved"), pathCulture));
            return true;
        }
        else
        {
            // Add log record
            AddLog(pathCulture);
        }

        return false;
    }
Exemple #32
0
    /// <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);
                    }
                }

                // Handle field attachment
                if (fieldAttachment)
                {
                    newAttachment = DocumentHelper.AddAttachment(node, AttachmentGUIDColumnName, Guid.Empty, Guid.Empty, new AttachmentSource(ucFileUpload.PostedFile.ToUploadedFile()), ResizeToWidth, ResizeToHeight, ResizeToMaxSideSize);
                    // Update attachment field
                    DocumentHelper.UpdateDocument(node, TreeProvider);
                }
                // Handle grouped and unsorted attachments
                else
                {
                    // Grouped attachment
                    if (AttachmentGroupGUID != Guid.Empty)
                    {
                        newAttachment = DocumentHelper.AddGroupedAttachment(node, AttachmentGUID, AttachmentGroupGUID, ucFileUpload.PostedFile.ToUploadedFile(), ResizeToWidth, ResizeToHeight, ResizeToMaxSideSize);
                    }
                    // Unsorted attachment
                    else
                    {
                        newAttachment = DocumentHelper.AddUnsortedAttachment(node, AttachmentGUID, ucFileUpload.PostedFile.ToUploadedFile(), 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, new AttachmentSource(ucFileUpload.PostedFile.ToUploadedFile()), 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
            Service.Resolve <IEventLogService>().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))
                {
                    var url = ResolveUrl(AttachmentURLProvider.GetAttachmentUrl(newAttachment.AttachmentGUID, newAttachment.AttachmentName));

                    // 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);
        }
    }
Exemple #33
0
    protected DataSet gridAttachments_OnDataReload(string completeWhere, string currentOrder, int currentTopN, string columns, int currentOffset, int currentPageSize, ref int totalRecords)
    {
        string where = null;
        Guid   attachmentFormGUID       = Guid.Empty;
        string whereCondition           = GetWhereConditionInternal();
        int    documentVersionHistoryID = UsesWorkflow ? VersionHistoryID : 0;

        // Grouped attachments
        if (GroupGUID != Guid.Empty)
        {
            // Combine where conditions
            where = String.Format("(AttachmentGroupGUID='{0}')", GroupGUID);
        }
        // Unsorted attachments
        else
        {
            where = "(AttachmentIsUnsorted = 1)";
        }

        // Temporary attachments
        if ((attachmentFormGUID != Guid.Empty) && (documentVersionHistoryID == 0))
        {
            where += String.Format(" AND (AttachmentFormGUID='{0}')", FormGUID);
        }
        // Else document attachments
        else
        {
            if (documentVersionHistoryID == 0)
            {
                // Ensure current site name
                if (string.IsNullOrEmpty(SiteName))
                {
                    SiteName = CMSContext.CurrentSiteName;
                }


                if (Node != null)
                {
                    where += String.Format(" AND (AttachmentDocumentID = {0})", Node.DocumentID);

                    // Get attachments for latest version if not live site
                    if (!IsLiveSite)
                    {
                        WorkflowManager wm = new WorkflowManager(TreeProvider);
                        WorkflowInfo    wi = wm.GetNodeWorkflow(Node);
                        if (wi != null)
                        {
                            documentVersionHistoryID = Node.DocumentCheckedOutVersionHistoryID;
                        }
                    }
                }
                else
                {
                    return(null);
                }
            }
        }

        // Ensure additional where condition
        whereCondition = SqlHelperClass.AddWhereCondition(whereCondition, where);

        // Ensure [AttachmentID] column
        List <String> cols = new List <string>(columns.Split(new char[] { ',', ';' }));

        if (!cols.Contains("AttachmentID") && !cols.Contains("[AttachmentID]"))
        {
            columns = SqlHelperClass.MergeColumns("AttachmentID", columns);
        }

        DataSet ds = null;

        // Get attachments for published document
        if (documentVersionHistoryID == 0)
        {
            currentOrder = "AttachmentOrder, AttachmentName, AttachmentID";
            ds           = AttachmentManager.GetAttachments(whereCondition, currentOrder, true, currentTopN, columns);
        }
        else
        {
            currentOrder = "AttachmentOrder, AttachmentName, AttachmentHistoryID";

            VersionManager vm = new VersionManager(TreeProvider);
            ds = vm.GetVersionAttachments(documentVersionHistoryID, whereCondition, currentOrder, true, currentTopN, columns.Replace("AttachmentID", "AttachmentHistoryID"));
        }

        // Ensure consistent ID column name
        if (!DataHelper.DataSourceIsEmpty(ds))
        {
            ds.Tables[0].Columns[0].ColumnName = "AttachmentID";
        }

        return(ds);
    }
    protected void gridHistory_OnAction(string actionName, object actionArgument)
    {
        int versionHistoryId = ValidationHelper.GetInteger(actionArgument, 0);

        switch (actionName.ToLowerCSafe())
        {
        case "rollback":
            if (versionHistoryId > 0)
            {
                if (CheckedOutByUserID > 0)
                {
                    // Document is checked out
                    ShowError(GetString("VersionProperties.CannotRollbackCheckedOut"));
                }
                else
                {
                    // Check permissions
                    if (!WorkflowManager.CheckStepPermissions(Node, WorkflowActionEnum.Approve) || !CanModify)
                    {
                        ShowError(String.Format(GetString("cmsdesk.notauthorizedtoeditdocument"), Node.NodeAliasPath));
                    }
                    else
                    {
                        try
                        {
                            VersionManager.RollbackVersion(versionHistoryId);

                            if (!IsLiveSite)
                            {
                                // Refresh content tree (for the case that document name has been changed)
                                string refreshTreeScript = ScriptHelper.GetScript("if(window.RefreshTree!=null){RefreshTree(" + Node.NodeParentID + ", " + Node.NodeID + ");}");
                                ScriptHelper.RegisterStartupScript(this, typeof(string), "refreshTree" + ClientID, refreshTreeScript);
                            }

                            ShowConfirmation(GetString("VersionProperties.RollbackOK"));
                        }
                        catch (Exception ex)
                        {
                            ShowError(ex.Message);
                        }
                    }
                }
            }
            break;

        case "destroy":
            if (versionHistoryId > 0)
            {
                if (Node != null)
                {
                    // Check permissions
                    if (!CanDestroy || (CheckedOutByAnotherUser && !CanCheckIn))
                    {
                        ShowError(GetString("History.ErrorNotAllowedToDestroy"));
                    }
                    else
                    {
                        VersionManager.DestroyDocumentVersion(versionHistoryId);
                        ShowConfirmation(GetString("VersionProperties.DestroyOK"));
                    }
                }
            }
            break;
        }
    }
Exemple #35
0
    /// <summary>
    /// Reloads the page data.
    /// </summary>
    private void ReloadData()
    {
        // If no workflow set for node, hide the data
        if (WorkflowInfo == null)
        {
            headCheckOut.ResourceString = "properties.scopenotset";
            DisableForm();
            pnlVersions.Visible = false;
        }
        else
        {
            if (!WorkflowStepInfo.StepIsDefault && !WorkflowManager.CheckStepPermissions(Node, WorkflowActionEnum.Approve))
            {
                ShowInfo(GetString("EditContent.NotAuthorizedToApprove"), true);
            }
        }

        bool useCheckInCheckOut = false;

        if (WorkflowInfo != null)
        {
            useCheckInCheckOut = WorkflowInfo.UseCheckInCheckOut(SiteContext.CurrentSiteName);
        }

        // Check modify permissions
        if (!versionsElem.CanModify)
        {
            DisableForm();
            plcForm.Visible = false;
            ShowInfo(String.Format(GetString("cmsdesk.notauthorizedtoeditdocument"), Node.NodeAliasPath), true);
        }
        else if (useCheckInCheckOut || (versionsElem.CheckedOutByUserID != 0))
        {
            btnCheckout.Visible     = false;
            btnCheckout.Enabled     = true;
            btnCheckin.Visible      = false;
            btnCheckin.Enabled      = true;
            btnUndoCheckout.Visible = false;
            btnUndoCheckout.Enabled = true;
            txtComment.Enabled      = true;
            txtVersion.Enabled      = true;
            lblComment.Enabled      = true;
            lblVersion.Enabled      = true;

            // Check whether to check out or in
            if (WorkflowInfo == null)
            {
                btnCheckout.Visible         = true;
                headCheckOut.ResourceString = "VersionsProperties.CheckOut";
                DisableForm();
            }
            else if (!Node.IsCheckedOut)
            {
                headCheckOut.ResourceString = "VersionsProperties.CheckOut";
                DisableForm();
                btnCheckout.Visible = true;
                // Do not allow checkout for published or archived step in advanced workflow
                btnCheckout.Enabled = (WorkflowInfo.IsBasic || (!WorkflowStepInfo.StepIsPublished && !WorkflowStepInfo.StepIsArchived));
            }
            else
            {
                // If checked out by current user, allow to check-in
                if (versionsElem.CheckedOutByUserID == MembershipContext.AuthenticatedUser.UserID)
                {
                    btnCheckin.Visible      = true;
                    btnUndoCheckout.Visible = true;
                }
                else
                {
                    // Else checked out by somebody else
                    btnCheckin.Visible  = true;
                    btnCheckout.Visible = false;

                    btnUndoCheckout.Visible = versionsElem.CanCheckIn;
                    btnUndoCheckout.Enabled = versionsElem.CanCheckIn;
                    btnCheckin.Enabled      = versionsElem.CanCheckIn;
                    txtComment.Enabled      = versionsElem.CanCheckIn;
                    txtVersion.Enabled      = versionsElem.CanCheckIn;
                }

                headCheckOut.ResourceString = "VersionsProperties.CheckIn";
            }

            if (!WorkflowManager.CheckStepPermissions(Node, WorkflowActionEnum.Approve))
            {
                DisableForm();
            }
        }
        else
        {
            plcForm.Visible = false;
        }
    }
        private void ImportPost(Guid blogId, GenericBlogPost post)
        {
            Guid masterBlogPostId = Guid.NewGuid();

            BlogPost blogPost = SFBlogsManager.CreateBlogPost(masterBlogPostId);

            Blog blog = SFBlogsManager.GetBlogs().Where(b => b.Id == blogId).SingleOrDefault();

            blogPost.Parent = blog;

            masterBlogPostId = blogPost.Id;

            blogPost.Title           = post.Title;
            blogPost.DateCreated     = post.DateCreated;
            blogPost.PublicationDate = post.PublicationDate;
            blogPost.LastModified    = post.PublicationDate;

            string content = ParseContent(post.Content);

            content = ImportAndLinkContentImages(content, post.Title, blog.Title);

            blogPost.Content = content;

            blogPost.Summary       = post.Summary;
            blogPost.AllowComments = post.AllowComments;
            blogPost.UrlName       = post.PostName ?? Regex.Replace(post.Title.ToLower(), @"[^\w\-\!\$\'\(\)\=\@\d_]+", "-");
            blogPost.Owner         = Guid.Empty;

            PostAuthor author = _authors.Where(a => a.Username == post.Creator).FirstOrDefault();

            if (author != null)
            {
                User user = SFUserManager.GetUserByEmail(author.Email);

                if (user != null)
                {
                    blogPost.Owner = user.Id;
                }
            }

            if (ddlCategoriesImportMode.SelectedIndex > 0)
            {
                if (post.Categories != null && post.Categories.Count > 0)
                {
                    foreach (string category in post.Categories)
                    {
                        HierarchicalTaxon taxon;

                        taxon = SFTaxonomyManager.GetTaxa <HierarchicalTaxon>().Where(t => t.Name == category).FirstOrDefault();

                        if (taxon == null && ddlCategoriesImportMode.SelectedIndex > 1)
                        {
                            taxon = CreateCategory(category);
                        }

                        if (taxon != null)
                        {
                            blogPost.Organizer.AddTaxa("Category", taxon.Id);
                        }
                    }
                }
            }

            if (ddlTagsImportMode.SelectedIndex > 0)
            {
                if (post.Tags != null && post.Tags.Count > 0)
                {
                    foreach (string tag in post.Tags)
                    {
                        FlatTaxon taxon;

                        taxon = SFTaxonomyManager.GetTaxa <FlatTaxon>().Where(t => t.Name == tag).FirstOrDefault();

                        if (taxon == null && ddlTagsImportMode.SelectedIndex > 1)
                        {
                            taxon = CreateTag(tag);
                        }

                        if (taxon != null)
                        {
                            blogPost.Organizer.AddTaxa("Tags", taxon.Id);
                        }
                    }
                }
            }

            if (post.AttachmentUrl != String.Empty)
            {
                string imageSrc = post.AttachmentUrl;

                string imgFile = Path.GetFileName(imageSrc);

                var sfImages = App.WorkWith().Images().Where(i => i.Status == ContentLifecycleStatus.Master).Get().ToList();

                var sfImg = sfImages.Where(i => Path.GetFileName(i.FilePath) == imgFile.ToLower()).FirstOrDefault();

                if (sfImg != null)
                {
                    blogPost.CreateRelation(sfImg, "Thumbnail");
                }
                else
                {
                    if (ImportImage(imageSrc, post.Title, blog.Title))
                    {
                        sfImg = App.WorkWith().Images().Where(i => i.Status == ContentLifecycleStatus.Master).Get().ToList().Where(i => Path.GetFileName(i.FilePath) == imgFile.ToLower()).FirstOrDefault();

                        blogPost.CreateRelation(sfImg, "Thumbnail");
                    }
                }
            }

            if (post.Meta != null)
            {
                if (post.Meta.ContainsKey("_yoast_wpseo_title"))
                {
                    blogPost.SetValue("SEOTitle", post.Meta["_yoast_wpseo_title"]);
                }

                if (post.Meta.ContainsKey("_yoast_wpseo_metadesc"))
                {
                    blogPost.SetValue("SEOMetaDescription", post.Meta["_yoast_wpseo_metadesc"]);
                }

                if (post.Meta.ContainsKey("_yoast_wpseo_focuskw"))
                {
                    blogPost.SetValue("SEOMetaKeywords", post.Meta["_yoast_wpseo_focuskw"]);
                }
            }

            SFBlogsManager.RecompileItemUrls(blogPost);
            SFBlogsManager.Lifecycle.PublishWithSpecificDate(blogPost, post.PublicationDate);
            SFBlogsManager.SaveChanges();

            var bag = new Dictionary <string, string>();

            bag.Add("ContentType", typeof(BlogPost).FullName);
            WorkflowManager.MessageWorkflow(masterBlogPostId, typeof(BlogPost), null, "Publish", false, bag);

            if (chkImportComments.Checked)
            {
                if (post.Comments != null && post.Comments.Count() > 0)
                {
                    foreach (var comment in post.Comments)
                    {
                        CreateBlogPostComment(masterBlogPostId, comment);
                    }
                }
            }

            var dbg = _importLog;
        }
Exemple #37
0
    private string CompleteTask(int iLoanTaskId)
    {
        #region complete task

        string sErrorMsg        = string.Empty;
        int    iEmailTemplateId = 0;
        bool   bIsSuccess       = LPWeb.DAL.WorkflowManager.CompleteTask(iLoanTaskId, this.CurrUser.iUserID, ref iEmailTemplateId);

        if (bIsSuccess == false)
        {
            sErrorMsg = "Failed to invoke WorkflowManager.CompleteTask.";
            return(sErrorMsg);
        }

        #endregion

        #region update point file stage

        int iLoanStageID = 0;

        #region get loan task info

        LoanTasks LoanTaskManager = new LoanTasks();
        DataTable LoanTaskInfo    = LoanTaskManager.GetLoanTaskInfo(iLoanTaskId);
        if (LoanTaskInfo.Rows.Count == 0)
        {
            sErrorMsg = "Invalid task id.";
            return(sErrorMsg);
        }
        string sLoanStageID = LoanTaskInfo.Rows[0]["LoanStageId"].ToString();
        if (sLoanStageID == string.Empty)
        {
            sErrorMsg = "Invalid loan stage id.";
            return(sErrorMsg);
        }
        iLoanStageID = Convert.ToInt32(sLoanStageID);

        #endregion
        if (WorkflowManager.StageCompleted(iLoanStageID) == true)
        {
            #region invoke PointManager.UpdateStage()

            //add by  gdc 20111212  Bug #1306
            LPWeb.BLL.PointFiles pfile = new PointFiles();
            var model = pfile.GetModel(iLoanID);
            if (model != null && !string.IsNullOrEmpty(model.Name.Trim()))
            {
                #region UPdatePointFileStage  WCF

                string sError = LoanTaskCommon.UpdatePointFileStage(iLoanID, this.CurrUser.iUserID, iLoanStageID);

                #endregion
            }

            #endregion
        }

        #endregion

        return(sErrorMsg);
    }
Exemple #38
0
 public WorkflowController(WorkflowManager manager)
 {
     Manager = manager;
 }
    /// <summary>
    /// Saves metadata and file name of attachment.
    /// </summary>
    /// <param name="newFileName">New attachment file name</param>
    /// <returns>Returns True if attachment was succesfully saved.</returns>
    private bool SaveAttachment(string newFileName)
    {
        bool saved = false;

        // Save new data
        try
        {
            AttachmentInfo attachmentInfo = InfoObject as AttachmentInfo;

            if (attachmentInfo != null)
            {
                // Set new file name
                if (!string.IsNullOrEmpty(newFileName))
                {
                    string name = newFileName + attachmentInfo.AttachmentExtension;
                    if (IsAttachmentNameUnique(attachmentInfo, name))
                    {
                        attachmentInfo.AttachmentName = name;
                    }
                    else
                    {
                        // Attachment already exists.
                        LabelError = GetString("img.errors.fileexists");
                        return false;
                    }
                }

                // Ensure automatic check-in/ check-out
                bool useWorkflow = false;
                bool autoCheck = false;
                WorkflowManager workflowMan = new WorkflowManager(TreeProvider);

                if (Node != null)
                {
                    // Get workflow info
                    WorkflowInfo wi = workflowMan.GetNodeWorkflow(Node);

                    // Check if the document uses workflow
                    if (wi != null)
                    {
                        useWorkflow = true;
                        autoCheck = !wi.UseCheckInCheckOut(SiteName);
                    }

                    // Check out the document
                    if (autoCheck)
                    {
                        VersionManager.CheckOut(Node, Node.IsPublished, true);
                        VersionHistoryID = Node.DocumentCheckedOutVersionHistoryID;
                    }

                    // Workflow has been lost, get published attachment
                    if (useWorkflow && (VersionHistoryID == 0))
                    {
                        attachmentInfo = AttachmentManager.GetAttachmentInfo(attachmentInfo.AttachmentGUID, SiteName);
                    }
                }

                if (attachmentInfo != null)
                {
                    // Set filename title and description
                    attachmentInfo.AttachmentTitle = ObjectTitle;
                    attachmentInfo.AttachmentDescription = ObjectDescription;

                    // Document uses workflow and document is already saved (attachment is not temporary)
                    if ((VersionHistoryID > 0) && !nodeIsParent)
                    {
                        attachmentInfo.AllowPartialUpdate = true;
                        VersionManager.SaveAttachmentVersion(attachmentInfo, VersionHistoryID);
                    }
                    else
                    {
                        // Update without binary
                        attachmentInfo.AllowPartialUpdate = true;
                        AttachmentManager.SetAttachmentInfo(attachmentInfo);

                        // Log the sycnhronization and search task for the document
                        if (Node != null)
                        {
                            // Update search index for given document
                            if ((Node.PublishedVersionExists) && (SearchIndexInfoProvider.SearchEnabled))
                            {
                                SearchTaskInfoProvider.CreateTask(SearchTaskTypeEnum.Update, PredefinedObjectType.DOCUMENT, SearchHelper.ID_FIELD, Node.GetSearchID());
                            }

                            DocumentSynchronizationHelper.LogDocumentChange(Node, TaskTypeEnum.UpdateDocument, TreeProvider);
                        }
                    }

                    // Check in the document
                    if (autoCheck)
                    {
                        if (VersionManager != null)
                        {
                            if (VersionHistoryID > 0 && (Node != null))
                            {
                                VersionManager.CheckIn(Node, null, null);
                            }
                        }
                    }

                    saved = true;

                    string fullRefresh = "false";

                    if (autoCheck || (Node == null))
                    {
                        fullRefresh = "true";
                    }

                    // Refresh parent update panel
                    LtlScript.Text = ScriptHelper.GetScript("RefreshMetaData(" + ScriptHelper.GetString(ExternalControlID) + ", '" + fullRefresh + "', '" + attachmentInfo.AttachmentGUID + "', 'refresh')");
                }
            }
        }
        catch (Exception ex)
        {
            lblError.Text = GetString("metadata.errors.processing");
            EventLogProvider.LogException("Metadata editor", "SAVEATTACHMENT", ex);
        }

        return saved;
    }
Exemple #40
0
 public void Dispose()
 {
     WorkflowManager.Execute(View.GetEventCommands("UnLoad"));
     WorkflowManager.Instance.Message -= Instance_Message;
 }
        public void NavigationWidget_ValidatePagesCacheDependenciesOnChildPagePublishUnpublish()
        {
            const string ParentPageTitle = "ParentPage";
            const string ChildPageTitle  = "ChildPage";

            string url = UrlPath.ResolveAbsoluteUrl("~/" + UrlNamePrefix + Index);

            var mvcProxy = new MvcControllerProxy()
            {
                ControllerName = typeof(NavigationController).FullName, Settings = new ControllerSettings(new NavigationController()
                {
                    LevelsToInclude = 2
                })
            };
            var paretnPageId = this.pageOperations.CreatePageWithControl(mvcProxy, PageNamePrefix, PageTitlePrefix, UrlNamePrefix, Index);

            this.createdPageIDs.Add(paretnPageId);

            var pageGenerator = new Telerik.Sitefinity.TestIntegration.Data.Content.PageContentGenerator();
            var pageManager   = PageManager.GetManager();

            var parentPageId = pageGenerator.CreatePage(ParentPageTitle, ParentPageTitle, ParentPageTitle);

            this.createdPageIDs.Add(parentPageId);

            var childPageId = pageGenerator.CreatePage(ChildPageTitle, ChildPageTitle, ChildPageTitle);

            this.createdPageIDs.Add(childPageId);

            var parent = pageManager.GetPageNode(parentPageId);
            var child  = pageManager.GetPageNode(childPageId);

            child.Parent = parent;
            pageManager.SaveChanges();

            var cookies = new CookieContainer();

            using (new AuthenticateUserRegion(null))
            {
                var responseContent = this.GetResponse(url, cookies);
                Assert.IsTrue(responseContent.Contains(ParentPageTitle + "<"), "The parent page was not found");
                Assert.IsTrue(responseContent.Contains(ChildPageTitle + "<"), "The child page was not found");
            }

            pageManager.UnpublishPage(child.GetPageData());
            pageManager.SaveChanges();

            using (new AuthenticateUserRegion(null))
            {
                var responseContent = this.GetResponse(url, cookies);
                Assert.IsTrue(responseContent.Contains(ParentPageTitle + "<"), "The parent page was not found");
                Assert.IsFalse(responseContent.Contains(ChildPageTitle + "<"), "The child page was found");
            }

            var bag = new Dictionary <string, string>();

            bag.Add("ContentType", child.GetType().FullName);
            WorkflowManager.MessageWorkflow(childPageId, child.GetType(), null, "Publish", false, bag);

            using (new AuthenticateUserRegion(null))
            {
                var responseContent = this.GetResponse(url, cookies);
                Assert.IsTrue(responseContent.Contains(ParentPageTitle + "<"), "The parent page was not found");
                Assert.IsTrue(responseContent.Contains(ChildPageTitle + "<"), "The child page was not found");
            }
        }
 public PendingWorkflowController(WorkflowManager manager)
 {
     Manager = manager;
 }
Exemple #43
0
    /// <summary>
    /// Saves modified image data.
    /// </summary>
    /// <param name="name">Image name</param>
    /// <param name="extension">Image extension</param>
    /// <param name="mimetype">Image mimetype</param>
    /// <param name="title">Image title</param>
    /// <param name="description">Image description</param>
    /// <param name="binary">Image binary data</param>
    /// <param name="width">Image width</param>
    /// <param name="height">Image height</param>
    private void SaveImage(string name, string extension, string mimetype, string title, string description, byte[] binary, int width, int height)
    {
        LoadInfos();

        // Save image data depending to image type
        switch (baseImageEditor.ImageType)
        {
            // Process attachment
            case ImageHelper.ImageTypeEnum.Attachment:
                if ((ai != null) && (AttachmentManager != null))
                {
                    // Save new data
                    try
                    {
                        // Get the node
                        TreeNode node = DocumentHelper.GetDocument(ai.AttachmentDocumentID, baseImageEditor.Tree);

                        // Check Create permission when saving temporary attachment, check Modify permission else
                        NodePermissionsEnum permissionToCheck = (ai.AttachmentFormGUID == Guid.Empty) ? NodePermissionsEnum.Modify : NodePermissionsEnum.Create;

                        // Check permission
                        if (CMSContext.CurrentUser.IsAuthorizedPerDocument(node, permissionToCheck) != AuthorizationResultEnum.Allowed)
                        {
                            baseImageEditor.LblLoadFailed.Visible = true;
                            baseImageEditor.LblLoadFailed.ResourceString = "attach.actiondenied";
                            this.SavingFailed = true;

                            return;
                        }

                        if (!IsNameUnique(name, extension))
                        {
                            baseImageEditor.LblLoadFailed.Visible = true;
                            baseImageEditor.LblLoadFailed.ResourceString = "img.namenotunique";
                            this.SavingFailed = true;

                            return;
                        }

                        // Ensure automatic check-in/ check-out
                        bool useWorkflow = false;
                        bool autoCheck = false;
                        WorkflowManager workflowMan = new WorkflowManager(baseImageEditor.Tree);
                        if (node != null)
                        {
                            // Get workflow info
                            WorkflowInfo wi = workflowMan.GetNodeWorkflow(node);

                            // Check if the document uses workflow
                            if (wi != null)
                            {
                                useWorkflow = true;
                                autoCheck = !wi.UseCheckInCheckOut(CurrentSiteName);
                            }

                            // Check out the document
                            if (autoCheck)
                            {
                                VersionManager.CheckOut(node, node.IsPublished, true);
                                VersionHistoryID = node.DocumentCheckedOutVersionHistoryID;
                            }

                            // Workflow has been lost, get published attachment
                            if (useWorkflow && (VersionHistoryID == 0))
                            {
                                ai = AttachmentManager.GetAttachmentInfo(ai.AttachmentGUID, CurrentSiteName);
                            }

                            // If extension changed update CMS.File extension
                            if ((node.NodeClassName.ToLower() == "cms.file") && (node.DocumentExtensions != extension))
                            {
                                // Update document extensions if no custom are used
                                if (!node.DocumentUseCustomExtensions)
                                {
                                    node.DocumentExtensions = extension;
                                }
                                node.SetValue("DocumentType", extension);

                                DocumentHelper.UpdateDocument(node, baseImageEditor.Tree);
                            }
                        }

                        if (ai != null)
                        {
                            // Test all parameters to empty values and update new value if available
                            if (name != "")
                            {
                                if (!name.EndsWith(extension))
                                {
                                    ai.AttachmentName = name + extension;
                                }
                                else
                                {
                                    ai.AttachmentName = name;
                                }
                            }
                            if (extension != "")
                            {
                                ai.AttachmentExtension = extension;
                            }
                            if (mimetype != "")
                            {
                                ai.AttachmentMimeType = mimetype;
                            }

                            ai.AttachmentTitle = title;
                            ai.AttachmentDescription = description;

                            if (binary != null)
                            {
                                ai.AttachmentBinary = binary;
                                ai.AttachmentSize = binary.Length;
                            }
                            if (width > 0)
                            {
                                ai.AttachmentImageWidth = width;
                            }
                            if (height > 0)
                            {
                                ai.AttachmentImageHeight = height;
                            }
                            // Ensure object
                            ai.MakeComplete(true);
                            if (VersionHistoryID > 0)
                            {
                                VersionManager.SaveAttachmentVersion(ai, VersionHistoryID);
                            }
                            else
                            {
                                AttachmentManager.SetAttachmentInfo(ai);

                                // Log the sycnhronization and search task for the document
                                if (node != null)
                                {
                                    // Update search index for given document
                                    if ((node.PublishedVersionExists) && (SearchIndexInfoProvider.SearchEnabled))
                                    {
                                        SearchTaskInfoProvider.CreateTask(SearchTaskTypeEnum.Update, PredefinedObjectType.DOCUMENT, SearchHelper.ID_FIELD, node.GetSearchID());
                                    }

                                    DocumentSynchronizationHelper.LogDocumentChange(node, TaskTypeEnum.UpdateDocument, baseImageEditor.Tree);
                                }
                            }

                            // Check in the document
                            if (autoCheck)
                            {
                                if (VersionManager != null)
                                {
                                    if (VersionHistoryID > 0 && node != null)
                                    {
                                        VersionManager.CheckIn(node, null, null);
                                    }
                                }
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        baseImageEditor.LblLoadFailed.Visible = true;
                        baseImageEditor.LblLoadFailed.ResourceString = "img.errors.processing";
                        ScriptHelper.AppendTooltip(baseImageEditor.LblLoadFailed, ex.Message, "help");
                        EventLogProvider.LogException("Image editor", "SAVEIMAGE", ex);
                        this.SavingFailed = true;
                    }
                }
                break;

            case ImageHelper.ImageTypeEnum.PhysicalFile:
                if (!String.IsNullOrEmpty(filePath))
                {
                    CurrentUserInfo currentUser = CMSContext.CurrentUser;
                    if ((currentUser != null) && currentUser.IsGlobalAdministrator)
                    {
                        try
                        {
                            string physicalPath = Server.MapPath(filePath);
                            string newPath = physicalPath;

                            // Write binary data to the disk
                            File.WriteAllBytes(physicalPath, binary);

                            // Handle rename of the file
                            if (!String.IsNullOrEmpty(name))
                            {
                                newPath = DirectoryHelper.CombinePath(Path.GetDirectoryName(physicalPath), name);
                            }
                            if (!String.IsNullOrEmpty(extension))
                            {
                                string oldExt = Path.GetExtension(physicalPath);
                                newPath = newPath.Substring(0, newPath.Length - oldExt.Length) + extension;
                            }

                            // Move the file
                            if (newPath != physicalPath)
                            {
                                File.Move(physicalPath, newPath);
                            }
                        }
                        catch (Exception ex)
                        {
                            baseImageEditor.LblLoadFailed.Visible = true;
                            baseImageEditor.LblLoadFailed.ResourceString = "img.errors.processing";
                            ScriptHelper.AppendTooltip(baseImageEditor.LblLoadFailed, ex.Message, "help");
                            EventLogProvider.LogException("Image editor", "SAVEIMAGE", ex);
                            this.SavingFailed = true;
                        }
                    }
                    else
                    {
                        baseImageEditor.LblLoadFailed.Visible = true;
                        baseImageEditor.LblLoadFailed.ResourceString = "img.errors.rights";
                        this.SavingFailed = true;
                    }
                }
                break;

            // Process metafile
            case ImageHelper.ImageTypeEnum.Metafile:

                if (mf != null)
                {
                    if (UserInfoProvider.IsAuthorizedPerObject(mf.MetaFileObjectType, mf.MetaFileObjectID, PermissionsEnum.Modify, this.CurrentSiteName, CMSContext.CurrentUser))
                    {
                        try
                        {
                            // Test all parameters to empty values and update new value if available
                            if (name.CompareTo("") != 0)
                            {
                                if (!name.EndsWith(extension))
                                {
                                    mf.MetaFileName = name + extension;
                                }
                                else
                                {
                                    mf.MetaFileName = name;
                                }
                            }
                            if (extension.CompareTo("") != 0)
                            {
                                mf.MetaFileExtension = extension;
                            }
                            if (mimetype.CompareTo("") != 0)
                            {
                                mf.MetaFileMimeType = mimetype;
                            }

                            mf.MetaFileTitle = title;
                            mf.MetaFileDescription = description;

                            if (binary != null)
                            {
                                mf.MetaFileBinary = binary;
                                mf.MetaFileSize = binary.Length;
                            }
                            if (width > 0)
                            {
                                mf.MetaFileImageWidth = width;
                            }
                            if (height > 0)
                            {
                                mf.MetaFileImageHeight = height;
                            }

                            // Save new data
                            MetaFileInfoProvider.SetMetaFileInfo(mf);

                            if (RefreshAfterAction)
                            {
                                if (String.IsNullOrEmpty(externalControlID))
                                {
                                    baseImageEditor.LtlScript.Text = ScriptHelper.GetScript("Refresh();");
                                }
                                else
                                {
                                    baseImageEditor.LtlScript.Text = ScriptHelper.GetScript(String.Format("InitRefresh({0}, false, false, '{1}', 'refresh')", ScriptHelper.GetString(externalControlID), mf.MetaFileGUID));
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            baseImageEditor.LblLoadFailed.Visible = true;
                            baseImageEditor.LblLoadFailed.ResourceString = "img.errors.processing";
                            ScriptHelper.AppendTooltip(baseImageEditor.LblLoadFailed, ex.Message, "help");
                            EventLogProvider.LogException("Image editor", "SAVEIMAGE", ex);
                            this.SavingFailed = true;
                        }
                    }
                    else
                    {
                        baseImageEditor.LblLoadFailed.Visible = true;
                        baseImageEditor.LblLoadFailed.ResourceString = "img.errors.rights";
                        this.SavingFailed = true;
                    }
                }
                break;
        }
    }
 /// <summary>
 /// Archives sub documents of given node.
 /// </summary>
 /// <param name="parentNode">Parent node</param>
 /// <param name="tree">Tree provider</param>
 /// <param name="wm">Workflow manager</param>
 /// <param name="cultureCode">Culture code</param>
 /// <param name="siteName">Site name</param>
 /// <returns>TRUE if operation fails and whole process should be canceled.</returns>
 private bool ArchiveSubDocuments(TreeNode parentNode, TreeProvider tree, WorkflowManager wm, string cultureCode, string siteName)
 {
     DataSet subDocuments = GetSubDocuments(parentNode, tree, cultureCode, siteName);
     if (!DataHelper.DataSourceIsEmpty(subDocuments))
     {
         foreach (DataRow nodeRow in subDocuments.Tables[0].Rows)
         {
             // Get the current document
             string aliasPath = ValidationHelper.GetString(nodeRow["NodeAliasPath"], string.Empty);
             if (PerformArchive(wm, tree, GetDocument(tree, siteName, nodeRow), aliasPath))
             {
                 return true;
             }
         }
     }
     return false;
 }
Exemple #45
0
 /// <summary>
 /// WorkflowService
 /// </summary>
 public WorkflowService()
 {
     _workflowManager = new WorkflowManager();
 }
    /// <summary>
    /// Page load.
    /// </summary>
    protected void Page_Load(object sender, EventArgs e)
    {
        // Initialize control
        directUpload.Form = Form;

        directUpload.OnUploadFile += Form.RaiseOnUploadFile;
        directUpload.OnDeleteFile += Form.RaiseOnDeleteFile;
        directUpload.CheckPermissions = false;
        if (this.FieldInfo != null)
        {
            directUpload.GUIDColumnName = this.FieldInfo.Name;
            directUpload.AllowDelete = this.FieldInfo.AllowEmpty;
        }

        // Set allowed extensions
        string extensions = ValidationHelper.GetString(GetValue("extensions"), null);
        string allowedExtensions = ValidationHelper.GetString(GetValue("allowed_extensions"), null);
        if (extensions == "custom")
        {
            directUpload.AllowedExtensions = !String.IsNullOrEmpty(allowedExtensions) ? allowedExtensions : "";
        }

        // Set image auto resize configuration
        if (this.FieldInfo != null)
        {
            int width = 0;
            int height = 0;
            int maxSideSize = 0;
            ImageHelper.GetAutoResizeDimensions(FieldInfo.Settings, CMSContext.CurrentSiteName, out width, out height, out maxSideSize);
            directUpload.ResizeToWidth = width;
            directUpload.ResizeToHeight = height;
            directUpload.ResizeToMaxSideSize = maxSideSize;
        }

        // Set control properties from parent Form
        if (Form != null)
        {
            // Get node
            TreeNode node = (TreeNode)Form.EditedObject;

            // Insert mode
            if ((Form.Mode == FormModeEnum.Insert) || (Form.Mode == FormModeEnum.InsertNewCultureVersion))
            {
                directUpload.FormGUID = Form.FormGUID;
                if ((Form.ParentObject != null) && (Form.ParentObject is TreeNode))
                {
                    directUpload.NodeParentNodeID = ((TreeNode)Form.ParentObject).NodeID;
                }
                else if (node != null)
                {
                    directUpload.NodeParentNodeID = node.NodeParentID;
                }

                if (node != null)
                {
                    directUpload.NodeClassName = node.NodeClassName;
                    directUpload.SiteName = node.NodeSiteName;

                    // Set document version history
                    if (Form.Mode == FormModeEnum.InsertNewCultureVersion)
                    {
                        // Set document version history ID
                        directUpload.VersionHistoryID = node.DocumentCheckedOutVersionHistoryID;
                        directUpload.SiteName = node.NodeSiteName;
                    }
                }
            }
            // Editing existing node
            else if (node != null)
            {
                // Set appropriate control settings
                directUpload.DocumentID = node.DocumentID;
                directUpload.NodeParentNodeID = node.NodeParentID;
                directUpload.NodeClassName = node.NodeClassName;
                directUpload.SiteName = node.NodeSiteName;

                // Get the node workflow
                WorkflowManager wm = new WorkflowManager(node.TreeProvider);
                WorkflowInfo wi = wm.GetNodeWorkflow(node);
                if (wi != null)
                {
                    // Set document version history ID
                    directUpload.VersionHistoryID = node.DocumentCheckedOutVersionHistoryID;
                }
            }
        }

        // Set style properties of control
        if (!String.IsNullOrEmpty(ControlStyle))
        {
            directUpload.Attributes.Add("style", ControlStyle);
            this.ControlStyle = null;
        }
        if (!String.IsNullOrEmpty(CssClass))
        {
            directUpload.CssClass = CssClass;
            this.CssClass = null;
        }

        CheckFieldEmptiness = false;
    }
    /// <summary>
    /// Initializes the control properties.
    /// </summary>
    protected void SetupControl()
    {
        if (this.StopProcessing)
        {
            // Do nothing
        }
        else
        {
            pi = CMSContext.CurrentPageInfo;
            if (pi != null)
            {
                CMSPagePlaceholder parentPlaceHolder = PortalHelper.FindParentPlaceholder(this);

                // Nothing to render, nothing to do
                if ((!this.DisplayAddButton && !this.DisplayResetButton) || ((parentPlaceHolder != null) && (parentPlaceHolder.UsingDefaultPageTemplate)))
                {
                    this.Visible = false;
                    return;
                }

                CurrentUserInfo currentUser = CMSContext.CurrentUser;
                zoneType = WidgetZoneTypeCode.ToEnum(this.WidgetZoneType);

                // Check security
                if (((zoneType == WidgetZoneTypeEnum.Group) && !currentUser.IsGroupAdministrator(pi.NodeGroupId))
                    || ((zoneType == WidgetZoneTypeEnum.User || zoneType == WidgetZoneTypeEnum.Dashboard) && !currentUser.IsAuthenticated()))
                {
                    this.Visible = false;
                    resetAllowed = false;
                    return;
                }

                // Displaying - Editor zone only in edit mode, User/Group zone only in Live site/Preview mode
                if (((zoneType == WidgetZoneTypeEnum.Editor) && (CMSContext.ViewMode != ViewModeEnum.Edit)) ||
                    (((zoneType == WidgetZoneTypeEnum.User) || (zoneType == WidgetZoneTypeEnum.Group)) && ((CMSContext.ViewMode != ViewModeEnum.LiveSite) && (CMSContext.ViewMode != ViewModeEnum.Preview))) || ((zoneType == WidgetZoneTypeEnum.Dashboard) && ((CMSContext.ViewMode != ViewModeEnum.DashboardWidgets) || (String.IsNullOrEmpty(PortalContext.DashboardName)))))
                {
                    this.Visible = false;
                    resetAllowed = false;
                    return;
                }

                // Get current document
                TreeNode currentNode = DocumentHelper.GetDocument(pi.DocumentId, this.TreeProvider);
                if (((zoneType == WidgetZoneTypeEnum.Editor) && (!currentUser.IsEditor || (currentUser.IsAuthorizedPerDocument(currentNode, NodePermissionsEnum.Modify) == AuthorizationResultEnum.Denied))))
                {
                    this.Visible = false;
                    resetAllowed = false;
                    return;
                }

                // If use checkin checkout enabled, check if document is checkout by current user
                if (zoneType == WidgetZoneTypeEnum.Editor)
                {
                    if (currentNode != null)
                    {
                        WorkflowManager wm = new WorkflowManager(this.TreeProvider);
                        // Get workflow info
                        WorkflowInfo wi = wm.GetNodeWorkflow(currentNode);

                        // Check if node is under workflow and if use checkin checkout enabled
                        if ((wi != null) && (wi.UseCheckInCheckOut(CMSContext.CurrentSiteName)))
                        {
                            int checkedOutBy = currentNode.DocumentCheckedOutByUserID;

                            // Check if document is checkout by current user
                            if (checkedOutBy != CMSContext.CurrentUser.UserID)
                            {
                                this.Visible = false;
                                resetAllowed = false;
                                return;
                            }
                        }
                    }
                }

                // Find widget zone
                PageTemplateInfo pti = pi.PageTemplateInfo;

                // ZodeID specified directly
                if (!String.IsNullOrEmpty(this.WidgetZoneID))
                {
                    zoneInstance = pti.GetZone(this.WidgetZoneID);
                }

                // Zone not find or specified zone is not of correct type
                if ((zoneInstance != null) && (zoneInstance.WidgetZoneType != zoneType))
                {
                    zoneInstance = null;
                }

                // For delete all variants all zones are necessairy
                if (parentPlaceHolder != null)
                {
                    ArrayList zones = parentPlaceHolder.WebPartZones;
                    if (zones != null)
                    {
                        foreach (CMSWebPartZone zone in zones)
                        {
                            if ((zone.ZoneInstance != null) && (zone.ZoneInstance.WidgetZoneType == zoneType))
                            {
                                zoneInstances.Add(zone.ZoneInstance);
                                if (zoneInstance == null)
                                {
                                    zoneInstance = zone.ZoneInstance;
                                }
                            }
                        }
                    }
                }

                // No suitable zones on the page, nothing to do
                if (zoneInstance == null)
                {
                    this.Visible = false;
                    resetAllowed = false;
                    return;
                }

                // Adding is enabled
                if (this.DisplayAddButton)
                {
                    pnlAdd.Visible = true;
                    lnkAddWidget.Visible = true;
                    lnkAddWidget.Text = DataHelper.GetNotEmpty(this.AddButtonText, GetString("widgets.addwidget"));

                    int templateId = 0;
                    if (pi.PageTemplateInfo != null)
                    {
                        templateId = pi.PageTemplateInfo.PageTemplateId;
                    }

                    string script = "NewWidget('" + HttpUtility.UrlEncode(zoneInstance.ZoneID) + "', '" + HttpUtility.UrlEncode(pi.NodeAliasPath) + "', '" + templateId + "'); return false;";
                    lnkAddWidget.Attributes.Add("onclick", script);
                }

                // Reset is enabled
                if (this.DisplayResetButton)
                {
                    pnlReset.Visible = true;
                    btnReset.Text = DataHelper.GetNotEmpty(this.ResetButtonText, GetString("widgets.resettodefault"));
                    btnReset.Click += new EventHandler(btnReset_Click);

                    // Add confirmation if required
                    if (this.ResetConfirmationRequired)
                    {
                        btnReset.Attributes.Add("onclick", "if (!confirm('" + GetString("widgets.resetzoneconfirmtext") + "')) return false;");
                    }
                }

                // Set the panel css clas with dependence on actions zone type
                switch (zoneType)
                {
                    // Editor
                    case WidgetZoneTypeEnum.Editor:
                        pnlWidgetActions.CssClass = "EditorWidgetActions";
                        break;

                    // User
                    case WidgetZoneTypeEnum.User:
                        pnlWidgetActions.CssClass = "UserWidgetActions";
                        break;

                    // Group
                    case WidgetZoneTypeEnum.Group:
                        pnlWidgetActions.CssClass = "GroupWidgetActions";
                        break;

                    // Dashboard
                    case WidgetZoneTypeEnum.Dashboard:
                        pnlContextHelp.Visible = true;
                        break;
                }
            }
        }
    }
    /// <summary>
    /// Page load.
    /// </summary>
    protected void Page_Load(object sender, EventArgs e)
    {
        // Initialize control
        documentAttachments.Form = this.Form;
        documentAttachments.CheckPermissions = false;
        documentAttachments.OnUploadFile += new EventHandler(this.Form.RaiseOnUploadFile);
        documentAttachments.OnDeleteFile += new EventHandler(this.Form.RaiseOnDeleteFile);
        documentAttachments.AllowChangeOrder = ValidationHelper.GetBoolean(GetValue("changeorder"), true);
        documentAttachments.AllowPaging = ValidationHelper.GetBoolean(GetValue("paging"), true);
        documentAttachments.PageSize = ValidationHelper.GetString(GetValue("pagingsize"), "5,10,25,50,100,##ALL##");
        documentAttachments.DefaultPageSize = ValidationHelper.GetInteger(GetValue("defaultpagesize"), 5);

        if (this.FieldInfo != null)
        {
            documentAttachments.GroupGUID = this.FieldInfo.Guid;
        }

        // Set allowed extensions
        string extensions = ValidationHelper.GetString(GetValue("extensions"), null);
        string allowedExtensions = ValidationHelper.GetString(GetValue("allowed_extensions"), null);
        if ((extensions == "custom") && (!String.IsNullOrEmpty(allowedExtensions)))
        {
            documentAttachments.AllowedExtensions = allowedExtensions;
        }

        // Set image auto resize dimensions
        if (this.FieldInfo != null)
        {
            int attachmentsWidth = 0;
            int attachmentsHeight = 0;
            int attachmentsMaxSideSize = 0;
            ImageHelper.GetAutoResizeDimensions(FieldInfo.Settings, CMSContext.CurrentSiteName, out attachmentsWidth, out attachmentsHeight, out attachmentsMaxSideSize);
            documentAttachments.ResizeToWidth = attachmentsWidth;
            documentAttachments.ResizeToHeight = attachmentsHeight;
            documentAttachments.ResizeToMaxSideSize = attachmentsMaxSideSize;
        }

        // Get node
        CMS.TreeEngine.TreeNode node = (CMS.TreeEngine.TreeNode)this.Form.EditedObject;

        if ((Form.Mode == FormModeEnum.Insert) || (Form.Mode == FormModeEnum.InsertNewCultureVersion))
        {
            documentAttachments.FormGUID = Form.FormGUID;
            if ((Form.ParentObject != null) && (Form.ParentObject is CMS.TreeEngine.TreeNode))
            {
                documentAttachments.NodeParentNodeID = ((CMS.TreeEngine.TreeNode)Form.ParentObject).NodeID;
            }
            else if (node != null)
            {
                documentAttachments.NodeParentNodeID = node.NodeParentID;
            }

            if (node != null)
            {
                documentAttachments.NodeClassName = node.NodeClassName;
            }
        }
        else if (node != null)
        {
            // Set appropriate control settings
            documentAttachments.DocumentID = node.DocumentID;
            documentAttachments.NodeParentNodeID = node.NodeParentID;
            documentAttachments.NodeClassName = node.NodeClassName;
            documentAttachments.ActualNode = node;

            // Get the node workflow
            WorkflowManager wm = new WorkflowManager(node.TreeProvider);
            WorkflowInfo wi = wm.GetNodeWorkflow(node);
            if (wi != null)
            {
                // Ensure the document version
                documentAttachments.VersionHistoryID = node.DocumentCheckedOutVersionHistoryID;
            }
        }
        if ((node != null) && !string.IsNullOrEmpty(node.NodeSiteName))
        {
            documentAttachments.SiteName = node.NodeSiteName;
        }

        // Set control styles
        if (!String.IsNullOrEmpty(ControlStyle))
        {
            documentAttachments.Attributes.Add("style", ControlStyle);
            this.ControlStyle = null;
        }
        if (!String.IsNullOrEmpty(CssClass))
        {
            documentAttachments.CssClass = CssClass;
            this.CssClass = null;
        }
    }
    /// <summary>
    /// Performs necessary checks and archives document.
    /// </summary>
    /// <returns>TRUE if operation fails and whole process should be canceled.</returns>
    private bool PerformArchive(WorkflowManager wm, TreeProvider tree, TreeNode node, string aliasPath)
    {
        if (node != null)
        {
            if (!UndoPossibleCheckOut(tree, node))
            {
                return true;
            }
            try
            {
                if (currentUser.UserHasAllowedCultures && !currentUser.IsCultureAllowed(node.DocumentCulture, node.NodeSiteName))
                {
                    AddLog(string.Format(GetString("content.notallowedtomodifycultureversion"), node.DocumentCulture, node.NodeAliasPath));
                }
                else
                {
                    // Add log record
                    AddLog(HTMLHelper.HTMLEncode(node.NodeAliasPath + " (" + node.DocumentCulture + ")"));

                    // Archive document
                    wm.ArchiveDocument(node, string.Empty);
                }
            }
            catch (ThreadAbortException te)
            {
                AddLog(te.Message);
            }
            catch
            {
                AddLog(string.Format(ResHelper.GetString("content.archivenowf"), HTMLHelper.HTMLEncode(node.NodeAliasPath + " (" + node.DocumentCulture + ")")));
            }
            return false;
        }
        else
        {
            AddLog(string.Format(ResHelper.GetString("ContentRequest.DocumentNoLongerExists", currentCulture), HTMLHelper.HTMLEncode(aliasPath)));
            return false;
        }
    }
 public PracticalSchedulePendingState(WorkflowManager manager)
     : base(manager, WorkflowStates.PracticalSchedulePending)
 {
 }
    /// <summary>
    /// Performs necessary checks and publishes document.
    /// </summary>
    /// <returns>TRUE if operation fails and whole process should be canceled.</returns>
    private bool PerformPublish(WorkflowManager wm, TreeProvider tree, TreeNode node, string aliasPath)
    {
        if (node != null)
        {
            if (currentUser.UserHasAllowedCultures && !currentUser.IsCultureAllowed(node.DocumentCulture, node.NodeSiteName))
            {
                AddLog(string.Format(GetString("content.notallowedtomodifycultureversion"), node.DocumentCulture, HTMLHelper.HTMLEncode(node.NodeAliasPath)));
            }
            else
            {
                if (!UndoPossibleCheckOut(tree, node))
                {
                    return true;
                }

                WorkflowStepInfo currentStep = null;
                try
                {
                    // Try to get workflow scope
                    currentStep = wm.EnsureStepInfo(node);
                }
                catch (ThreadAbortException te)
                {
                    AddLog(te.Message);
                }
                catch
                {
                    AddLog(string.Format(ResHelper.GetString("content.publishnowf"), HTMLHelper.HTMLEncode(node.NodeAliasPath + " (" + node.DocumentCulture + ")")));
                    return false;
                }

                if (currentStep != null)
                {
                    // Publish document
                    return Publish(node, wm, currentStep);
                }
            }

            return false;
        }
        else
        {
            AddLog(string.Format(ResHelper.GetString("ContentRequest.DocumentNoLongerExists", currentCulture), HTMLHelper.HTMLEncode(aliasPath)));
            return false;
        }
    }
Exemple #52
0
        private void GenerateWorkflowItemList()
        {
            string connectionString = ConfigurationManager.ConnectionStrings["CertusDB"].ToString();
            string query;

            SqlConnection conn    = new SqlConnection(connectionString);
            SqlCommand    command = conn.CreateCommand();

            // get query
            using (Stream strm = Assembly.GetExecutingAssembly().GetManifestResourceStream("CertusCompanion.ImportQueries.WIR4.0_DS.sql"))
            {
                using (StreamReader sr = new StreamReader(strm))
                {
                    query = sr.ReadToEnd();
                }
            }

            // manipulate query
            if (workflowItemSelection == "Non-completed")
            {
                query = query.Replace("TOP", "--TOP");
                query = query.Replace("0--<cl>", $"{clientID}--<cl>");
                query = query.Replace("AND DocumentWorkflowStatus.DocumentWorkflowStatusID > 3--<c2>", "--AND DocumentWorkflowStatus.DocumentWorkflowStatusID > 3--<c2>");
            }
            else if (workflowItemSelection == "Most Recent...")
            {
                query = query.Replace("TOP 0", $"TOP {itemCount}");
                query = query.Replace("0--<cl>", $"{clientID}--<cl>");
                query = query.Replace("AND DocumentWorkflowStatus.DocumentWorkflowStatusID <= 3--<c1>", "--AND DocumentWorkflowStatus.DocumentWorkflowStatusID <= 3--<c1>");
                query = query.Replace("AND DocumentWorkflowStatus.DocumentWorkflowStatusID > 3--<c2>", "--AND DocumentWorkflowStatus.DocumentWorkflowStatusID > 3--<c2>");
            }
            else if (workflowItemSelection == "Most Recent (Non-completed)...")
            {
                query = query.Replace("TOP 0", $"TOP {itemCount}");
                query = query.Replace("0--<cl>", $"{clientID}--<cl>");
                query = query.Replace("AND DocumentWorkflowStatus.DocumentWorkflowStatusID > 3--<c2>", "--AND DocumentWorkflowStatus.DocumentWorkflowStatusID > 3--<c2>");
            }
            else if (workflowItemSelection == "Most Recent (Completed)...")
            {
                query = query.Replace("TOP 0", $"TOP {itemCount}");
                query = query.Replace("0--<cl>", $"{clientID}--<cl>");
                query = query.Replace("AND DocumentWorkflowStatus.DocumentWorkflowStatusID <= 3--<c1>", "--AND DocumentWorkflowStatus.DocumentWorkflowStatusID <= 3--<c1>");
            }

            // execute query
            command.CommandText    = query;
            command.CommandType    = CommandType.Text;
            command.CommandTimeout = 450;

            SqlDataAdapter wiAdapter = new SqlDataAdapter(command);
            DataTable      wiTable   = new DataTable();

            wiAdapter.Fill(wiTable);

            // if there is a LoadingForm, report progress
            if (WorkflowManager.CheckIfFormIsOpened("LoadingForm"))
            {
                if (Application.OpenForms[0].InvokeRequired)
                {
                    Application.OpenForms[0].Invoke(new Action(() =>
                    {
                        (Application.OpenForms["LoadingForm"] as LoadingForm).ChangeLabel($"Generating items...");
                        (Application.OpenForms["LoadingForm"] as LoadingForm).MoveBar(25);
                        (Application.OpenForms["LoadingForm"] as LoadingForm).Refresh();
                    }));
                }
                else
                {
                    (Application.OpenForms["LoadingForm"] as LoadingForm).ChangeLabel($"Generating items...");
                    (Application.OpenForms["LoadingForm"] as LoadingForm).MoveBar(25);
                    (Application.OpenForms["LoadingForm"] as LoadingForm).Refresh();
                }
            }

            // add to WI
            foreach (DataRow row in wiTable.Rows)
            {
                string   documentWorkflowItemID = row[0].ToString();
                string   CertificateID          = row[1].ToString();
                string   vendorName             = row[2].ToString();
                string   vendorID          = row[3].ToString();
                string   clID              = row[4].ToString();
                string   workflowAnalyst   = row[5].ToString();
                string   workflowAnalystID = row[6].ToString();
                string   companyAnalyst    = row[7].ToString();
                string   companyAnalystID  = row[8].ToString();
                DateTime parsedDateTimeValue;
                DateTime?emailDate = null;
                DateTime.TryParse(row[9].ToString(), out parsedDateTimeValue);
                emailDate = parsedDateTimeValue;
                string emailFromAddress = row[10].ToString();
                string subjectLine      = row[11].ToString();
                string status           = row[12].ToString();
                string certusFileID     = row[13].ToString();
                string fileName         = row[14].ToString();
                string fileSize         = row[15].ToString();
                string fileMIME         = row[16].ToString();
                string fileURL          = row[17].ToString();

                WorkflowItem wi = new WorkflowItem
                                  (
                    documentWorkflowItemID,
                    CertificateID,
                    vendorName,
                    vendorID,
                    clID,
                    null,
                    null,
                    null,
                    null,
                    workflowAnalyst,
                    workflowAnalystID,
                    companyAnalyst,
                    companyAnalystID,
                    emailDate,
                    emailFromAddress,
                    subjectLine,
                    null,
                    status,
                    certusFileID,
                    fileName,
                    fileURL,
                    fileSize,
                    fileMIME,
                    null
                                  );

                this.currentImportItems.Add(wi);
            }

            // if there is a LoadingForm, report progress
            if (WorkflowManager.CheckIfFormIsOpened("LoadingForm"))
            {
                if (Application.OpenForms[0].InvokeRequired)
                {
                    Application.OpenForms[0].Invoke(new Action(() =>
                    {
                        (Application.OpenForms["LoadingForm"] as LoadingForm).ChangeLabel($"Saving item data...");
                        (Application.OpenForms["LoadingForm"] as LoadingForm).MoveBar(25);
                        (Application.OpenForms["LoadingForm"] as LoadingForm).Refresh();
                    }));
                }
                else
                {
                    (Application.OpenForms["LoadingForm"] as LoadingForm).ChangeLabel($"Saving item data...");
                    (Application.OpenForms["LoadingForm"] as LoadingForm).MoveBar(25);
                    (Application.OpenForms["LoadingForm"] as LoadingForm).Refresh();
                }
            }

            WorkflowImportRouter(3);
        }
 /// <summary>
 /// Publishes sub documents of given node.
 /// </summary>
 /// <param name="parentNode">Parent node</param>
 /// <param name="tree">Tree provider</param>
 /// <param name="wm">Workflow manager</param>
 /// <param name="cultureCode">Culture code</param>
 /// <param name="siteName">Site name</param>
 /// <returns>TRUE if operation fails and whole process should be canceled.</returns>
 private bool PublishSubDocuments(TreeNode parentNode, TreeProvider tree, WorkflowManager wm, string cultureCode, string siteName)
 {
     // Get sub documents
     DataSet subDocuments = GetSubDocuments(parentNode, tree, cultureCode, siteName);
     if (!DataHelper.DataSourceIsEmpty(subDocuments))
     {
         foreach (DataRow nodeRow in subDocuments.Tables[0].Rows)
         {
             if (PerformPublish(wm, tree, siteName, nodeRow))
             {
                 return true;
             }
         }
     }
     return false;
 }
    protected void libraryMenuElem_OnReloadData(object sender, EventArgs e)
    {
        string[] parameters = ValidationHelper.GetString(libraryMenuElem.Parameter, string.Empty).Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
        if (parameters.Length == 2)
        {
            // Parse identifier and document culture from library parameter
            int    nodeId      = ValidationHelper.GetInteger(parameters[0], 0);
            string cultureCode = ValidationHelper.GetString(parameters[1], string.Empty);

            // Get document using based on node identifier and culture
            TreeNode node = DocumentHelper.GetDocument(nodeId, cultureCode, TreeProvider);

            bool contextMenuVisible    = false;
            bool localizeVisible       = false;
            bool editVisible           = false;
            bool uploadVisible         = false;
            bool copyVisible           = false;
            bool deleteVisible         = false;
            bool openVisible           = false;
            bool propertiesVisible     = false;
            bool permissionsVisible    = false;
            bool versionHistoryVisible = false;

            bool checkOutVisible         = false;
            bool checkInVisible          = false;
            bool undoCheckoutVisible     = false;
            bool submitToApprovalVisible = false;
            bool rejectVisible           = false;
            bool archiveVisible          = false;

            if ((node != null) && (CMSContext.CurrentUser.IsAuthorizedPerDocument(node, NodePermissionsEnum.Read) == AuthorizationResultEnum.Allowed))
            {
                // Get original node (in case of linked documents)
                TreeNode originalNode = TreeProvider.GetOriginalNode(node);

                string documentType           = ValidationHelper.GetString(node.GetValue("DocumentType"), string.Empty);
                string siteName               = CMSContext.CurrentSiteName;
                string currentDocumentCulture = CMSContext.CurrentDocumentCulture.CultureCode;

                if (CMSContext.CurrentSiteID != originalNode.NodeSiteID)
                {
                    SiteInfo si = SiteInfoProvider.GetSiteInfo(originalNode.NodeSiteID);
                    siteName = si.SiteName;
                }

                // Get permissions
                const bool authorizedToRead              = true;
                bool       authorizedToDelete            = (CMSContext.CurrentUser.IsAuthorizedPerDocument(node, NodePermissionsEnum.Delete) == AuthorizationResultEnum.Allowed);
                bool       authorizedToModify            = (CMSContext.CurrentUser.IsAuthorizedPerDocument(node, NodePermissionsEnum.Modify) == AuthorizationResultEnum.Allowed);
                bool       authorizedCultureToModify     = (CMSContext.CurrentUser.IsAuthorizedPerDocument(node, NodePermissionsEnum.Modify, false) == AuthorizationResultEnum.Allowed) && TreeSecurityProvider.HasUserCultureAllowed(NodePermissionsEnum.Modify, currentDocumentCulture, CMSContext.CurrentUser, siteName);
                bool       authorizedToModifyPermissions = (CMSContext.CurrentUser.IsAuthorizedPerDocument(node, NodePermissionsEnum.ModifyPermissions) == AuthorizationResultEnum.Allowed);
                bool       authorizedToCreate            = CMSContext.CurrentUser.IsAuthorizedToCreateNewDocument(node.NodeParentID, node.NodeClassName);
                bool       allowEditByCurrentUser        = false;

                // Hide menu when user has no 'Read' permissions on document
                libraryMenuElem.Visible = authorizedToRead;

                // First evaluation of control's visibility
                bool differentCulture = (string.Compare(node.DocumentCulture, currentDocumentCulture, StringComparison.InvariantCultureIgnoreCase) != 0);
                localizeVisible       = differentCulture && authorizedToCreate && authorizedCultureToModify;
                uploadVisible         = authorizedToModify;
                copyVisible           = authorizedToCreate && authorizedToModify;
                deleteVisible         = authorizedToDelete;
                openVisible           = authorizedToRead;
                propertiesVisible     = authorizedToModify;
                permissionsVisible    = authorizedToModifyPermissions;
                versionHistoryVisible = authorizedToModify;
                editVisible           = authorizedToModify && CMSContext.IsWebDAVEnabled(CMSContext.CurrentSiteName) && RequestHelper.IsWindowsAuthentication() && WebDAVSettings.IsExtensionAllowedForEditMode(documentType, CMSContext.CurrentSiteName);

                // Get workflow object
                WorkflowInfo wi = WorkflowManager.GetNodeWorkflow(node);

                if ((wi != null) && authorizedToModify)
                {
                    bool autoPublishChanges = wi.WorkflowAutoPublishChanges;
                    // Get current step info, do not update document
                    WorkflowStepInfo si = WorkflowManager.GetStepInfo(node, false) ?? WorkflowManager.GetFirstWorkflowStep(node, wi);

                    bool canApprove = true;

                    // If license does not allow custom steps, 'can approve' check is meaningless
                    if (WorkflowInfoProvider.IsCustomStepAllowed())
                    {
                        canApprove = WorkflowManager.CanUserApprove(node, CMSContext.CurrentUser);
                    }

                    // Get name of current workflow step
                    string stepName             = si.StepName.ToLower();
                    bool   useCheckinCheckout   = wi.UseCheckInCheckOut(CMSContext.CurrentSiteName);
                    int    nodeCheckedOutByUser = node.DocumentCheckedOutByUserID;
                    bool   nodeIsCheckedOut     = (nodeCheckedOutByUser != 0);
                    bool   allowEdit            = canApprove || (stepName == "edit") || (stepName == "published") || (stepName == "archived");

                    // If document is checked in
                    if (nodeIsCheckedOut)
                    {
                        // If checked out by current user, add the check-in button and undo checkout button
                        if (nodeCheckedOutByUser == CMSContext.CurrentUser.UserID)
                        {
                            undoCheckoutVisible    = true;
                            checkInVisible         = true;
                            allowEditByCurrentUser = allowEdit;
                        }
                    }
                    else
                    {
                        // Hide check-out menu item if user can't apporve or document is in specific step
                        if (allowEdit)
                        {
                            // If site uses check-out / check-in
                            if (useCheckinCheckout)
                            {
                                checkOutVisible = true;
                            }
                            else
                            {
                                allowEditByCurrentUser = true;
                            }
                        }
                    }

                    rejectVisible           = canApprove && !nodeIsCheckedOut && (stepName != "edit") && (stepName != "published") && (stepName != "archived") && !autoPublishChanges;
                    submitToApprovalVisible = (canApprove || ((stepName == "edit") && authorizedToRead)) && !nodeIsCheckedOut && (stepName != "published") && (stepName != "archived") && !autoPublishChanges;
                    archiveVisible          = canApprove && !nodeIsCheckedOut && (stepName == "published");
                }
                else
                {
                    allowEditByCurrentUser = true;
                }

                // Check whether the document is not checked out by another user
                editVisible   &= allowEditByCurrentUser;
                uploadVisible &= allowEditByCurrentUser;

                string parameterScript = "GetContextMenuParameter('" + libraryMenuElem.MenuID + "')";

                // Initialize edit menu item
                Guid attachmentGuid = ValidationHelper.GetGuid(node.GetValue("FileAttachment"), Guid.Empty);

                // If attachment field doesn't allow empty value and the value is empty
                if ((FieldInfo != null) && !FieldInfo.AllowEmpty && (attachmentGuid == Guid.Empty))
                {
                    submitToApprovalVisible = false;
                    archiveVisible          = false;
                    checkInVisible          = false;
                }

                // Get attachment
                AttachmentInfo ai = DocumentHelper.GetAttachment(attachmentGuid, TreeProvider, siteName, false);

                Panel previousPanel = null;
                Panel currentPanel  = pnlEdit;

                if (editVisible)
                {
                    if (ai != null)
                    {
                        // Load WebDAV edit control and initialize it
                        WebDAVEditControl editAttachment = Page.LoadControl("~/CMSModules/WebDAV/Controls/AttachmentWebDAVEditControl.ascx") as WebDAVEditControl;

                        if (editAttachment != null)
                        {
                            editAttachment.ID                  = "editAttachment";
                            editAttachment.NodeAliasPath       = node.NodeAliasPath;
                            editAttachment.NodeCultureCode     = node.DocumentCulture;
                            editAttachment.AttachmentFieldName = "FileAttachment";
                            editAttachment.FileName            = ai.AttachmentName;
                            editAttachment.IsLiveSite          = IsLiveSite;
                            editAttachment.UseImageButton      = true;
                            editAttachment.LabelText           = GetString("general.edit");
                            editAttachment.CssClass            = "Icon";
                            editAttachment.LabelCssClass       = "Name";
                            editAttachment.RefreshScript       = JavaScriptPrefix + "PerformAction(" + parameterScript + ", 'WebDAVRefresh');";
                            // Set Group ID for live site
                            editAttachment.GroupID = IsLiveSite ? node.GetIntegerValue("NodeGroupID") : 0;
                            editAttachment.ReloadData(true);

                            pnlEditPadding.Controls.Add(editAttachment);
                            pnlEditPadding.CssClass = editAttachment.EnabledResult ? "ItemPadding" : "ItemPaddingDisabled";
                        }
                    }
                    else
                    {
                        editVisible = false;
                        openVisible = false;
                    }
                }

                previousPanel = currentPanel;
                currentPanel  = pnlUpload;

                // Initialize upload menu item
                if (authorizedToModify)
                {
                    string uploaderImg  = "<img class=\"UploaderImage\" src=\"" + GetImageUrl("Design/Controls/ContextMenu/DocumentLibrary/Upload.png", IsLiveSite) + "\" alt=\"" + GetString("general.update") + "\" />";
                    string uploaderText = "<span class=\"UploaderText\">" + GetString("general.update") + "</span>";

                    StringBuilder uploaderInnerHtml = new StringBuilder();

                    bool isRTL = (IsLiveSite && CultureHelper.IsPreferredCultureRTL()) || (!IsLiveSite && CultureHelper.IsUICultureRTL());
                    if (isRTL)
                    {
                        uploaderInnerHtml.Append(uploaderText);
                        uploaderInnerHtml.Append(uploaderImg);
                    }
                    else
                    {
                        uploaderInnerHtml.Append(uploaderImg);
                        uploaderInnerHtml.Append(uploaderText);
                    }

                    // Initialize direct file uploader
                    updateAttachment.InnerDivHtml             = uploaderInnerHtml.ToString();
                    updateAttachment.InnerDivClass            = "LibraryContextUploader";
                    updateAttachment.DocumentID               = node.DocumentID;
                    updateAttachment.ParentElemID             = ClientID;
                    updateAttachment.SourceType               = MediaSourceEnum.Attachment;
                    updateAttachment.AttachmentGUIDColumnName = "FileAttachment";
                    updateAttachment.DisplayInline            = true;
                    updateAttachment.IsLiveSite               = IsLiveSite;

                    // Set allowed extensions
                    if ((FieldInfo != null) && ValidationHelper.GetString(FieldInfo.Settings["extensions"], "") == "custom")
                    {
                        // Load allowed extensions
                        updateAttachment.AllowedExtensions = ValidationHelper.GetString(FieldInfo.Settings["allowed_extensions"], "");
                    }
                    else
                    {
                        // Use site settings
                        updateAttachment.AllowedExtensions = SettingsKeyProvider.GetStringValue(siteName + ".CMSUploadExtensions");
                    }

                    updateAttachment.ReloadData();
                    SetupPanelClasses(currentPanel, previousPanel);
                }

                previousPanel = currentPanel;
                currentPanel  = pnlLocalize;

                // Initialize localize menu item
                if (localizeVisible)
                {
                    lblLocalize.RefreshText();
                    imgLocalize.AlternateText = lblLocalize.Text;
                    imgLocalize.ImageUrl      = GetImageUrl("Design/Controls/ContextMenu/DocumentLibrary/Localize.png", IsLiveSite);
                    pnlLocalize.Attributes.Add("onclick", JavaScriptPrefix + "PerformAction(" + parameterScript + ", 'Localize');");
                    SetupPanelClasses(currentPanel, previousPanel);
                }

                previousPanel = null;
                currentPanel  = pnlCopy;

                // Initialize copy menu item
                if (copyVisible)
                {
                    lblCopy.RefreshText();
                    imgCopy.ImageUrl = GetImageUrl("Design/Controls/ContextMenu/DocumentLibrary/Copy.png", IsLiveSite);
                    pnlCopy.Attributes.Add("onclick", JavaScriptPrefix + "PerformAction(" + parameterScript + ",'Copy');");
                    SetupPanelClasses(currentPanel, previousPanel);
                }

                previousPanel = currentPanel;
                currentPanel  = pnlDelete;

                // Initialize delete menu item
                if (deleteVisible)
                {
                    lblDelete.RefreshText();
                    imgDelete.ImageUrl = GetImageUrl("Design/Controls/ContextMenu/DocumentLibrary/Delete.png", IsLiveSite);
                    pnlDelete.Attributes.Add("onclick", JavaScriptPrefix + "PerformAction(" + parameterScript + ", 'Delete');");
                    SetupPanelClasses(currentPanel, previousPanel);
                }

                previousPanel = currentPanel;
                currentPanel  = pnlOpen;

                // Initialize open menu item
                if (openVisible)
                {
                    lblOpen.RefreshText();
                    imgOpen.ImageUrl = GetImageUrl("Design/Controls/ContextMenu/DocumentLibrary/Open.png", IsLiveSite);
                    if (ai != null)
                    {
                        // Get document URL
                        string attachmentUrl = CMSContext.ResolveUIUrl(AttachmentURLProvider.GetPermanentAttachmentUrl(node.NodeGUID, node.NodeAlias));
                        if (authorizedToModify)
                        {
                            attachmentUrl = URLHelper.AddParameterToUrl(attachmentUrl, "latestfordocid", ValidationHelper.GetString(node.DocumentID, string.Empty));
                            attachmentUrl = URLHelper.AddParameterToUrl(attachmentUrl, "hash", ValidationHelper.GetHashString("d" + node.DocumentID));
                        }
                        attachmentUrl = URLHelper.UpdateParameterInUrl(attachmentUrl, "chset", Guid.NewGuid().ToString());

                        if (!string.IsNullOrEmpty(attachmentUrl))
                        {
                            pnlOpen.Attributes.Add("onclick", "location.href = " + ScriptHelper.GetString(attachmentUrl) + ";");
                        }
                    }
                    SetupPanelClasses(currentPanel, previousPanel);
                }

                previousPanel = null;
                currentPanel  = pnlProperties;

                // Initialize properties menu item
                lblProperties.RefreshText();
                imgProperties.ImageUrl = GetImageUrl("Design/Controls/ContextMenu/DocumentLibrary/Properties.png", IsLiveSite);
                pnlProperties.Attributes.Add("onclick", JavaScriptPrefix + "PerformAction(" + parameterScript + ", 'Properties');");
                SetupPanelClasses(currentPanel, previousPanel);

                previousPanel = currentPanel;
                currentPanel  = pnlPermissions;

                // Initialize permissions menu item
                lblPermissions.RefreshText();
                imgPermissions.ImageUrl = GetImageUrl("Design/Controls/ContextMenu/DocumentLibrary/Permissions.png", IsLiveSite);
                pnlPermissions.Attributes.Add("onclick", JavaScriptPrefix + "PerformAction(" + parameterScript + ", 'Permissions');");
                SetupPanelClasses(currentPanel, previousPanel);

                previousPanel = currentPanel;
                currentPanel  = pnlVersionHistory;

                // Initialize version history menu item
                lblVersionHistory.RefreshText();
                imgVersionHistory.ImageUrl = GetImageUrl("Design/Controls/ContextMenu/DocumentLibrary/VersionHistory.png", IsLiveSite);
                pnlVersionHistory.Attributes.Add("onclick", JavaScriptPrefix + "PerformAction(" + parameterScript + ", 'VersionHistory');");
                SetupPanelClasses(currentPanel, previousPanel);

                previousPanel = null;
                currentPanel  = pnlCheckOut;

                // Initialize checkout menu item
                if (checkOutVisible)
                {
                    lblCheckOut.RefreshText();
                    imgCheckOut.ImageUrl = GetImageUrl("Design/Controls/ContextMenu/DocumentLibrary/CheckOut.png", IsLiveSite);
                    pnlCheckOut.Attributes.Add("onclick", JavaScriptPrefix + "PerformAction(" + parameterScript + ", 'CheckOut');");
                    SetupPanelClasses(currentPanel, previousPanel);
                }

                previousPanel = currentPanel;
                currentPanel  = pnlCheckIn;

                // Initialize checkin menu item
                if (checkInVisible)
                {
                    lblCheckIn.RefreshText();
                    imgCheckIn.ImageUrl = GetImageUrl("Design/Controls/ContextMenu/DocumentLibrary/CheckIn.png", IsLiveSite);
                    pnlCheckIn.Attributes.Add("onclick", JavaScriptPrefix + "PerformAction(" + parameterScript + ", 'CheckIn');");
                    SetupPanelClasses(currentPanel, previousPanel);
                }

                previousPanel = currentPanel;
                currentPanel  = pnlUndoCheckout;

                // Initialize undo checkout menu item
                if (undoCheckoutVisible)
                {
                    lblUndoCheckout.RefreshText();
                    imgUndoCheckout.ImageUrl = GetImageUrl("Design/Controls/ContextMenu/DocumentLibrary/UndoCheckout.png", IsLiveSite);
                    pnlUndoCheckout.Attributes.Add("onclick", JavaScriptPrefix + "PerformAction(" + parameterScript + ", 'UndoCheckout');");
                    SetupPanelClasses(currentPanel, previousPanel);
                }

                previousPanel = currentPanel;
                currentPanel  = pnlSubmitToApproval;

                // Initialize submit to approval / publish menu item
                if (submitToApprovalVisible)
                {
                    if (wi != null)
                    {
                        // Get next step info
                        WorkflowStepInfo nsi = WorkflowManager.GetNextStepInfo(node);
                        if (nsi.StepName.ToLower() == "published")
                        {
                            // Set 'Publish' label
                            lblSubmitToApproval.ResourceString = "general.publish";
                        }
                    }

                    lblSubmitToApproval.RefreshText();
                    imgSubmitToApproval.ImageUrl = GetImageUrl("Design/Controls/ContextMenu/DocumentLibrary/SubmitToApproval.png", IsLiveSite);
                    pnlSubmitToApproval.Attributes.Add("onclick", JavaScriptPrefix + "PerformAction(" + parameterScript + ", 'SubmitToApproval');");
                    SetupPanelClasses(currentPanel, previousPanel);
                }

                previousPanel = currentPanel;
                currentPanel  = pnlReject;

                // Initialize reject menu item
                if (rejectVisible)
                {
                    lblReject.RefreshText();
                    imgReject.ImageUrl = GetImageUrl("Design/Controls/ContextMenu/DocumentLibrary/Reject.png", IsLiveSite);
                    pnlReject.Attributes.Add("onclick", JavaScriptPrefix + "PerformAction(" + parameterScript + ", 'Reject');");
                    SetupPanelClasses(currentPanel, previousPanel);
                }

                previousPanel = currentPanel;
                currentPanel  = pnlArchive;

                // Initialize archive menu item
                if (archiveVisible)
                {
                    lblArchive.RefreshText();
                    imgArchive.ImageUrl = GetImageUrl("Design/Controls/ContextMenu/DocumentLibrary/Archive.png", IsLiveSite);
                    pnlArchive.Attributes.Add("onclick", JavaScriptPrefix + "PerformAction(" + parameterScript + ", 'Archive');");
                    SetupPanelClasses(currentPanel, previousPanel);
                }

                // Set up visibility of menu items
                pnlLocalize.Visible       = localizeVisible;
                pnlUpload.Visible         = uploadVisible;
                pnlDelete.Visible         = deleteVisible;
                pnlCopy.Visible           = copyVisible;
                pnlOpen.Visible           = openVisible;
                pnlProperties.Visible     = propertiesVisible;
                pnlPermissions.Visible    = permissionsVisible;
                pnlVersionHistory.Visible = versionHistoryVisible;
                pnlEdit.Visible           = editVisible;

                pnlCheckOut.Visible         = checkOutVisible;
                pnlCheckIn.Visible          = checkInVisible;
                pnlUndoCheckout.Visible     = undoCheckoutVisible;
                pnlSubmitToApproval.Visible = submitToApprovalVisible;
                pnlReject.Visible           = rejectVisible;
                pnlArchive.Visible          = archiveVisible;

                // Set up visibility of whole menu
                contextMenuVisible = true;
            }

            // Set up visibility of separators
            bool firstGroupVisible  = editVisible || uploadVisible || localizeVisible;
            bool secondGroupVisible = copyVisible || deleteVisible || openVisible;
            bool thirdGroupVisible  = propertiesVisible || permissionsVisible || versionHistoryVisible;
            bool fourthGroupVisible = checkOutVisible || checkInVisible || undoCheckoutVisible || submitToApprovalVisible || rejectVisible || archiveVisible;

            pnlSep1.Visible = firstGroupVisible && secondGroupVisible;
            pnlSep2.Visible = secondGroupVisible && thirdGroupVisible;
            pnlSep3.Visible = thirdGroupVisible && fourthGroupVisible;

            // Setup 'No action available' menu item
            pnlNoAction.Visible = !contextMenuVisible;
            lblNoAction.RefreshText();
        }
    }
    /// <summary>
    /// Performs actions necessary to select particular item from a list.
    /// </summary>
    private void SelectMediaItem(string argument)
    {
        if (!string.IsNullOrEmpty(argument))
        {
            Hashtable argTable = CMSModules_Content_Controls_Dialogs_LinkMediaSelector_MediaView.GetArgumentsTable(argument);
            if (argTable.Count >= 2)
            {
                // Get information from argument
                string name = argTable["name"].ToString();
                string ext = argTable["attachmentextension"].ToString();
                int imageWidth = ValidationHelper.GetInteger(argTable["attachmentimagewidth"], 0);
                int imageHeight = ValidationHelper.GetInteger(argTable["attachmentimageheight"], 0);
                int nodeID = ValidationHelper.GetInteger(argTable["nodeid"], NodeID);
                long size = ValidationHelper.GetLong(argTable["attachmentsize"], 0);
                string url = argTable["url"].ToString();
                string aliasPath = null;

                // Do not update properties when selecting recently edited image item
                bool avoidPropUpdate = false;

                // Remember last selected attachment GUID
                if (SourceType == MediaSourceEnum.DocumentAttachments)
                {
                    Guid attGuid = ValidationHelper.GetGuid(argTable["attachmentguid"], Guid.Empty);

                    avoidPropUpdate = (LastAttachmentGuid == attGuid);

                    LastAttachmentGuid = attGuid;
                    ItemToColorize = LastAttachmentGuid;
                }
                else
                {
                    aliasPath = argTable["nodealiaspath"].ToString();
                    Guid nodeAttGuid = ValidationHelper.GetGuid(argTable["attachmentguid"], Guid.Empty);
                    Properties.SiteDomainName = mediaView.SiteObj.DomainName;

                    avoidPropUpdate = (ItemToColorize == nodeAttGuid);

                    ItemToColorize = nodeAttGuid;
                    if (ItemToColorize == Guid.Empty)
                    {
                        ItemToColorize = ValidationHelper.GetGuid(argTable["nodeguid"], Guid.Empty);
                    }
                }

                avoidPropUpdate = (avoidPropUpdate && IsEditImage);
                if (!avoidPropUpdate)
                {
                    if (SourceType == MediaSourceEnum.DocumentAttachments)
                    {
                        int versionHistoryId = 0;

                        if (TreeNodeObj != null)
                        {
                            // Get the node workflow
                            WorkflowManager wm = new WorkflowManager(TreeNodeObj.TreeProvider);
                            WorkflowInfo wi = wm.GetNodeWorkflow(TreeNodeObj);
                            if (wi != null)
                            {
                                // Get the document version
                                versionHistoryId = TreeNodeObj.DocumentCheckedOutVersionHistoryID;
                            }
                        }

                        MediaItem item = InitializeMediaItem(name, ext, imageWidth, imageHeight, size, url, null, versionHistoryId, nodeID, aliasPath);

                        SelectMediaItem(item);
                    }
                    else
                    {
                        // Select item
                        SelectMediaItem(name, ext, imageWidth, imageHeight, size, url, null, nodeID, aliasPath);
                    }
                }
            }
        }
    }
Exemple #56
0
 public AdditionalClassesCompletedState(WorkflowManager manager)
     : base(manager, WorkflowStates.AdditionalClassesCompleted)
 {
 }
    /// <summary>
    /// Creates new page(CMS.MenuItem) and assignes selected template.
    /// </summary>
    protected void Save(bool createAnother)
    {
        // Check security
        CheckSecurity(true);

        string newPageName = txtPageName.Text.Trim();

        string errorMessage = null;

        if (!String.IsNullOrEmpty(newPageName))
        {
            // Limit length to 100 characters
            newPageName = TextHelper.LimitLength(newPageName, TreePathUtils.MaxNameLength, String.Empty);
        }
        else
        {
            errorMessage = GetString("newpage.nameempty");
        }

        if (parentNodeId == 0)
        {
            errorMessage = GetString("newpage.invalidparentnode");
        }

        // If error, show error message and return
        if (String.IsNullOrEmpty(errorMessage))
        {
            TreeProvider tree = new TreeProvider(CMSContext.CurrentUser);
            TreeNode node = TreeNode.New("CMS.MenuItem", tree);

            // Load default data
            FormHelper.LoadDefaultValues(node);

            node.DocumentName = newPageName;
            node.SetValue("MenuItemName", newPageName);
            lblError.Style.Remove("display");

            node.DocumentPageTemplateID = selTemplate.EnsureTemplate(node.DocumentName, ref errorMessage);

            // Switch to design mode (the template is empty at this moment)
            if (selTemplate.NewTemplateIsEmpty && !createAnother)
            {
                CMSContext.ViewMode = ViewModeEnum.Design;
            }

            // Insert node if no error
            if (String.IsNullOrEmpty(errorMessage))
            {
                node.DocumentCulture = CMSContext.PreferredCultureCode;

                // Insert the document
                DocumentHelper.InsertDocument(node, parentNodeId, tree);
                //node.Insert(parentNodeId);

                // Create default SKU if configured
                if (ModuleEntry.CheckModuleLicense(ModuleEntry.ECOMMERCE, URLHelper.GetCurrentDomain(), FeatureEnum.Ecommerce, VersionActionEnum.Insert))
                {
                    bool? skuCreated = node.CreateDefaultSKU();
                    if (skuCreated.HasValue && !skuCreated.Value)
                    {
                        lblError.Text = GetString("com.CreateDefaultSKU.Error");
                    }
                }

                if (node.NodeSKUID > 0)
                {
                    DocumentHelper.UpdateDocument(node, tree);
                }

                // Automatically publish
                // Check if allowed 'Automatically publish changes'
                WorkflowManager wm = new WorkflowManager(tree);
                WorkflowInfo wi = wm.GetNodeWorkflow(node);
                if ((wi != null) && wi.WorkflowAutoPublishChanges && !wi.UseCheckInCheckOut(CMSContext.CurrentSiteName))
                {
                    wm.AutomaticallyPublish(node, wi, null);
                }

                // Process create another flag
                string script = null;
                if (createAnother)
                {
                    script = ScriptHelper.GetScript("parent.PassiveRefresh(" + node.NodeParentID + ", " + node.NodeParentID + "); parent.CreateAnother();");
                }
                else
                {
                    script = ScriptHelper.GetScript("parent.RefreshTree(" + node.NodeID + ", " + node.NodeID + ");");
                    script += ScriptHelper.GetScript("parent.SelectNode(" + node.NodeID + ");");
                }

                ScriptHelper.RegisterClientScriptBlock(Page, typeof(string), "Refresh", script);
            }
        }

        // Insert node if no error
        if (!String.IsNullOrEmpty(errorMessage))
        {
            lblError.Text = errorMessage;
            lblError.Visible = true;
            return;
        }
    }
 public ParkingTestScheduledState(WorkflowManager manager)
     : base(manager, WorkflowStates.ParkingTestScheduled)
 {
 }
    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);
        }
    }
    protected void Page_Load(object sender, EventArgs e)
    {
        #region 接收参数

        if (this.Request.QueryString["TaskIDs"] == null)
        {
            this.Response.Write("{\"ExecResult\":\"Failed\",\"ErrorMsg\":\"Missing required query string.\"}");
            return;
        }
        string sTaskIDs = this.Request.QueryString["TaskIDs"].ToString();
        if (Regex.IsMatch(sTaskIDs, @"^([1-9]\d*)(,[1-9]\d*)*$") == false)
        {
            this.Response.Write("{\"ExecResult\":\"Failed\",\"ErrorMsg\":\"Invalid query string[" + sTaskIDs + "].\"}");
            return;
        }

        // LoanID
        bool bIsValid = PageCommon.ValidateQueryString(this, "LoanID", QueryStringType.ID);
        if (bIsValid == false)
        {
            this.Response.Write("{\"ExecResult\":\"Failed\",\"ErrorMsg\":\"Missing required query string.\"}");
            return;
        }
        string sLoanID = this.Request.QueryString["LoanID"].ToString();
        int    iLoanID = Convert.ToInt32(sLoanID);

        #endregion

        // json示例
        // {"ExecResult":"Success","ErrorMsg":""}
        // {"ExecResult":"Failed","ErrorMsg":"执行数据库脚本时发生错误。"}

        string sExecResult = string.Empty;
        string sErrorMsg   = string.Empty;
        string sLoanClosed = "No";
        string result      = "";
        bool   bIsSuccess  = false;
        try
        {
            // workflow api
            string[] TaskIDArray = sTaskIDs.Split(',');
            foreach (string sTaskID in TaskIDArray)
            {
                int iTaskID = Convert.ToInt32(sTaskID);

                #region get loan task info

                LoanTasks LoanTaskManager = new LoanTasks();
                DataTable LoanTaskInfo    = LoanTaskManager.GetLoanTaskInfo(iTaskID);
                if (LoanTaskInfo.Rows.Count == 0)
                {
                    sErrorMsg = "Failed to delete the tasks(s) invalid task id.";
                    return;
                }
                string sLoanStageID = LoanTaskInfo.Rows[0]["LoanStageId"].ToString();
                if (sLoanStageID == string.Empty)
                {
                    sErrorMsg = "Failed to delete the task(s) invalid Stage Id";
                    return;
                }
                int iLoanStageID = Convert.ToInt32(sLoanStageID);

                #endregion

                #region delete task

                bIsSuccess = LPWeb.DAL.WorkflowManager.DeleteTask(iTaskID, this.CurrUser.iUserID);

                if (bIsSuccess == false)
                {
                    sErrorMsg = "Failed to delete the task(s) due to a Workflow Manager problem.";
                    return;
                }
                bool StageCompletedAfter = LPWeb.BLL.WorkflowManager.StageCompleted(iLoanStageID);

                #endregion
                if (StageCompletedAfter)
                {
                    #region update point file stage

                    #region invoke PointManager.UpdateStage()

                    string sError = LoanTaskCommon.UpdatePointFileStage(iLoanID, this.CurrUser.iUserID, iLoanStageID);

                    // the last one, sleep 1 second
                    System.Threading.Thread.Sleep(1000);

                    if (sError == string.Empty) // success
                    {
                        bIsSuccess = true;
                        sErrorMsg  = "Deleted the task(s) successfully.";
                    }
                    else
                    {
                        sErrorMsg = "Deleted the task(s) but failed to update stage date in Point.";
                        return;
                    }

                    if (WorkflowManager.IsLoanClosed(iLoanID))
                    {
                        sLoanClosed = "Yes";
                    }

                    #endregion

                    #endregion
                }
            }
            return;
        }
        catch (Exception ex)
        {
            sErrorMsg = "Failed to delete selected task(s): " + ex.ToString().Replace("\"", "\\\"");
            return;
        }
        finally
        {
            string sEmailTemplateID = "";
            if (bIsSuccess)
            {
                result = "{\"ExecResult\":\"Success\",\"ErrorMsg\":\"" + sErrorMsg + "\",\"EmailTemplateID\":\"" + sEmailTemplateID + "\",\"LoanClosed\":\"" + sLoanClosed + "\"}";
            }
            else
            {
                result = "{\"ExecResult\":\"Failed\",\"ErrorMsg\":\"" + sErrorMsg + "\"}";
            }
            Response.Write(result);
        }
    }