Creando custom workflow activities para SharePoint 2010

Una de las mejores prácticas a la hora de crear flujos de trabajo (no solo para SharePoint) es encapsular funcionalidad común o reutilizable en actividades personalizadas, esto nos permitirá hacer flujos de trabajo mucho más mantenibles, disminuyendo así la cantidad de código que escribimos dentro del “code behind”, y es que al menos en mi muy humilde opinión, el código que escribimos debería ser mínimo y para casos muy específicos.

Además de todas las ventajas que implica el uso de actividades personalizadas, es bastante sencillo crearlas, a continuación explicaré el paso a paso de cómo crear una actividad que nos permita la creación de sub-sitios.

Pensemos en el siguiente escenario: El administrador de un sitio recibe muchas peticiones para generar sub sitios dentro del sitio que él administra, esta aburrido de hacer está tarea tan repetitiva, él lo que desea es salir temprano de la oficina y darle duro al PS3 Xbox 360, por lo que se le ocurre automatizar el proceso de solicitud de creación de sitios mediante una lista en la cual los solicitantes puedan ingresar la información fundamental para la creación del sitio y una justificación de porque lo necesitan, de esta manera el administrador solo recibe un mail de que tiene una tarea pendiente, entra a revisar la tarea y la aprueba (si es el caso) y automágicamente el sitio se provisiona, cool no!?. Pues entonces comencemos a  darle forma a los sueños de este administrador ficticio.

Primero creamos una solución de tipo de Sequential Workflow que nos servirá para probar la actividad personalizada que crearemos, después creamos un proyecto de tipo Workflow Activity Library que será en donde crearemos las actividades de workflow personalizadas.

Acto seguido agregamos una clase con el nombre que tendrá la actividad personalizada, en este caso CreateNewSubSite, y heredamos de la clase base Activity.

Creamos las propiedades que tendrán la información necesaria para crear el sub sitio: SiteName, SiteUrl, SiteLCID, TemplateName, SiteDescription, UseUniquePermissions y una propiedad para almacenar el contexto de ejecución del workflow.  Lo primero que debemos notar es que las propiedades que creamos son dependency properties (propiedades de dependencia), esto para permitir a cualquiera que use nuestra actividad poder enlazar (Binding) estas propiedades para que en tiempo de ejecución los valores se calculen. Si aún no sabes que es o para que se utilizan las property dependencies, lee esto.

public static readonly DependencyProperty SiteNameProperty = DependencyProperty.Register("SiteName", typeof(string), typeof(CreateNewSubSite));
public static readonly DependencyProperty SiteUrlProperty = DependencyProperty.Register("SiteUrl", typeof(string), typeof(CreateNewSubSite));
public static readonly DependencyProperty SiteLCIDProperty = DependencyProperty.Register("SiteLCID", typeof(uint), typeof(CreateNewSubSite), new PropertyMetadata((uint)1033));
public static readonly DependencyProperty TemplateNameProperty = DependencyProperty.Register("TemplateName", typeof(string), typeof(CreateNewSubSite), new PropertyMetadata("STS#1"));
public static readonly DependencyProperty SiteDescriptionProperty = DependencyProperty.Register("SiteDescription", typeof(string), typeof(CreateNewSubSite));
public static readonly DependencyProperty UseUniquePermissionsProperty = DependencyProperty.Register("UseUniquePermissions", typeof(bool), typeof(CreateNewSubSite));

public static DependencyProperty __ContextProperty = System.Workflow.ComponentModel.DependencyProperty.Register("__Context", typeof(Microsoft.SharePoint.WorkflowActions.WorkflowContext), typeof(CreateNewSubSite));

[Description("The name of the new subsite")]
public string SiteName
{
 get { return (string)GetValue(SiteNameProperty); }
 set { SetValue(SiteNameProperty, value); }
}

[Description("Relative Url of the new subsite. You should consider that any space will be codified, for example MySite=MySite, Financial Area=Financial%20Area")]
public string SiteUrl
{
 get { return (string)GetValue(SiteUrlProperty); }
 set { SetValue(SiteUrlProperty, value); }
}

[Description("Specify the LCID of the language that will be used to create the subsite. Example: English=1033, Spanish=3082. For more reference you can see http://technet.microsoft.com/en-us/library/ff463597.aspx")]
public uint SiteLCID
{
 get { return (uint)GetValue(SiteLCIDProperty); }
 set { SetValue(SiteLCIDProperty, value); }
}

[Description("Specify the template name that will be used to create the subsite. Example: GLOBAL#0 = Global template, STS#0 = Team Site, STS#1 = Blank Site.")]
public string TemplateName
{
 get { return (string)GetValue(TemplateNameProperty); }
 set { SetValue(TemplateNameProperty, value); }
}

[Description("Specify the description of the new subsite")]
public string SiteDescription
{
 get { return (string)GetValue(SiteDescriptionProperty); }
 set { SetValue(SiteDescriptionProperty, value); }
}

[Description("Specify if the site will have unique permissions")]
public bool UseUniquePermissions
{
 get { return (bool)GetValue(UseUniquePermissionsProperty); }
 set { SetValue(UseUniquePermissionsProperty, value); }
}

public WorkflowContext __Context
{
 get { return (WorkflowContext)GetValue(__ContextProperty); }
 set { SetValue(__ContextProperty, value); }
}

La parte medular para la creación de nuestra actividad personalizada es sobreescribir el método Execute, el cual contiene el código principal a ejecutar por la actividad personalizada. En este ejemplo tomamos los valores de las propiedades para crear el sub sitio, no sin antes ejecutar algunas validaciones.

protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
 SPSecurity.RunWithElevatedPrivileges(() =>
  {
   using (SPSite site= new SPSite (__Context.Site.ID))
   {
    using (SPWeb web = site.AllWebs[__Context.Web.ID])
    {
     //before to add the new subsite, we need to validate some settings, remember! never trust in another dev
     //first at all, validate the LCID
     SPLanguage language = SPRegionalSettings.GlobalInstalledLanguages.Cast().FirstOrDefault(x => x.LCID == SiteLCID);
     if (language == null)
     {
      throw new ArgumentException(string.Format("The value '{0}' for SiteLCID is not supported, are you sure corresponding language pack is already installed?", this.SiteLCID));
     }
     
     //then validate the name of site template
     SPWebTemplate webTemplate = site.GetWebTemplates(this.SiteLCID).Cast().FirstOrDefault(x => x.Name == this.TemplateName);
     if (webTemplate == null)
     {
      throw new ArgumentException(string.Format("The specified TemplateName='{0}' is not supported for specified language='{1}'", this.TemplateName, language.DisplayName));
     }

     //then validate the SiteUrl is unique
     if (web.Webs.Names.Contains(SiteUrl))
     {
      throw new ArgumentException("The SiteUrl is not unique, there is another subsite with the same SiteUrl");
     }

     web.Webs.Add(SiteUrl, SiteName, SiteDescription, SiteLCID, webTemplate, UseUniquePermissions, false);
    }
   }
  }
 );

 return ActivityExecutionStatus.Closed;
}

Así de simple ya tenemos una actividad personalizada lista para ser utilizada. Para este ejemplo agregamos el proyecto del workflow (WorkfllowDemo) y el proyecto de las actividades personalizadas (CustomActivities) en la misma solución, por lo que al compilar la solución automáticamente la actividad que creamos aparece en el toolbox.

Aunque también se puede solo agregar la referencia a la dll que contiene las actividades utilizando la ventana de diálogos para agregar elementos al Toolbox, para poder utilizar las actividades sin necesidad del código fuente.

El paso siguiente es arrastrar la actividad CreateNewSubSite al diseñador de workflows y configurar sus propiedades con la información para crear el subsitio.

Como se aprecia en la imagen anterior, agregamos solo una actividad más para escribir en la lista de Workflow History que el sitio fue creado correctamente. Ahora hablemos un poco a cerca de la lista que utilizaremos para las solicitudes de nuevos sitios, la cual solo contiene dos columnas: SiteName y SiteUrl. Es a esta lista a la cual asociaremos el flujo de trabajo.

Configuramos el flujo para que se ejecute al crear un nuevo elemento en la lista y podremos ver como se crea el sitio automáticamente, además del mensaje en el historial del flujo de trabajo

Les comparto el código y si tienen algún comentario o pregunta no duden en hacerla

Happy coding!

Accediendo al contexto de SharePoint desde un flujo de trabajo

Escribo este post ya que he notado que muchos desarrolladores al crear flujos de trabajo utilizando Visual Studio 2010 para SharePoint 2010, incluso para Project Server 2010, se quejan que durante la ejecución del flujo de trabajo no tienen acceso al "contexto", es decir no pueden utilizar la instancia de la clase SPContext accediéndola de la manera común Microsoft.SharePoint.SPContext.Current.

Y si bien es cierto que durante la ejecución del flujo de trabajo si intentamos acceder al contexto de SharePoint de esta manera siempre obtendremos null, la solución es crear durante la inicialización del flujo de trabajo una instancia del objeto Microsoft.SharePoint.WorkflowActions.WorkflowContext,
la cual nos permitirá acceder a gran parte de la información del contexto de ejecución de SharePoint desde el flujo de trabajo.

Para inicializar una instancia de la clase WorkflowContext, seguimos los siguientes dos sencillos pasos:

Declaramos una propiedad del tipo WorkflowContext y posteriormente la instanciamos utilizando el constructor sin parámetros que existe.

public Microsoft.SharePoint.WorkflowActions.WorkflowContext WFContext { get; set; }

public Workflow1()
{
    WFContext = new Microsoft.SharePoint.WorkflowActions.WorkflowContext();
    InitializeComponent();
}

Después inicializamos la propiedad en el evento Invoked de la actividad OnWorkflowActivated que se agrega automáticamente cuando creamos el flujo de trabajo

private void onWorkflowActivated1_Invoked(object sender, ExternalDataEventArgs e)
{
    WFContext.Initialize(workflowProperties);
}

El código completo se vería asi:

using System;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Collections;
using System.Drawing;
using System.Linq;
using System.Workflow.ComponentModel.Compiler;
using System.Workflow.ComponentModel.Serialization;
using System.Workflow.ComponentModel;
using System.Workflow.ComponentModel.Design;
using System.Workflow.Runtime;
using System.Workflow.Activities;
using System.Workflow.Activities.Rules;
using Microsoft.SharePoint;
using Microsoft.SharePoint.Workflow;
using Microsoft.SharePoint.WorkflowActions;

namespace WorkflowDemo.Workflow1
{
    public sealed partial class Workflow1 : SequentialWorkflowActivity
    {
        public Guid workflowId = default(System.Guid);
        public SPWorkflowActivationProperties workflowProperties = new SPWorkflowActivationProperties();

        public Microsoft.SharePoint.WorkflowActions.WorkflowContext WFContext { get; set; }

        public Workflow1()
        {
            WFContext = new Microsoft.SharePoint.WorkflowActions.WorkflowContext();
            InitializeComponent();
        }

        private void onWorkflowActivated1_Invoked(object sender, ExternalDataEventArgs e)
        {
            WFContext.Initialize(workflowProperties);
        }
    }
}

Y eso es todo, ahora podemos acceder al contexto de SharePoint utilizando esta propiedad.

Happy Coding!