SharePoint

SharePoint Retention Policies

Marzec 1, 2018 1
Podziel się:

W rozwiązaniach SharePoint zostało wbudowanych wiele mechanizmów, które z założenia mają ułatwiać zarządzanie informacją. Jednym z tych mechanizmów jest „SharePoint Retention Policies”. W artykule został opisany sposób jego konfiguracji z poziomu użytkownika (za pomocą przeglądarki), jak również z kodu serwerowego z wykorzystaniem API SharePointa. Ponadto zostało również omówione, jak z kodu utworzyć własne zdarzenie i akcje w Retention Policies.

Zasady zarządzania informacją (SharePoint Retention Policies) umożliwiają planowanie tego, co ma się wydarzyć z elementami listy bądź dokumentami po spełnieniu ustalonych uprzednio warunków – zdarzeń. Dla lepszego zrozumienia tematu, jako przykład, możemy wskazać potrzebę utworzenia reguły, która definiuje, że wszystkie dokumenty po 2 latach od ich utworzenia należy przenieść do innej lokalizacji.
Dzięki wykorzystaniu „Zasad zarządzania informacją” możemy w łatwy sposób wyegzekwować zgodności naszego środowiska z prawem lub wewnętrznymi procesami biznesowymi.

Standardowo wyzwalaczami akcji, definiowanej przez politykę, jest przekroczenie daty, która jest tworzona z daty pobieranej z jednego z pól elementu do której jest dodawana określona liczba dni, miesięcy albo lat. Pole, które można wykorzystać do tworzenia takiej daty, może być dowolnym polem typu „DateTime”.
Oprócz opisanego powyżej sposobu definiowania wyzwalacza akcji można programistycznie utworzyć własny warunek (opisany w dalszej części artykułu), w którym możemy zdefiniować własną logikę działania.
Weryfikacja, czy dla danego elementu zostały spełnione warunki uruchomienia reguły, odbywa się przez zadanie o nazwie „Expiration policy”. Zadanie to jest standardowo uruchamiane raz w tygodniu.
Standardowe akcje, które są dostępne podczas tworzenia polityki to:

  • Move to Recyle Bin
  • Permanently Delete
  • Transfer to another location
  • Start a workflow
  • Skip to next stage
  • Delete previous drafts
  • Delete all previous versions

Istnieje również możliwość programistycznego utworzenia własnej akcji (zostanie to opisane w dalszej części artykułu).

Konfiguracja Polityki zarządzania za pomocą Interfejsu przeglądarkowego

Warunkiem koniecznym do tego by można było korzystać z „SharePoint Retention Policies” jest włączony na poziomie kolekcji witryn Feature o nazwie: „Site Policy”.
Politykę zarządzania informacją można skonfigurować na trzy poniższe sposoby:

  • Utworzenie polityki w kolekcji polityk (na poziomie kolekcji witryn) – W celu utworzenia takiej policy należy z ustawień głównej witryny wybrać „Content Type Policy Templates”, który to link powinien nas przenieść do strony o wyglądzie jak na poniższym rysunku.
    Lista - Policies
    Na powyższej stronie są wyświetlone utworzone już polityki, jak również istnieje możliwość utworzenia nowej (link „Create”). Utworzoną w tym miejscu politykę będzie można wykorzystać w dowolnym „Content Type” lub bezpośrednio użyć w konfiguracji polityk dla bibliotek bądź list.
  • Utworzenie polityki dla danego kontent typu – Aby utworzyć/podłączyć politykę do Content Type należy otworzyć stronę ustawień Content Typu. Z tej strony należy przejść do linku „Information managment policy setting” – powinna otworzyć się strona jak poniższa.
    Wybieranie źródła policy
    Na powyższej stronie można wybrać jedną z wcześniej zdefiniowanych polityk (opcja „Use a site collection policy”) albo utworzyć nową politykę, która będzie wykorzystywana tylko przez ten Content Type (opcja „Define a policy…”). Wybranie opcji „Define a policy…” spowoduje otworzenie strony z definicją nowej polityki.
  • Utworzenie polityki dla listy bądź biblioteki – W celu skonfigurowania polityki bezpośrednio dla listy/biblioteki należy przejść na stronę ustawień listy i wybrać link „Information management policy settings”, powinna wyświetlić się strona z której wybieramy, czy chcemy definiować politykę dla elementów (Item) czy dla folderów (Folder), tak jak na poniższym rysunku.
    Wybór konfiguracji policy - dokument albo folder
    Po wybraniu jednej z opcji istnieje, tak jak w przypadku konfiguracji polityki Content Type, możliwość utworzenia nowej polityki (opcja „Define a policy…”) albo podłączenia do jednej z już istniejących (opcja „Use a site collection policy”).

Utworzenie polityki z API serwerowego SharePoint

Politykę Zarządzania Informacją, oprócz sposobu tworzenia przez przeglądarkę (opisanego w punkcie 2) można również utworzyć z kodu serwerowego. W celu zobrazowania tej metody poniżej został pokazany kod, który tworzy politykę dla Content Type o nazwie “ContentName”.
W pierwszej kolejności powinniśmy pobrać politykę dla danego Content Typu.

SPContentType ct = web.ContentTypes["ContentName"];
Policy policy = Policy.GetPolicy(ct);

W przypadku gdy do Content Typu nie jest podłączona żadna polityka, należy ją utworzyć.

Policy.CreatePolicy(ct,null);
ct.Update();
policy = Policy.GetPolicy(ct);
policy.Statement = "to jest opis";
policy.Update();

Po pobraniu polityki, można do niej dodać zdarzenie i akcje, które mają być przez nią wykorzystywane. Definicja polityki jest konfigurowalna za pomocą XML, tak jak w poniższym kodzie.

"<Schedules nextStageId \"2\">
   <Schedule type=\"Default\">
      <stages>
         <data stageId=\"1\">
            <formula id=\"Microsoft.Office.RecordsManagement.PolicyFeatures.Expiration.Formula.BuiltIn\">
               <number>36</number>
               <property>Created</property>
               <propertyId>8c06beca-0777-48f7-91c7-6da68bc07b69</propertyId>
               <period>days</period>
            </formula>
            <action type=\"action\" id=\"Microsoft.Office.RecordsManagement.PolicyFeatures.Expiration.Action.MoveToRecycleBin\" />
         </data>
      </stages>
   </Schedule>
</Schedules>";

Powyższy kod definiuje politykę, która uruchomi się 36 dni po utworzeniu elementu i wykona akcję polegającą na przeniesieniu elementu do kosza. Całość kodu tworząca nową politykę została zebrana poniżej.

using Microsoft.SharePoint;
using Microsoft.SharePoint.Administration;
using Microsoft.Office.RecordsManagement.InformationPolicy;
...
   using (SPSite site = new SPSite("http://siteUrl"))
   {
      using (SPWeb web = site.OpenWeb(""))
      {
         SPContentType ct = web.ContentTypes["ContentName"];
         Policy policy = Policy.GetPolicy(ct);
         if (policy==null)
         {
            Policy.CreatePolicy(ct,null);
            ct.Update();
            policy = Policy.GetPolicy(ct);
            policy.Statement = "to jest opis";
            policy.Update();
         }
         string policyCustomData= "<Schedules nextStageId \"2\">
         <Schedule type=\"Default\">
            <stages>
   	        <data stageId=\"1\">
                  <formula id=\"Microsoft.Office.RecordsManagement.PolicyFeatures.Expiration.Formula.BuiltIn\">
                     <number>36</number>
                     <property>Created</property>
                     <propertyId>8c06beca-0777-48f7-91c7-6da68bc07b69</propertyId>
                     <period>days</period>
                  </formula>
                  <action type=\"action\" id=\"Microsoft.Office.RecordsManagement.PolicyFeatures.Expiration.Action.MoveToRecycleBin\" />
               </data>
            </stages>
         </Schedule>
      </Schedules>";
      policy.Items.Add("Microsoft.Office.RecordsManagement.PolicyFeatures.Expiration", policyCustomData);
      policy.Update(); }
    }

Utworzenie własnego zdarzenia polityki (API serwera SharePoint)

W celu utworzenia własnego zdarzenia polityki należy z pomocą Visual Studio utworzyć nowy pusty projekt SharePointowy, w którym „Trust Level” został ustawiony jako „Deploy as a farm solution”. Do projektu należy dodać referencje “Microsoft.Office.Policy”.
W projekcie należy utworzyć klasę, która będzie odpowiedzialna za implementacje metody sprawdzenia i wywołania zdarzenia, w naszym przykładzie będzie to klasa o nazwie „CustomExpiration”. Do klasy należy dodać przestrzeń nazw Microsoft.Office.RecordsManagement.PolicyFeatures. Klasa musi implementować interfejs IExpirationFormula, który wymusza implementacje metody ComputeExpireDate. Metoda ComputeExpireDate powinna zwracać datę w przypadku gdy zdarzenie ma zostać wygenerowane, w przeciwnym przypadku powinna zwracać null. W poniższym kodzie została zaimplementowana logika, który sprawdza czy pole o nazwie „Status” ma wartość „Delete”, jeśli tak to zdarzenie jest generowane. Poniżej kod klasy wraz z metodą ComputeExpireDate.

namespace CustomExpiration
{
   class MyCustomExpiration: IExpirationFormula
   {
      public Nullable<DateTime> ComputeExpireDate(SPListItem item, System.Xml.XmlNode parametersData)
      {
         DateTime? expirationStatus = null;
         if (item["Status"] != null && (!string.IsNullOrEmpty(item["Status"].ToString())))
         {
            if (item["Status"].ToString() == "Delete")
               expirationStatus = DateTime.Now;
         }
         return expirationStatus;
      }
   }
}

Po utworzeniu klasy implementującej interfejs IExpirationFormula należy zarejestrować nowe zdarzenie w PolicyResourceCollection. Do tego celu, możemy wykorzystać Feature ze Scope ustawionym na poziomie farmy. W feature tym należy zdefiniować Event Receiver, który powinien implementować zdarzenie FeatureActivated tak jak w poniższym kodzie.

public override void FeatureActivated(SPFeatureReceiverProperties properties)
{
   string expirationFormulaID = "CustomExpirationFormula";
   string expirationFormulaName = "Moja formula wygasania";
   string expirationFormulaDesc = "Moja formula wygasania";
   string xmlExpirationFormula = "<PolicyResource xmlns=\"urn:schemas-microsoft-com:office:server:policy\"" + " id = \"" + expirationFormulaID + "\"" + " featureId=\"Microsoft.Office.RecordsManagement.PolicyFeatures.Expiration\"" + " type = \"DateCalculator\">
      "<Name>" + (expirationFormulaName) + "</Name>" +
      "<Description>" + (expirationFormulaDesc) + "</Description>" +
      "<AssemblyName>CustomExpiration, Version=1.0.0.0, Culture=neutral, PublicKeyToken=88bf3ea84224a2b8</AssemblyName>" +
      "<ClassName>CustomExpiration.MyCustomExpiration</ClassName>" +
   "</PolicyResource>";
   try
   {
      PolicyResourceCollection.Delete(expirationFormulaID);
   }
   catch (Exception ex)
   {
   }
   PolicyResource.ValidateManifest(xmlExpirationFormula);
   PolicyResourceCollection.Add(xmlExpirationFormula);
}

Należy zwrócić uwagę na prawidłową wartość tagów AssemblyName oraz ClassName, które będą inne niż w przykładowym kodzie.
Po skompilowaniu projektu i jego wdrożeniu powinniśmy mieć możliwość skorzystania z nowego zdarzenia. Zdarzenie będzie się uruchamiało, gdy element na którym jest zdefiniowana polityka będzie posiadał pole o nazwie „Status” i to pole będzie miało przypisaną wartość „Delete”.

Utworzenie własnej akcji polityki (API serwera SharePoint)

W celu utworzenia własnej akcji polityki wykorzystamy utworzony w poprzednim punkcie projekt SharePointowy. Do projektu należy dodać klasę, która w naszym przykładzie będzie miała nazwę CustomExpirationAction. Klasa powinna implementować interfejs IExpirationAction, który posiada metodę OnExpiration. W naszym przykładzie utworzymy prostą akcję, która będzie przypisywała do pola „Title” datę wystąpienia zdarzenia. Metoda powinna mieć więc następującą treść:

public void OnExpiration(SPListItem item, XmlNode parametersData, DateTime expiredDate)
{
   item["Title"] = expiredDate.ToString();
   item.Update();
}

Gdy mamy już utworzoną klasę, odpowiedzialną za wykonanie akcji, należy akcję dodać do kolekcji PolicyResourceCollection, w której są przechowywane zdarzenia i akcje.
Czynność tę można wykonać w analogiczny sposób jak w przypadku rejestracji zdarzenia. Kod rejestracji akcji należy więc dodać do Event Receiver Featura (po kodzie rejestrującym zdarzenie).

string expirationActionFormulaID = "CustomExpirationAction";
string expirationActionFormulaName = "Moja akcja name";
string expirationActionFormulaDesc = "Moja akcja desc";
string xmlManifestAction = "<PolicyResource xmlns='urn:schemas-microsoft-com:office:server:policy'" + " id = \"" + expirationActionFormulaID + "\"" + " featureId='Microsoft.Office.RecordsManagement.PolicyFeatures.Expiration'" + " type='Action'>" +
      "<Name>" + (expirationActionFormulaName) + "</Name>" +
      "<Description>" + (expirationActionFormulaDesc) + "</Description>" +
      "<AssemblyName>CustomExpiration, Version=1.0.0.0, Culture=neutral, PublicKeyToken=88bf3ea84224a2b8</AssemblyName>" +
      "<ClassName>CustomExpiration.CustomExpirationAction</ClassName>" +
   "</PolicyResource>";
try
{
   PolicyResourceCollection.Delete(expirationActionFormulaID);
}
catch (Exception ex)
{
}
PolicyResource.ValidateManifest(xmlManifestAction);
PolicyResourceCollection.Add(xmlManifestAction);

Należy zwrócić uwagę na prawidłową wartość tagów AssemblyName oraz ClassName, które będą inne niż w przykładowym kodzie.
Po skompilowaniu projektu i wdrożeniu rozwiązania można już korzystać z nowo dodanej akcji.

Podsumowanie

Mechanizm „SharePoint Retention Policies” jest elastycznym rozwiązaniem umożliwiającym egzekwowanie reguł dotyczących przechowywanych informacji w SharePoint. Wbudowane zdarzenia i akcje umożliwiają tworzenie polityk, które powinny sprostać większości wymagań. Jednak w przypadku potrzeb, które wykraczają poza wbudowane elementy, istniej prosta możliwość tworzenia nowych zdarzeń (wyzwalaczy) i akcji.

4.5 / 5
Kategorie: SharePoint
Paweł Siuda
Autor: Paweł Siuda
Programista SharePoint

Imię i nazwisko (wymagane)

Adres email (wymagane)

Temat

Treść wiadomości

komentarze(1)

avatar'
Kamil Pacanek
8 maja 2019 Odpowiedz

O! Dokładnie to czego szukałem Paweł!

Zostaw komentarz