Пример #1
0
        public WBPublishingProcess PublishDocument(WBPublishingProcess process)
        {
            SPListItem currentItem = process.CurrentItem;
            WBDocument document    = new WBDocument(process.WorkBox, currentItem);

            WBTaskFeedback feedback = new WBTaskFeedback(WBTaskFeedback.TASK_TYPE__PUBLISH, process.CurrentItemID);

            feedback.PrettyName = document.Name;

            process.LastTaskFeedback = feedback;

            // Just check that the IAO at time of publishing is captured:
            process.AddExtraMetadata(WBColumn.IAOAtTimeOfPublishing, process.OwningTeamsIAOAtTimeOfPublishing);

            if (SPContext.Current != null)
            {
                process.AddExtraMetadataIfMissing(WBColumn.PublishedBy, SPContext.Current.Web.CurrentUser);
            }
            process.AddExtraMetadataIfMissing(WBColumn.DatePublished, DateTime.Now);
            if (process.ProtectiveZone != WBRecordsType.PROTECTIVE_ZONE__PROTECTED)
            {
                // If the document is going on the public or public extranet zones then let's set a review date for 2 years from now:
                process.AddExtraMetadataIfMissing(WBColumn.ReviewDate, DateTime.Now.AddYears(2));
            }

            if (process.RecordsTypeTaxonomy == null)
            {
                WBLogging.Debug("Yeah - the process.RecordsTypeTaxonomy == null !! ");
            }
            else
            {
                WBLogging.Debug("No - the process.RecordsTypeTaxonomy was NOT  null !! ");
            }

            try
            {
                // Setting the various keys metadata values on the document to be published:
                WBRecordsType recordsType = new WBRecordsType(process.RecordsTypeTaxonomy, process.RecordsTypeUIControlValue);
                document.RecordsType    = recordsType;
                document.FunctionalArea = new WBTermCollection <WBTerm>(process.FunctionalAreasTaxonomy, process.FunctionalAreaUIControlValue);
                document.SubjectTags    = new WBTermCollection <WBSubjectTag>(process.SubjectTagsTaxonomy, process.SubjectTagsUIControlValue);
                document.OwningTeam     = new WBTeam(process.TeamsTaxonomy, process.OwningTeamUIControlValue);
                document.InvolvedTeams  = new WBTermCollection <WBTeam>(process.TeamsTaxonomy, process.InvolvedTeamsUIControlValue);
                document.ProtectiveZone = process.ProtectiveZone;
                document.Title          = process.CurrentShortTitle;

                WBLogging.Debug("Set document.Title = " + document.Title);

                document.Update();
                document.Reload();

                process.WorkBox.GenerateAndSetFilename(recordsType, document);

                document.Update();
                document.Reload();

                process.ReloadCurrentItem();
            }
            catch (Exception e)
            {
                feedback.Failed("It was not possible to save the metadata to the document before publishing it", e);
                WBLogging.Debug("It was not possible to save the metadata to the document before publishing it");

                process.CurrentItemFailed();
                return(process);
            }

            WBLogging.Debug("Starting WBRecordsManager.PublishDocument()");

            if (!document.IsSPListItem)
            {
                feedback.Failed("You can currently only publish SPListItem backed WBDocument objects");
                WBLogging.Debug("WBRecordsManager.PublishDocument(): WBDocument wasn't a list item");

                process.CurrentItemFailed();
                return(process);
            }

            WBRecord recordToReplace = null;

            if (!String.IsNullOrEmpty(process.ToReplaceRecordID))
            {
                WBLogging.Debug("WBRecordsManager.PublishDocument(): Replacing record with id: " + process.ToReplaceRecordID);
                recordToReplace = Libraries.GetRecordByID(process.ToReplaceRecordID);

                if (recordToReplace == null)
                {
                    feedback.Failed("Couldn't find the record that is meant to be replaced with Record ID = " + process.ToReplaceRecordID);
                    WBLogging.Debug("WBRecordsManager.PublishDocument(): Couldn't find the record that is meant to be replaced with Record ID = " + process.ToReplaceRecordID);

                    process.CurrentItemFailed();
                    return(process);
                }
            }


            WBLogging.Debug("WBRecordsManager.PublishDocument(): About to declare new record");

            WBRecord newRecord = null;

            try
            {
                newRecord = Libraries.DeclareNewRecord(feedback, _callingUserLogin, document, recordToReplace, process.ReplaceAction, process.ExtraMetadata);
            }
            catch (Exception e)
            {
                feedback.AddFeedback("Something went wrong with first attempt to publish document");
                feedback.AddException(e);

                WBLogging.RecordsTypes.Unexpected("Something went wrong with first attempt to publish document", e);
            }

            if (newRecord == null)
            {
                WBLogging.RecordsTypes.Unexpected("Making a second attempt to publish document");

                try
                {
                    newRecord = Libraries.DeclareNewRecord(feedback, _callingUserLogin, document, recordToReplace, process.ReplaceAction, process.ExtraMetadata);
                }
                catch (Exception e)
                {
                    feedback.Failed("Something went wrong with the second attempt to publish document", e);
                    WBLogging.RecordsTypes.Unexpected("Something went wrong with the second attempt to publish document", e);

                    process.CurrentItemFailed();
                    return(process);
                }
            }

            WBLogging.Debug("WBRecordsManager.PublishDocument(): Declared new record");
            feedback.Success();
            process.CurrentItemSucceeded();

            if (newRecord != null && newRecord.ProtectiveZone != WBRecordsType.PROTECTIVE_ZONE__PROTECTED)
            {
                String documentType           = GetDocumentType(newRecord.ProtectedMasterRecord);
                bool   needsEmailToIAONow     = (documentType == WBColumn.DOCUMENT_TYPE__SPREADSHEET);
                bool   needsEmailToWebteamNow = !String.IsNullOrEmpty(process.WebPageURL);

                if (needsEmailToIAONow || needsEmailToWebteamNow)
                {
                    //WBLogging.Debug("WBRecordsManager.PublishDocument(): process.WebPageURL has been set - so creating or updating alert email");

                    SPUser publisehdByUser   = newRecord.ProtectedMasterRecord[WBColumn.PublishedBy] as SPUser;
                    String publishedByString = "Published by: <unknown>";
                    if (publisehdByUser != null)
                    {
                        publishedByString = "Published by: " + publisehdByUser.Name;
                    }

                    List <SPUser> approvedByUsers  = newRecord.ProtectedMasterRecord[WBColumn.PublishingApprovedBy] as List <SPUser>;
                    String        approvedByString = "Approved by: <unknown>";
                    if (approvedByUsers != null)
                    {
                        approvedByString = "Approved by: " + approvedByUsers.WBxToPrettyString();
                    }

                    if (needsEmailToWebteamNow && String.IsNullOrEmpty(process.WebteamEmailAlertMessage))
                    {
                        process.WebteamEmailAlertMessage = @"<p>Dear Webteam,</p>

<p>One or more documents have been published to the Public Records Library that should be put on a web page.</p>

<p>Web page URL: " + process.WebPageURL + @"</p>

<p>Please find details of the published documents below.</p>
 
<p>" + publishedByString + "<br/>\n" + approvedByString + "</p>\n\n<p><b>Published Documents:</b></p>\n\n";
                    }

                    if (needsEmailToIAONow && String.IsNullOrEmpty(process.IAOEmailAlertMessage))
                    {
                        process.IAOEmailAlertMessage = @"<p>Dear Information Asset Owner,</p>

<p>An Excel document has been published to the Public Records Library by a member of your team.</p>

<p>As the responsible Information Asset Owner for this document, please find details of the publication below along with a link.</p>
 
<p>" + publishedByString + "<br/>\n" + approvedByString + "</p>\n\n<p><b>Published Documents:</b></p>\n\n";
                    }

                    String functionalAreaString = "";
                    if (newRecord.FunctionalArea.Count > 0)
                    {
                        functionalAreaString = newRecord.FunctionalArea[0].FullPath;
                    }

                    if (needsEmailToWebteamNow)
                    {
                        process.WebteamEmailAlertMessage += "<p><a href=\"" + newRecord.ProtectedMasterRecord.AbsoluteURL + "\">" + newRecord.ProtectedMasterRecord.Name + "</a><br/>\n(" + newRecord.ProtectiveZone + "): " + functionalAreaString + "/" + newRecord.RecordsType.FullPath + "</p>\n";
                    }
                    if (needsEmailToIAONow)
                    {
                        process.IAOEmailAlertMessage += "<p><a href=\"" + newRecord.ProtectedMasterRecord.AbsoluteURL + "\">" + newRecord.ProtectedMasterRecord.Name + "</a><br/>\nLocation: (" + newRecord.ProtectiveZone + "): " + functionalAreaString + "/" + newRecord.RecordsType.FullPath + "</p>\n";
                    }

                    if (process.PublishMode != WBPublishingProcess.PUBLISH_MODE__ALL_TOGETHER || !process.HasMoreDocumentsToPublish)
                    {
                        if (needsEmailToWebteamNow)
                        {
                            WBLogging.Debug("WBRecordsManager.PublishDocument(): Webteam Email Alert Message: " + process.WebteamEmailAlertMessage);

                            StringDictionary headers = new StringDictionary();

                            headers.Add("to", WBFarm.Local.PublicWebsiteTeamEmail);
                            headers.Add("cc", WBFarm.Local.PublicDocumentEmailAlertsTo);
                            headers.Add("content-type", "text/html");
                            headers.Add("bcc", WBFarm.Local.SendErrorReportEmailsTo);
                            headers.Add("subject", "New documents published for a web page");

                            WBUtils.SendEmail(Libraries.ProtectedMasterLibrary.Web, headers, process.WebteamEmailAlertMessage);
                        }
                        process.WebteamEmailAlertMessage = null;

                        WBLogging.Debug("WBRecordsManager.PublishDocument(): Webteam Email Alert Message: " + process.WebteamEmailAlertMessage);

                        if (needsEmailToIAONow)
                        {
                            StringDictionary headers = new StringDictionary();

                            SPUser teamsIAO = Libraries.ProtectedMasterLibrary.Web.WBxEnsureUserOrNull(process.OwningTeamsIAOAtTimeOfPublishing);
                            if (teamsIAO != null)
                            {
                                headers.Add("to", teamsIAO.Email);
                                headers.Add("cc", WBFarm.Local.PublicDocumentEmailAlertsTo);
                            }
                            else
                            {
                                headers.Add("to", WBFarm.Local.PublicDocumentEmailAlertsTo);
                            }

                            headers.Add("content-type", "text/html");
                            headers.Add("bcc", WBFarm.Local.SendErrorReportEmailsTo);
                            headers.Add("subject", "New Excel documents published for which you are IAO");

                            WBUtils.SendEmail(Libraries.ProtectedMasterLibrary.Web, headers, process.IAOEmailAlertMessage);
                            process.IAOEmailAlertMessage = null;
                        }
                    }
                }
            }
            else
            {
                WBLogging.Debug("WBRecordsManager.PublishDocument(): Either publishing failed - or web page URL was not set");
            }


            return(process);
        }