Archives du mot-clé sharepoint

SharePoint 2013 et l’agrégation de données provenant du SI puis exposition à une application mobile


Avez vous déjà penser à utiliser SharePoint en tant que serveur de médiation / serveur relai entre un SI et une application mobile ?

Pourquoi SharePoint pour ce usecase ?

Lorsque l’on créé une application mobile pour une entreprise, il est souvent nécessaire de récupérer des données provenant de divers systèmes (bases de données métier, applications spécifiques, AD, etc.). SharePoint offre nativement tous les outils pour ce type d’usage, se pose alors le coût de l’installation et de la mise en oeuvre d’une artillerie aussi lourde que SharePoint pour répondre à ce type de besoin. Dans certains cas, le client a déjà un serveur SharePoint pour d’autres usages, il suffit juste de valider qu’il est bien possible de créer une application web pour aller exposer des données à l’extérieur du réseau. Autrement un SharePoint Online (SAAS) ou une l’utilisation d’une plateforme hébergée via Azure ou autre solution d’hébergement peut parfaitement répondre au besoin et vous allez voir que la mise en oeuvre est relativement simple car tous les outils sont disponibles nativement.

Alimenter SharePoint en données

Business Connectivity Services permet de se connecter à une source de données tiers afin d’en exposer les données via SharePoint. Dès que la source de données est mise à jour, la (les) liste(s) externe(s) SharePoint sont mises à jour. On peut également bénéficier du système de notification présent dans SharePoint (alertes email ou SMS).

Un SPJob (tâche planifiée SharePoint) peut également être un très bon moyen de se connecter à une source de données tiers pour venir alimenter une structure de donnée SharePoint (mode PULL). Celui-ci sera déclenché à une fréquence définie, ce qui ne garantie pas autant de fraîcheur qu’avec le BCS.

La source de données tiers peut-elle même venir alimenter SharePoint (mode PUSH) via l’interface RESTful mise à disposition ou via l’API de webservice SharePoint. Ce mode est à privilégié afin de garantir la fraîcheur des données mais il faut que les équipes en charge de la source de données puissent implémenter ce type de solution, ce qui n’est pas toujours le cas.

Exposer des données en OData via SharePoint

SharePoint expose nativement les données des listes et des bibliothèques via le protocole OData (http://www.odata.org/). Donc, une fois les données stockées, peu importe leur type (documents, photos ou éléments de liste, voire même vidéos), elles peuvent être exposées via les interfaces OData natives SharePoint 2013. A partir du moment ou une donnée est stockée dans une liste ou une librairie SharePoint, elle peut être requetée en REST / JSON (format de communication à privilégié en cas de mobilité) par n’importe quel client authentifié (ex : interrogation de listdata.svc).

Une application mobile peut bien évidemment demander ses mises à jour à un serveur SharePoint en fonction de la date à laquelle elle a récupéré les dernières informations.

Construire et tester ses requêtes REST

Afin de construire des requêtes en REST, pas de mal d’éléments intéressants par ici avec des cas concrets : SharePoint REST interface with operators and functions.

Prenons un exemple : je veux récupérer tous les éléments mis à jour depuis une date donnée ainsi que les éléments associés via un lookupfield (ou champs de recherche). Voici une URL REST type : http://urldusite/_vti_bin/listdata.svc/VotreListe1?$expand=VotreLookUpField1,VotreLookUpField1/VotreLookUpField2,titre,description&$filter=Modifi%C3%A9%20gt%20datetime%272013-12-16T09%3A44%3A05%27

Côté client en HTML, pour tester votre requête une fois authentifié sur votre serveur SharePoint, le code donnerait ça :

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
<HTML>
 <HEAD>
 <script src="http://ajax.aspnetcdn.com/ajax/jQuery/jquery-1.7.2.min.js" type="text/javascript"/>
 </HEAD>

 <BODY>

 <script>
$(document).ready(function() {getdata(); });

function getdata() {
    $.ajax({
       type: "GET",
		url: "http://votresite/_vti_bin/listdata.svc/VotreListe(20)?$expand=LookUp1/Documents,titre,description",
		contentType: "application/json; charset=utf-8",
		accept: "application/json",
		success: function (xhr) {
		alert('ok');
		},
		error: function (xhr) {
		alert ('You are being redirect to the login page since you are not authenticated');
		window.location = "http://votresite";
		}
    });
}

</script>

</BODY>

</HTML>

Un super utilitaire pour avancer dans vos devs et valider/troubleshooter vos requêtes est SOAPUI qui sait très bien gérer les authent NTLM sur domaine différent, donc fonctionne parfaitement avec SharePoint.

Attention :   Il n’est pas possible de récupérer les éléments à la minute près, le webservice ne semble pas prendre en compte les heures ni les minutes indiquées dans le datetime (voir : Filter REST call on SharePoint with DateTime value). Il faut donc tout récupérer depuis la veille et refiltrer sur l’heure en local, ou si données trop volumineuses, il faut se créer un webservice WCF spécifique.

Envoi de fichiers

Afin d’envoyer des fichiers mis à jour depuis une date données, il est possible de continuer à utiliser le même principe :

  • interrogation de la bibliothèque de doc en REST par l’appli mobile
  • Envoi de la liste des docs mis à jour depuis une date donnée
  • lecture de cette liste et récupération des documents un à un grâce à leurs URLs par l’application mobile

Afin de faire un peu mieux en terme de performance dans un contexte de mobilité il est possible de créer un webservice WCF personnalisé à déployer sur votre ferme SharePoint qui prendra en entrée une date et une liste, et qui retournera un ZIP comprenant la dernière version de tous les documents mis à jour depuis cette date. Très sympa pour des populations nomades souvent en déplacement (mais ne vient pas remplacer un SkyDrive Pro qui offre une application mobile sur les grands OS mobiles et qui fera du bidirectionnel et du différentiel de version).

Exemple : Skydrive Pro pour iOS

Notifications PUSH

Plutôt que l’application cliente demande à chaque fois au serveur SharePoint de lui envoyer ses mises à jours, il est possible de programmer un système de notifications PUSH. Ce système permet au serveur d’informer l’application mobile qu’il y a eu des mises à jour. 

Le procédure est différente selon les OS mobiles ciblés mais en gros il faut suivre les étapes suivantes :

  • l’application doit s’inscrire auprès du site SharePoint et souscrire aux notifications push auprès du serveur. Lorsque la feature de notification est activée via les paramètres du site, un store de souscriptions est créé au niveau site afin de stocker toutes les informations des devices qui ont souscrits aux notifications push depuis ce site. Ceci correspond en fait à une liste cachée. Il peut y avoir maximum 2000 souscriptions par site, il est possible d’effacer celles qui ne sont plus d’actualité (Clear push notification registrations from the subscription store in SharePoint 2013)
  • il faut ensuite créer un event handler dédié à cet effet et utiliser des méthodes spécifiques à votre OS cible pour créer la notification lors la création / mise à jour / suppression de votre élément de liste. En effet il vous faudra interagir avec le système de notifications de votre OS (exemple :  Microsoft Push Notification Service -MPNS).
  • Une procédure très complète et détaillée pour Windows Phone par ici : « Procédure : configurer et utiliser les notifications push dans des applications SharePoint 2013 pour Windows Phone »

Autres features intéressantes dans un contexte de mobilité : 

Supports

Si vous désirez consulter un site, ou un simple élément SharePoint sur un device mobile, voici les OS / navigateurs supportés nativement par Microsoft.

OS

OS Version

navigateur

Smartphone Support

Tablet support

Windows Phone

Windows 7.5 or superior

Internet Explorer Mobile

Supported

NA

Windows

Windows 7 or superior

Internet Explorer

NA

Supported

iOS

5.0 or superior

(video playing needs iOS 6.0 or superior)

Safari

Supported

Supported

Android

4.0 or superior

(video playing needs Android 4.1 or superior)

Android Browser

Supported

Supported

Sources :

– Nouveautés pour les appareils mobiles dans SharePoint 2013

la bible pour commencer à développer des Apps pour SharePoint 2013 sur Windows Phone

Comment afficher les tâches affectées à un utilisateur SharePoint et à ses groupes


Cet article fait partie d’une série concernant la mise en oeuvre de liste externes et de workflows avec SharePoint. Les étapes suivantes seront passées en revue :

_______________________________________________________________________________________________

Il n’est pas possible, nativement, d’afficher toutes les tâches affectées directement et indirectement à un utilisateur. J’entends par « indirectement’, le fait qu’une tâche puisse être affectée à un groupe auquel l’utilisateur appartient, ce qui est plutôt une bonne pratique.

En effet nativement j’ai uniquement la possibilité de créer un affichage pour les tâches affectées à l’utilisateur courant mais pas ses groupes grâce au filtre dynamique [Utilisateur actif].

tasks assigned to user sharepoint

Si je veux créer un affichage des tâches qui me sont affectées de manière directe et indirecte, j’ai les possibilités suivantes :

  • SharePoint Designer pour créer l’affichage avec un requête personnalisée
  • Visual Studio pour créer l’affichage avec la même requête
  • WebPart dédiée développée via Visual Studio

L’ensemble de ces solutions reposent sur la même requête CAML , à savoir :

<Query>
<Where>
  <Or>
    <Membership Type='CurrentUserGroups'>
       <FieldRef Name='AssignedTo'/>
    </Membership>
    <Eq>
       <FieldRef Name='AssignedTo'></FieldRef>
       <Value Type='Integer'>
         <UserID/>
       </Value>
    </Eq>
 </Or>
</Where>
</Query>

Avec SharePoint Designer 2013

Pour filtrer une liste de tâches SharePoint 2013 afin d’afficher les tâches assignées à l’utilisateur courant ainsi qu’aux groupes dont il fait partie, il faut suivre la procédure suivante avec SharePoint Designer 2013 :

1 – Ouvrir le site cible et sa liste de tâches avec SharePoint Designer. Sélectionner l’affichage à modifier, clic droit -> modifier le fichier en mode avancé.

sharepoint designer assigned tasks

2 – Dans le code source, rechercher la « <Query> » associée à cette vue.

sharepoint designer query mytasks

3 – Remplacer cette requête CAML par celle indiquée ci dessus. L’élément clé étant le « CurrentUserGroups »

Avec une Visual Studio 2012 et une Visual WebPart

1 – Dans Visual Studio 2012, ajouter un nouvel élément de type Visual WebPart.

visual studio 2012 visual webpart

visual webpart visual studio 2012

2 – Remplacer le code behind par le code suivant :

using Microsoft.SharePoint;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Web.UI.WebControls.WebParts;
using System.Linq;

namespace SharePointProject1.VisualWebPart1
{

        [ToolboxItemAttribute(false)]
        public partial class VisualWebPart1 : WebPart
        {

            /// <summary>
            /// List Name property allows Web Part user to specify which tasks list to use to retrieve data.
            /// If nothing is specified, it takes Tasks as List Name.
            /// </summary>
            [Personalizable(),
            WebBrowsable,
            DefaultValue("MyTitleList"),
            DisplayName("Nom de la liste de tâche"),
            Category("Paramètres Custom")]
            public string ListName { get; set; }

            public VisualWebPart1()
            {
            }

            protected override void OnInit(EventArgs e)
            {
                base.OnInit(e);
                InitializeControl();
            }

            protected void Page_Load(object sender, EventArgs e)
            {
                try
                {
                    using (SPSite site = new SPSite(SPContext.Current.Site.Url))
                    {
                        using (SPWeb web = site.OpenWeb())
                        {
                            if (this.ListName != null && this.ListName.Length > 0)
                            {
                                this.Title = "Mes tâches de " + this.ListName;

                                SPList list = web.Lists.TryGetList(this.ListName);

                                grvTasks.DataSource = this.GetTasksEntity(list);
                                grvTasks.DataBind();

                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    throw (ex);
                }
            }

            private List<TaskEntity> GetTasksEntity(SPList list)
            {
                // Variables
                List<TaskEntity> tasks = new List<TaskEntity>();
                SPQuery myQuery = new SPQuery();
                myQuery.Query = @"<Where>
                   <Or>
                         <Membership Type='CurrentUserGroups'>
                            <FieldRef Name='AssignedTo'/>
                         </Membership>
                   <Eq>
                         <FieldRef Name='AssignedTo'></FieldRef>
                         <Value Type='Integer'>
                         <UserID/>
                         </Value>
                   </Eq>
                   </Or>
             </Where>";

                // récupération des tâches de l'utilisateur courant et des groupes auxquels il appartient
                SPListItemCollection tasksUserAndGroups = list.GetItems(myQuery);

                //assignation des valeur à une entité de type TaskEntity // création de la DataSource
                if (tasksUserAndGroups != null && tasksUserAndGroups.Count > 0)
                {
                    foreach (SPListItem item in tasksUserAndGroups)
                    {
                        TaskEntity task = new TaskEntity();

                        task.Title = this.GetFieldValue(item, "Title");
                        task.NavigateUrl = string.Concat(
                            list.DefaultEditFormUrl,
                            string.Format("?ID={0}", item.ID));
                        task.Description = this.GetFieldValue(item, "Description");
                        task.AssignedTo = this.GetFieldValue(item, "AssignedTo");
                        task.Status = this.GetFieldValue(item, "Status");

                        if (!string.IsNullOrEmpty(GetFieldValue(item, "StartDate")))
                        {
                            task.StartDate = DateTime.Parse(item["StartDate"].ToString());
                        }
                        else
                        {
                            task.StartDate = DateTime.Now;
                        }

                        if (!string.IsNullOrEmpty(GetFieldValue(item, "DueDate")))
                        {
                            task.DueDate = DateTime.Parse(item["DueDate"].ToString());
                        }
                        tasks.Add(task);
                    }

                }
                return tasks;
            }

            private string GetFieldValue(SPListItem item, string fieldName)
            {
                string strFieldValue = string.Empty;

                if (item != null && item.Fields.ContainsField(fieldName) && item[fieldName] != null)
                {
                    strFieldValue = item[fieldName].ToString();
                }

                return strFieldValue;
            }
        }

        /// <summary>
        /// Task entity for the Tasks list.
        /// </summary>
        public class TaskEntity
        {
            private string assignedTo;

            public string Title { get; set; }
            public string AssignedTo
            {
                get
                {
                    if (assignedTo.Length > 0)
                    {
                        string[] user =
                            assignedTo.Split(
                            SPFieldMultiChoiceValue.Delimiter.ToCharArray());
                        return user[user.Length - 1];
                    }

                    return string.Empty;
                }
                set { assignedTo = value; }
            }
            public string Description { get; set; }
            public string Status { get; set; }
            public DateTime StartDate { get; set; }
            public DateTime DueDate { get; set; }
            public string NavigateUrl { get; set; }

        }
    }

4 – Remplacer le code de votre fichier ASCX par le code suivant :

<%@ Assembly Name="$SharePoint.Project.AssemblyFullName$" %>
<%@ Assembly Name="Microsoft.Web.CommandUI, Version=15.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>
<%@ Register Tagprefix="SharePoint" Namespace="Microsoft.SharePoint.WebControls" Assembly="Microsoft.SharePoint, Version=15.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>
<%@ Register Tagprefix="Utilities" Namespace="Microsoft.SharePoint.Utilities" Assembly="Microsoft.SharePoint, Version=15.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>
<%@ Register Tagprefix="asp" Namespace="System.Web.UI" Assembly="System.Web.Extensions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" %>
<%@ Import Namespace="Microsoft.SharePoint" %>
<%@ Register Tagprefix="WebPartPages" Namespace="Microsoft.SharePoint.WebPartPages" Assembly="Microsoft.SharePoint, Version=15.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>
<%@ Control Language="C#" AutoEventWireup="true" CodeBehind="VisualWebPart1.ascx.cs" Inherits="SharePointProject1.VisualWebPart1.VisualWebPart1" %>

<asp:GridView ID="grvTasks" runat="server" AutoGenerateColumns="False"
    BackColor="#DEBA84" BorderColor="#DEBA84" BorderStyle="None" BorderWidth="1px"
    CellPadding="3" CellSpacing="2" EnableModelValidation="True">
    <Columns>
        <asp:HyperLinkField DataTextField="Title" HeaderText="Titre"
            DataNavigateUrlFields="NavigateUrl" />
        <asp:BoundField DataField="AssignedTo" HeaderText="Assignée à" />
        <asp:BoundField DataField="Description" HeaderText="Description" />
        <asp:BoundField DataField="Status" HeaderText="Statut" />
        <asp:BoundField DataField="StartDate" DataFormatString="{0:MMMM d, yyyy}"
            HeaderText="Date de début" />
        <asp:BoundField DataField="DueDate" HeaderText="Date de fin"
            DataFormatString="{0:MMMM d, yyyy}" />
    </Columns>
    <FooterStyle BackColor="#F7DFB5" ForeColor="#8C4510" />
    <HeaderStyle BackColor="#A55129" Font-Bold="True" ForeColor="White" />
    <PagerStyle ForeColor="#8C4510" HorizontalAlign="Center" />
    <RowStyle BackColor="#FFF7E7" ForeColor="#8C4510" />
    <SelectedRowStyle BackColor="#738A9C" Font-Bold="True" ForeColor="White" />
</asp:GridView>

5 – déployer sur votre site et ajouter la webpart à une page. Paramétrer cette webpart afin qu’elle pointe vers une liste de tâche de votre site.

visual webpart task

paramètres visual webpart

6 – Tester l’affichage. Bon OK en terme d’IHM ça casse pas des briques 🙂

mes taches sharepoint 2013

 

 

Voilà pour cette série.

Pour récapituler vous êtes capable de manipuler des données provenant d’une source de donnée externe dans un workflow de type machine à état SharePoint 2013 et d’afficher toutes ses tâches à un utilisateur donné.

 

Sources :

Utilisation des workflows SharePoint 2013


Cet article fait partie d’une série concernant la mise en oeuvre de liste externes et de workflows avec SharePoint. Les étapes suivantes seront passées en revue :

_______________________________________________________________________________________________

SharePoint est souvent cité comme une plateforme permettant de mettre en oeuvre des Workflows, cependant ses capacités Out Of the Box restent très axées sur les documents (DocFlow) et donc plutôt limitées lorsqu’on parle de dématérialisation de processus métiers.

Il est, par exemple, assez simple de mettre en oeuvre de l’approbation documentaire avant publication (usage courant)  mais dès que l’on veut aller plus loin, cela peut vite se compliquer car il faut souvent avoir recourt à des développements chronophages.

La couverture fonctionnelle native de SharePoint

Typiquement si je veux créer un workflow de demande de congés, par défaut, SharePoint ne sait pas répondre à mon besoin. Je dois utiliser, au choix, l’une des solutions suivantes, en fonction de mon profil, de mes affinités avec les outils, de mes moyens :

  • SharePoint Designer 2013
  • Visual Studio 2012
  • Une solution tierce : Nintex, K2 ou autre

Au final j’aurais probablement une liste qui référencera un type de contenu « demande de congés », qui me permettra d’offrir un formulaire complet au demandeur. Son responsable hiérarchique pourra ensuite valider cette demande via une liste de tâches dédiée, mais plusieurs problèmes ne sont pas solvables sans développement :

  • trouver dynamiquement le responsable hiérarchique de l’utilisateur courant (en comptant sur le fait que celui-ci soit systématiquement renseigné dans le profil SharePoint de l’utilisateur)
  • Gérer la visibilité d’une tâche, en effet on ne veut pas que toutes les personnes qui accèdent à la liste de tâches puissent valider la tâche qui est affectée au manager du demandeur.
  • Avoir un affichage « user friendly » des demandes en cours pour le manager et pour le demandeur. Je veux pouvoir consulter les tâches qui me sont affectés en tant qu’individu ou que groupe.
  • Avoir un reminder paramétrable si une tâche n’a pas été traitée
  • Pouvoir réassigner une tâche automatiquement au bout d’un certain temps
  • Recevoir des alertes emails spécifiques et personnalisées me permettant d’interagir directement avec ma tâche afin de valider ou non la demande via un bouton dédié
  • Avoir un reporting sur le workflow : temps de traitement, le nombre de demandes annuelles,  etc.
  • etc.

Les fonctionnalités citées ci-dessus paraissent, pour certaines, être le béaba de tout outil de workflow, et bien ce n’est pas le cas de SharePoint 2013, qui, sans paramétrage avancé + développements ne sait pas répondre à ces besoins.

Nous disposons des fondations (moteur de workflow) mais pas des murs et encore mois de la décoration (affichages user centric). Un effort à fournir qui peut parfois être conséquent !

Evolution des Workflows dans SharePoint 2013

Les workflows SharePoint 2013 reposent sur WorkFlow Foundation 4.0, qui repose lui-même sur WCF. Les évolutions notables par rapport à 2010 sont entre autres :

  • la création entièrement déclarative (plus, pu très peu, de code serveur pour interagir avec le workflow) basée sur un designer Visual Studio 2012 (plus de détail dans le prochain article)
  • le gestionnaire de workflow (Workflow Manager 1.0) devient l’élément central de l’architecture des workflows et doit être installé en plus des binaires SharePoint 2013 classiques. S’il n’est pas installé sur la plateforme, seule la création de workflow de type SharePoint 2010 est possible avec SharePoint Designer 2013 (pas de modèles 2013 visibles).
  • Le gestionnaire de workflow a été développé dans une optique Azure, ce qui permet de gérer des worfklow à grande échelle et en répartissant la charge (exécution au sein d’une architecture mutualisée prise en charge). Il offre donc une plus grande évolutivité et scalabilité aux scénariis liés aux workflows.
  • Les workflows natifs (disponibles dans l’interface d’un site SharePoint quelconque) sont uniquement des modèles SharePoint 2010.
  • REST et le Service Bus permettent d’interagir avec le workflow manager via le CSOM
  • SharePoint Designer 2013 a été grandement amélioré concernant la création de workflow et devient donc un outil privilégié dans ce type de contexte
  • évolution de la gestion et de la présentation des tâches (validation rapide via une check box, agrégation de tâches cross collection de site via l’application de service « Work Management »)

Modifications de l’architecture dans les flux de travail

Un point important est la rétrocompatibilité de ce système avec les workflows de type SharePoint 2010 qui sont toujours utilisables (le moteur est toujours présent). Plutôt rassurant pour les entreprise qui ont largement investit sur ces modèles (et il y en a) car ce ne sera pas un frein pour migrer vers SharePoint 2013. De même il est possible de continuer à développer des workflows de types SharePoint 2010, même si, avec cette nouvelle version, on se doute bien que ceux-ci ne seront pas éternels et qu’il vaut mieux privilégier un workflow de type SharePoint 2013 si possible.

Workflows Natifs SharePoint 2013

Comme précisé ci dessus, ce sont les mêmes que ceux présents dans la version 2010, ils sont d’ailleurs de type 2010. Voici les fonctionnalités que l’on retrouve au niveau de la collection de site : features workflows par défaut sharepoint 2013 Dans une bibliothèque de documents on retrouve les workflow suivants : workflows natifs sharepoint 2013

  • Approbation – SharePoint 2010 : Envoie un document pour approbation. Les approbateurs peuvent approuver ou rejeter le document, réattribuer la tâche d’approbation, ou requérir la modification du document
  • Approbation de destruction : Gère l’expiration et la rétention de documents en autorisant les membres à conserver ou supprimer les documents expirés.
  • Approbation de publication : Envoie une page pour approbation. Les approbateurs peuvent approuver ou rejeter la page, réaffecter la tâche d’approbation ou demander des modifications à la page.
  • Recueillir les commentaires : Envoie un document en révision. Les réviseurs peuvent insérer des commentaires qui seront compilés et envoyés au propriétaire du document à la fin du flux de travail.
  • Collecte des signatures : Rassemble les signatures nécessaires pour achever un document Microsoft Office.
  • Trois états : Ce flux de travail permet de suivre les éléments d’une liste.

Bien choisir son outil pour créer un nouveau workflow

SP Designer 2013 vs Visual Studio 2012 vs Solutions tierces (K2 offre, par exemple, de très bon outil de design de process et de création de formulaires).

Il faut alors choisir en fonction du profil de la personne qui va créer le workflow, s’il elle a des compétence en développement et est familière de Visual Studio ou pas.

Si l’entreprise décide d’investir plus largement sur une plateforme de développement de processus métier critiques ou centraux pour certaines équipe, des outils tels que Nintex ou K2 BlackPearl / K2 BlackPoint

Fonctionnalité / requis SharePoint Designer Visual Studio
Permet le développement rapide de Workflow Oui Oui
Permet de réutiliser des workflows Un workflow peut être utilisé uniquement par la liste ou bibliothèque à laquelle il a été développé. Toutefois, SharePoint Designer fournit des workflow réutilisables qui peutvent être utilisés plusieurs fois dans le même site. Un workflow peut être écrit comme un modèle de sorte qu’après avoir déployé, il peut être réutilisé et associé à une liste ou une bibliothèque.
Inclure un workflow dans une solution SharePoint (WSP) ou application pour SharePoint Non Oui
Permet de créer des actions personnalisées Non. Toutefois, SharePoint Designer peut consommer et implémenter des actions personnalisées qui sont créées et déployées à l’aide de Visual Studio. Oui. En revanche, vous devez savoir que dans Visual Studio, les activités sous-jacentes, pas les opérations correspondantes, sont utilisées.
Permet d’écrire du code personnalisé Non Non. Nouveauté SharePoint 2013, workflow déclaratifs uniquement et Visual Studio s’appuie sur le designer pour le développement de workflow.
Utilisation de Visio Professional pour créer une logique de workflow Oui Non
Déploiement Déployés automatiquement sur la liste, bibliothèque ou sur le site sur lequel ils ont été créés. Créer un fichier de package (.wsp) de solution SharePoint et le déploie dans le site (SPWeb).
Publication en 1 clic Oui Oui
Packaging et déploiement sur un serveur distant Oui Oui
Débogage Non. workflow peut être débogué à l’aide de Visual Studio. Mais pas encoe mis en œuvre.
Utilisation exclusive des actions qui sont approuvées par l’administrateur de site Oui Oui. Nouveauté SharePoint 2013, dans les versions précédentes les workflow et les actions créées à l’aide de Visual Studio étaient basés sur du code et déployés dans l’étendue de la ferme de serveurs (approbation administrateur non requise).

Installation de workflow Manager 1.0 et du Service BUS

La procédure est décrit de manière très précise dans le document de Critical Path référencé dans Créer son environnement de développement SharePoint 2013 sur VMWare Player.

  1. L’installation de service Bus et de Workflow Manager 1.0 se fait via le Web Platform Installer sous réserve que la machine soit connectée au web.
  2. Télécharger et installer WebPlatform Installer 4.5
  3. Dans le webplatform Installer chercher « Service Bus », installer Service Bus 1.0 puis le cumulative update 1 de Service Bus 1.0
  4. Chercher « Workflow Manager », installer Workflow Manager 1.0 mais ne pas le configurer (fermer l’installeur avant de lancer le wizzard), installer le cumulative update 1 de workflow Manager 1.0.
  5. exécuter les script suivant Script05_CreateWorkflowFarm.ps1
$ErrorActionPreference="SilentlyContinue"
Stop-Transcript | out-null
$ErrorActionPreference = "Continue"
Start-Transcript -path C:\output.txt -append
# do some stuff

# add SQL Server login for WINGTIP\sp_workflow
# add this login to roles of securityadmin and dbcreator
$sql = "CREATE LOGIN [SPALEX\sp_workflow] FROM WINDOWS WITH DEFAULT_DATABASE=[master], DEFAULT_LANGUAGE=[French]
        GO
        ALTER SERVER ROLE [securityadmin] ADD MEMBER [SPALEX\sp_workflow]
        GO
        ALTER SERVER ROLE [dbcreator] ADD MEMBER [SPALEX\sp_workflow]"

# invoke this SQL command
Invoke-Sqlcmd -ServerInstance "SPAlexandre\SQLSharePoint" -Query $sql

# determine path to CreateWorkflowFarmScript.ps1
$currentScriptPath = $MyInvocation.MyCommand.Path
$scriptFolder = Split-Path $currentScriptPath
$targetScriptPath = Join-Path $scriptFolder "\CreateWorkflowFarmScript.ps1"

Write-Host
Write-Host "Executing script $targetScriptPath using credentials of sp_workflow"
Write-Host "This script will execute within its own window"

# Get the Farm Account Creds
$serviceAccountName = "SPALEX\sp_workflow"
$serviceAccountPassword = "yourpassword"
$serviceAccountSecureStringPassword = ConvertTo-SecureString -String $serviceAccountPassword -AsPlainText -Force
$serviceAccountCredentials = New-Object -TypeName System.Management.Automation.PSCredential -ArgumentList $serviceAccountName, $serviceAccountSecureStringPassword

# Create a new process with UAC elevation
Start-Process $PSHOME\powershell.exe `
                -Credential $serviceAccountCredentials `
                -ArgumentList "-Command Start-Process $PSHOME\powershell.exe -ArgumentList `"'$targetScriptPath'`" -Verb Runas" -Wait

Write-Host
Write-Host "Reverting back to identity of SPALEX\Administrateur"
Write-Host

# register workflow farm with SharePoint farm
Add-PSSnapin Microsoft.SharePoint.Powershell
Write-Host "Registering new workflow farm with SharePoint farm to support SharePoint 2013 workflows"
Register-SPWorkflowService –SPSite "http://spalexandre" –WorkflowHostUri "http://spalexandre:12291" –AllowOAuthHttp
Stop-Transcript

Ce script lancera automatiquement celui-ci CreateWorkflowFarm.ps1 :


$wfinstallpath = (Get-ItemProperty "HKLM:\Software\Microsoft\Workflow Manager\1.0" INSTALLDIR).INSTALLDIR
$wfinstallpath = $wfinstallpath.TrimEnd('\')

if ($SetDirectory){
Set-Location $wfinstallpath
}

[Environment]::SetEnvironmentVariable("PSModulePath", [Environment]::GetEnvironmentVariable("PSModulePath","Machine"))
Import-Module WorkflowManager

# Create new SB Farm
Write-Host "Creating new service bus farm..."
$SBCertificateAutoGenerationKey = ConvertTo-SecureString -AsPlainText -Force -String 'yourpassword' -Verbose
New-SBFarm `
-SBFarmDBConnectionString 'Data Source=SPAlexandre\SQLSharePoint;Initial Catalog=WF_ServiceBus_ManagementDB;Integrated Security=True;Encrypt=False' `
-InternalPortRangeStart 9000 `
-TcpPort 9354 `
-MessageBrokerPort 9356 `
-RunAsAccount 'SPALEX\sp_workflow' `
-AdminGroup 'BUILTIN\Administrateurs' `
-GatewayDBConnectionString 'Data Source=SPAlexandre\SQLSharePoint;Initial Catalog=WF_ServiceBus_GatewayDatabase;Integrated Security=True;Encrypt=False' `
-CertificateAutoGenerationKey $SBCertificateAutoGenerationKey `
-MessageContainerDBConnectionString 'Data Source=SPAlexandre\SQLSharePoint;Initial Catalog=WF_ServiceBus_MessageContainer;Integrated Security=True;Encrypt=False' | Out-Null

# Create new WF Farm
Write-Host "Creating new workflow manager farm..."
$WFCertAutoGenerationKey = ConvertTo-SecureString -AsPlainText -Force -String 'yourpassword' -Verbose
New-WFFarm `
-WFFarmDBConnectionString 'Data Source=SPAlexandre\SQLSharePoint;Initial Catalog=WF_ManagementDB;Integrated Security=True;Encrypt=False' `
-RunAsAccount 'SPALEX\sp_workflow' `
-AdminGroup 'BUILTIN\Administrateurs' `
-HttpsPort 12290 `
-HttpPort 12291 `
-InstanceDBConnectionString 'Data Source=SPAlexandre\SQLSharePoint;Initial Catalog=WF_InstanceManagementDB;Integrated Security=True;Encrypt=False' `
-ResourceDBConnectionString 'Data Source=SPAlexandre\SQLSharePoint;Initial Catalog=WF_ResourceManagementDB;Integrated Security=True;Encrypt=False' `
-CertificateAutoGenerationKey $WFCertAutoGenerationKey

# Add SB Host
Write-Host "Creating new service bus host..."
$SBRunAsPassword = ConvertTo-SecureString -AsPlainText -Force -String 'yourpassword' -Verbose
Add-SBHost `
-SBFarmDBConnectionString 'Data Source=SPAlexandre\SQLSharePoint;Initial Catalog=WF_ServiceBus_ManagementDB;Integrated Security=True;Encrypt=False' `
-RunAsPassword $SBRunAsPassword `
-EnableFirewallRules $true `
-CertificateAutoGenerationKey $SBCertificateAutoGenerationKey

Try {
# Create new SB Namespace
New-SBNamespace `
-Name 'WorkflowDefaultNamespace' `
-AddressingScheme 'Path' `
-ManageUsers 'SPALEX\sp_workflow','SPALEX\Administrateur'

Start-Sleep -s 90
}
Catch [system.InvalidOperationException]{}

# Get SB Client Configuration
$SBClientConfiguration = Get-SBClientConfiguration -Namespaces 'WorkflowDefaultNamespace' -Verbose

# Add WF Host
Write-Host "Creating new workflow manager host..."
$WFRunAsPassword = ConvertTo-SecureString -AsPlainText -Force -String 'yourpassword' -Verbose;
Add-WFHost `
-WFFarmDBConnectionString 'Data Source=SPAlexandre\SQLSharePoint;Initial Catalog=WF_ManagementDB;Integrated Security=True;Encrypt=False' `
-RunAsPassword $WFRunAsPassword `
-EnableFirewallRules $true `
-SBClientConfiguration $SBClientConfiguration `
-EnableHttpPort `
-CertificateAutoGenerationKey $WFCertAutoGenerationKey

Write-Host "Workflow manager setup complete"
Write-Host

Afin de tester le fait que l’installation et la configuration soit OK, lancer SharePoint Designer 2013 qui devrait maintenant proposer les modèles de workflow Sharepoint 2013. workflow sharepoint designer 2013

Les types de workflow SharePoint 2013 dans SharePoint Designer

SharePoint Designer 2013 est l’outil privilégié pour créer de petit DocFlow. Il offre la possibilité de créer de nouveaux flux de travail : workflows natifs sharepoint designer 2013

  • sur une liste ou une bibliothèque donnée
  • réutilisable : avec très peu d’action disponibles et sans possibilité de manipuler des métadonnées, ce qui est tout de même souvent une nécessité …
  • sur un site donné
  • importé depuis Visio 2013 (SharePoint Designer et Visio 2013 – MSDN)

Ces workflows peuvent ensuite être déployés sur le site en un clic et être sauvegardés en tant que modèle pour être déployés sur un autre environnement. Attention à cette étape qui est souvent très chaotique car le wokflow est souvent lié à de nombreuses variables de votre environnement de dev qui ne sont pas présentes en production. De plus les environnements doivent être complètement ISO.

Une des grosses nouveautés dans les actions est l’appel d’un service web HTTP permettant d’interagir avec SharePoint mais aussi de nombreux autres systèmes afin de déclencher des actions métier. Il est également possible de créer des branches parallèles très simplement.

Toutes les actions sont décrites ici : référence des actions de workflow SharePoint Designer 2013 MSDN

workflow sharepoint designer 2013 - actions

Les types de workflows disponibles dans Visual Studio 2012

On y retrouve des Workflows de type SharePoint 2010 (logo grisé) et des workflows de type SharePoint 2013 (logo bleu).

  • Flux de travail SharePoint 2013
  • Activité personnalisée de flux de travail SharePoint 2013
  • Flux de travail séquentiel SharePoint 2010
  • Flux de travail de la machine a états SharePoint 2010

workflow sharepoint 2013 visual studio 2012 On retrouvera également un flux de travail de type machine a état dans le workflow SharePoint 2013 (le 1er de la liste). Mais ça, c’est pour le prochain article. Il y a aussi un projet de type « SharePoint 2010 – importer le flux de travail réutilisable » disponible à la création. visual studio 2012 rpojets sharepoint 2013 En espérant avoir planté le décor autour de ce vaste sujet SharePoint 2013.