外部Eメールアドレスにカスタムアラートを作成する方法

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

  •  10-12-2019
  •  | 
  •  

質問

当社では、SharePointには機密情報が保存されています。いくつかの政治的に効果的な人々は、外部の電子メールアドレスに警告を送信していることを推進しています。コンテンツを内蔵の電子メールにコンテンツと外部電子メールアドレスにコンテンツにコンテンツとともに送信するにはどうすればよいですか？

役に立ちましたか？

解決

新しいアラートテンプレートを作成する

1ボックステンプレートのコピーを作成し、名前、IDを変更し、カスタムハンドラへの呼び出しをそれぞれに変更します。

  • カスタムテンプレートに名前の最後に ".ext"があります。

  • カスタム機能はカスタムNotificationHandlerAssembly を呼び出します。 

    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は、定義されたメソッドonnotification を含むIalertNotifyHandlerインタフェースを実装しています。

    • カスタムアラートを送信しようとしました（正常な警告が失敗した場合）

    • カスタムアラート：

      • ユーザー情報リスト からPerdentEmailフィールドデータを取得します。

      • 個人用電子メールが空の場合通常のアラートを送信する

      • 個人用メールが内蔵されている場合

        • 通常の電子メールを内部に送信する

        • 外部アドレス に縮小電子メールを送信する

        • 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は、それらが追加されたものと同じテンプレート名に反転しました。

            • 既存リスト：

              • site.allwebs.listが添付のAlertTemplatesを彼らの.ext courtpart に反転させました

                { 

                    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将来のWebとその将来のリスト

                • SplistEventReceiver 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

                    • PERTOMENTEMAILはコンテンツになり、無効化時に削除されない

他のヒント

単一のリストだけで分離されている場合は、代わりにワークフローを使用できる可能性があります。Eメールアドレスの電子メールアドレスとセミコロン区切りリストの一覧を追跡するための保留リストを作成できます。アイテムが作成または編集されたとき（あなたのアラートロジックがなんであれ）電子メールアドレスの適切なリストを調べ、そのグループの消毒された電子メールをグループ化します。

ライセンス： CC-BY-SA と 帰属
所属していません sharepoint.stackexchange
scroll top