如何为外部电子邮件地址创建自定义警报？

sharepoint.stackexchange https://sharepoint.stackexchange.com//questions/76085

  •  10-12-2019
  •  | 
  •  

题

在我们公司中，我们有存储在SharePoint中的机密信息。一些政治有效的人员正在推动发送到外部电子邮件地址的警报。如何将内容发送到内部电子邮件和警报的自定义电子邮件警报，而不包含外部电子邮件地址？

有帮助吗？

解决方案

创建新的警报模板

1创建一个框模板的副本，更改名称，ID，并将调用添加到自定义处理程序到每个。

  • 使自定义模板在其名称结束时具有“.ext”。

  • 自定义功能也调用自定义NotificationshanderAssembly 

    using System;
using System.Runtime.InteropServices;
using Microsoft.SharePoint;
using Microsoft.SharePoint.Administration;
using System.Xml;

namespace Prov.Shared.CCPersonalEmail.Features.AlertTemplates
{
    public class AlertTemplatesEventReceiver : SPFeatureReceiver
    {
        public override void FeatureActivated(SPFeatureReceiverProperties properties)
        {
            //The Properties we will add to the Alert Template
            //(Since this feature lives in the same project with the 
            //IAlertNotifyHandler we just refer to our own assembly)
            string ClassToAdd = "CCPersonalClass";
            SPFeatureDefinition FeatDef = (SPFeatureDefinition)properties.Feature.Definition;
            string ourAssemblyName = FeatDef.ReceiverAssembly;

            SPWebApplication WebApplication = (SPWebApplication)properties.Feature.Parent;
            SPWebService WebService = WebApplication.WebService; 
            SPAlertTemplateCollection colSPAT = new SPAlertTemplateCollection(WebService);

            foreach (SPAlertTemplate SPAT in colSPAT)
            {
                if (SPAT.Name.Contains(".Ext"))
                {
                    SPAT.Delete();
                }
            }

            foreach (SPAlertTemplate SPAT in colSPAT)
            {
                if (SPAT.Name.Contains("SPAlertTemplateType"))
                {
                    SPAlertTemplate newSPAT = new SPAlertTemplate();
                    XmlDocument xmlSpit = new XmlDocument();

                    xmlSpit.LoadXml(SPAT.Xml.ToString());

                    //create node and add value
                    XmlNode node = xmlSpit.CreateNode(XmlNodeType.Element, "Properties", string.Empty);

                    //create 3 nodes
                    XmlNode nodeAssembly = xmlSpit.CreateElement("NotificationHandlerAssembly");
                    XmlNode nodeClassName = xmlSpit.CreateElement("NotificationHandlerClassName");
                    XmlNode nodeProperties = xmlSpit.CreateElement("NotificationHandlerProperties");

                    nodeAssembly.InnerText = ourAssemblyName;
                    nodeClassName.InnerText = ourAssemblyName.Substring(0,ourAssemblyName.IndexOf(",")) + "." + ClassToAdd;

                    //add to parent node
                    node.AppendChild(nodeAssembly);
                    node.AppendChild(nodeClassName);
                    node.AppendChild(nodeProperties);

                    //add to elements collection
                    xmlSpit.DocumentElement.AppendChild(node);

                    newSPAT.Xml = xmlSpit.InnerXml;
                    newSPAT.Name = SPAT.Name.ToString() + ".Ext";
                    newSPAT.Id = Guid.NewGuid();

                    colSPAT.Add(newSPAT);
                }
            }



            foreach (SPTimerServiceInstance timerservice in WebApplication.Farm.TimerService.Instances)
            {
                timerservice.Stop();
                timerservice.Start();
            }

        }



        public override void FeatureDeactivating(SPFeatureReceiverProperties properties)
        {
            SPWebApplication WebApplication = (SPWebApplication)properties.Feature.Parent;
            SPWebService WebService = WebApplication.WebService; 
            SPAlertTemplateCollection colSPAT = new SPAlertTemplateCollection(WebService);

            foreach (SPAlertTemplate SPAT in colSPAT)
            {
                if (SPAT.Name.Contains(".Ext"))
                {
                    SPAT.Delete();
                }
            }
        }

    }
}

    自定义通知处理程序组装

    1类CCPersonalClass实现了包含定义方法的IalertNotifyHandler接口

    • 将自定义警报发送（如果它失败发送正常警报）

    • 自定义警报：

      • 从用户信息列表中获取UsifalEmail字段数据

      • 如果个人电子邮件是空的，它只是发送正常警报

      • 如果填充了个人电子邮件

        • 将正常电子邮件发送到内部电子邮件

        • 将缩小的电子邮件发送到外部地址

        • 用http://替换http://ext-

        • 如果发送外部电子邮件删除所有细节记录，只需留下标题。

          { 

              using System;
    using Microsoft.SharePoint;
    using Microsoft.SharePoint.Utilities;
    using System.Text.RegularExpressions;
    using Framework.Logger;
    using System.Collections.Specialized;

    namespace Shared.CCPersonalEmail
    {
        class CCPersonalClass: IAlertNotifyHandler
        {
            public bool OnNotification(SPAlertHandlerParams alertHandler)
            {
                using (new SPMonitoredScope("Shared.CCPersonalClass OnNotification"))
                {
                    string siteUrl = alertHandler.siteUrl;
                    using (SPSite site = new SPSite(siteUrl + alertHandler.webUrl))
                    {
                        using (SPWeb web = site.OpenWeb())
                        {
                            try
                            {
                                return CustomAlertNotification(web, alertHandler, siteUrl);
                            }
                            catch
                            {
                                //if it fails due to configuration still the default alert should work
                                SPUtility.SendEmail(web, alertHandler.headers, alertHandler.body);
                                return false;
                            }
                        }
                    }
                }
            }
            private bool CustomAlertNotification(SPWeb web, SPAlertHandlerParams alertHandler, string siteUrl)
            {
                using (new SPMonitoredScope("Shared.CCPersonalClass CustomAlertNotification"))
                {
                    string PersonalEmail = string.Empty;
                    int eventCount = alertHandler.eventData.GetLength(0);

                    //Get the Personal Email from the User Information List
                    try
                    {
                        PersonalEmail = GetPersonalEmail(alertHandler.headers["to"], web);
                    }
                    catch (Exception e)
                    {
                        Logger.LogError(e, "CCPersonalClass");
                    }

                    //Send each alert in the alertHandler
                    for (int i = 0; i < eventCount; i++)
                    {
                        try
                        {
                            if (string.IsNullOrEmpty(PersonalEmail))
                            {
                                SPUtility.SendEmail(web, alertHandler.headers, alertHandler.body);
                            }
                            else
                            {
                                //Send a normal notification to the work email
                                SPUtility.SendEmail(web, alertHandler.headers, alertHandler.body);

                                //Send an abbreviated email to the external email
                                string txt = alertHandler.body.ToString().Replace("http://", "http://ext-");

                                //Digest messages- removing detail records
                                string strRegex = "<tr>\\s*<td class=\"[a-z]*?\"> <div class=\"nobr\">.*?</td>{0}s*</tr>|";
                                //Immediate messages- removing detail records
                                strRegex = strRegex + "<tr>\\s*<td class=\"formlabel\">.*<td class=\"altvb\">&nbsp;</td>\\s*</tr>";

                                txt = Regex.Replace(txt, strRegex, string.Empty, RegexOptions.Singleline);
                                StringDictionary PersonalHeader = alertHandler.headers;
                                PersonalHeader["cc"] = PersonalEmail;
                                SPUtility.SendEmail(web, PersonalHeader, txt);
                            }
                        }
                        catch (Exception e)
                        {
                           Logger.LogError(e, "CCPersonalClass");
                        }

                    }
                    if (eventCount > 1)
                        return true;
                    else
                        return false;
                }
            }
            private string GetPersonalEmail(string WorkEmail, SPWeb web)
            {
                using (new SPMonitoredScope("Shared.CCPersonalClass GetPersonalEmail"))
                {
                    SPQuery SelectUser = new SPQuery();
                    string SelectUserQS = string.Format("<Query><Where><Eq><FieldRef Name='EMail' /><Value Type='Text'>{0}</Value></Eq></Where></Query>", WorkEmail);
                    SelectUser.Query = SelectUserQS;
                    SPList UserList = web.Site.RootWeb.Lists["User Information List"];
                    SPListItemCollection SelectedUserCol = UserList.GetItems(SelectUser);
                    SPListItem SelectedUser = SelectedUserCol[0];
                    return (string)SelectedUser["PersonalEmail"];
                }
            }
        }
    }
          .

          设置使用外部模板 的警报

          1现有内容使用功能事件接收器更新：

          • 现有警报：

            • site.allwebs.alerts会变为与之与.ext附加的相同的模板名称

            • 现有列表：

              • site.allwebs.lists将附加的警报翻转到他们的.ext对手

                { 

                    using System;
    using System.Runtime.InteropServices;
    using System.Security.Permissions;
    using Microsoft.SharePoint;
    using Microsoft.SharePoint.Security;
    using Prov.Framework.Logger;

    namespace Prov.Shared.CCPersonalEmail.Features.CCAlerts
    {
        [Guid("a3889d39-ea91-441e-9039-157c512441e4")]
        public class CCAlertsEventReceiver : SPFeatureReceiver
        {
            // Set AlertTemplates on sites and alerts to custom templates.
            public override void FeatureActivated(SPFeatureReceiverProperties properties)
            {
                using (SPSite site = (SPSite)properties.Feature.Parent)
                {
                    AlertTemplateSelector objSelectedAlertTemplate = new AlertTemplateSelector(site);

                    //Add PersonalEmail field if it does not exist yet
                    SPFieldCollection UserInfoFields = site.RootWeb.Lists["User Information List"].Fields;
                    try
                    {
                        bool FieldExists = UserInfoFields.ContainsField("PersonalEmail");
                        if (!FieldExists)
                        {
                            UserInfoFields.Add("PersonalEmail", SPFieldType.Text, false);
                        }
                    }
                    catch (Exception e)
                    {
                        Logger.LogError(e, "CCPersonalClass");
                    }

                    foreach (SPWeb web in site.AllWebs)
                    {
                        using (web)
                        {
                            web.AllowUnsafeUpdates = true;

                            foreach (SPList List in web.Lists)
                            {
                                try
                                {
                                    List.AlertTemplate = objSelectedAlertTemplate.SwapAlertTemplate(List.AlertTemplate.Name, true);
                                    List.Update();
                                }
                                catch (Exception e)
                                {
                                    Logger.LogError(e, "CCAlertsEventReceiver");
                                }
                            }

                            foreach (SPAlert Alert in web.Alerts)
                            {
                                try
                                {
                                    Alert.AlertTemplate = objSelectedAlertTemplate.SwapAlertTemplate(Alert.AlertTemplate.Name, true);
                                    Alert.Update();
                                }
                                catch (Exception e)
                                {
                                    Logger.LogError(e, "CCAlertsEventReceiver");
                                }
                            }
                            web.AllowUnsafeUpdates = false;
                        }
                    }
                }
            }


            // Revert AlertsTemplates on sites and alerts back to out of box templates.

            public override void FeatureDeactivating(SPFeatureReceiverProperties properties)
            {
                using (SPSite site = (SPSite)properties.Feature.Parent)
                {
                    AlertTemplateSelector objSelectedAlertTemplate = new AlertTemplateSelector(site);

                    foreach (SPWeb web in site.AllWebs)
                    {
                        using (web)
                        {
                            web.AllowUnsafeUpdates = true;

                            foreach (SPList List in web.Lists)
                            {
                                try
                                {
                                    List.AlertTemplate = objSelectedAlertTemplate.SwapAlertTemplate(List.AlertTemplate.Name, false);
                                    List.Update();
                                }
                                catch (Exception e)
                                {
                                    Logger.LogError(e, "CCAlertsEventReceiver");
                                }
                            }

                            foreach (SPAlert Alert in web.Alerts)
                            {
                                try
                                {
                                    Alert.AlertTemplate = objSelectedAlertTemplate.SwapAlertTemplate(Alert.AlertTemplate.Name, false);
                                Alert.Update();
                                }
                                catch (Exception e)
                                {
                                    Logger.LogError(e, "CCAlertsEventReceiver");
                                }
                            }
                            web.AllowUnsafeUpdates = false;
                        }
                    }
                }
            }
        }
    }
                .

                通过功能激活，取消激活和onlistCreation事件处理程序 ，使用以下代码

                { 

                    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using Microsoft.SharePoint.Administration;
    using Microsoft.SharePoint;

    namespace Shared.CCPersonalEmail
    {
        class AlertTemplateSelector
        {
            private SPAlertTemplateCollection atc;
            private SPSite site;

            public AlertTemplateSelector(SPSite site)
            {
                this.site = site;
                this.atc = new SPAlertTemplateCollection((SPWebService)site.WebApplication.Parent);
            }

            public SPAlertTemplate SwapAlertTemplate(string PreviousAlert, bool isActivating)
            {

                if ((!PreviousAlert.EndsWith(".Ext")) && (isActivating))
                {
                    PreviousAlert = string.Format("{0}.Ext", PreviousAlert);
                }
                if ((PreviousAlert.EndsWith(".Ext")) && (!isActivating))
                {
                    PreviousAlert = PreviousAlert.Replace(".Ext", "");
                }

                SPAlertTemplate newTemplate = atc[PreviousAlert];
                if (newTemplate == null)
                {
                    if (isActivating)
                    {
                        newTemplate = atc["SPAlertTemplateType.GenericList.Ext"];
                    }
                    else
                    {
                        newTemplate = atc["SPAlertTemplateType.GenericList"];
                    }
                }
                return newTemplate;
            }

        }
    }
                .

                2未来的网页及其未来列表

                • splasteventreceiver listadded（）事件在网站集中创建的所有列表中翻转模板

                  { 

                      namespace Shared.CCPersonalEmail.OnListCreation
    {
        public class OnListCreation : SPListEventReceiver
        {
           public override void ListAdded(SPListEventProperties properties)
           {
                base.ListAdded(properties);
                SPWeb web = properties.Web;
                SPList List = web.Lists[properties.ListId];

                AlertTemplateSelector objSelectedAlertTemplate = new AlertTemplateSelector(web.Site);
                List.AlertTemplate = objSelectedAlertTemplate.SwapAlertTemplate(List.AlertTemplate.Name, true);
                List.Update();
           }
        }
    }
                  .

                  家政

                  1在特征激活期间

                  • 在rootweb的用户信息列表中创建一个personalemail字段

                  • 代码包含在 上方的特征激活事件接收器中

                    2在功能停用期间

                    • pustryemail成为内容，因此在停用时不会删除

其他提示

如果它是孤立的只需一个列表，您可能可以使用工作流程。您可以创建一个保留列表，以跟踪电子邮件的类型，并分号分隔的电子邮件地址列表。当创建或编辑项目时（无论您的警报逻辑应该是什么），您可以查找相应的电子邮件地址列表，并将其进行调查的电子邮件。

许可以下： CC-BY-SA 和 归因
scroll top