Archives du mot-clé Visual Studio 2012

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 :

Publicités

Event Handler de modification des autorisations sur les tâches d’un workflow SharePoint


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 :

_______________________________________________________________________________________________

Lorsqu’une tâche est créée automatiquement par une activité de workflow, elle l’est dans la liste de tâche associée au Workflow en cours. Cette liste de tâche hérite bien souvent des autorisations de son site, qui lui-même pourrait hérité des autorisation de son site parent.

Dû à cette gestion des autorisations, il s’avère, que si je me rend directement dans la liste de tâches du workflow, je peux voir les tâches affectées aux autres acteurs du Workflow, ce qui n’est pas toujours souhaité. Ceci peut ne poser aucun problème puisqu’une des nouveautés de SharePoint 2013 permet d’agréger l’ensemble des tâches affectées à un utilisateur dans son site personnel, et ceci de manière transverse (cross collection de site) grâce à l’application de Service de « Gestion du travail » (ou « Work Management »).

L’utilisateur ne verra donc que ses propres tâches triées dynamiquement en fonction de leur sources. il pourra également gérer sa « to-do list ». Il a également la possibilité de filtrer ses tâches en fonction de leur statut et de leur date d’échéance. Plutôt sympathique.

Une très bonne explication de tout cela sur le post Work Management Application de Mickey75019.

mes tâches sharepoint 2013

Ici on ne parle que d’affichage mais pas de gestion de la sécurité liée à ces tâches. Si on veut empêcher un utilisateur de consulter/modifier toutes les tâches car il a des droits de lecture/ édition sur la liste de tâche, ou qu’il est lui même acteur du Workflow mais qu’il ne doit pas voir les tâches de tous les autres acteurs, alors il faut systématiquement réécrire les autorisations des tâches créées par le Workflow via un Event Handler (=récepteur d’événement = trigger).

Ci dessous le code C# permettant de répondre à ce besoin. J’y vais surement un peu fort sur le allowUnsafeUpdate et suis preneur de retours pour des optims si vous en avez … mais ça fonctionne 🙂

 public class TaskEventReceiver : SPItemEventReceiver
    {
        /// <summary>
        /// Un élément a été ajouté.
        /// </summary>
        public override void ItemAdded(SPItemEventProperties properties)
        {
            base.ItemAdded(properties);

            try
            {

                //changement d'autorisation sur chaque tâche afin que les utilisateurs ne voient que les tâches qui leur sont affectées

                SPSecurity.RunWithElevatedPrivileges(delegate()
                {
                    using (SPSite site = new SPSite(properties.WebUrl))
                    {
                        site.AllowUnsafeUpdates = true;

                        using (SPWeb web = site.OpenWeb())
                        {
                            web.AllowUnsafeUpdates = true;

                            SPListItem myItem = web.Lists[properties.ListId].GetItemById(properties.ListItem.ID); //  GET LIST OBJECT FROM SPWEB, NOT EVENT PROPERTIES

                            myItem.BreakRoleInheritance(false);

                            string spgroup = myItem["AssignedTo"].ToString();
                            spgroup = spgroup.Split('#')[1];

                            SPMember member = web.SiteGroups[spgroup];
                            SPPrincipal principal = (SPPrincipal)member;
                            SPRoleDefinition roledefinition = web.RoleDefinitions.GetByType(SPRoleType.Contributor);
                            SPRoleAssignment myRoleAssignment = new SPRoleAssignment(principal);
                            myRoleAssignment.RoleDefinitionBindings.Add(roledefinition);
                            myItem.RoleAssignments.Add(myRoleAssignment);
                            myItem.Update();
                            web.AllowUnsafeUpdates = false;
                            site.AllowUnsafeUpdates = false;
                        }
                    }
                });
            }
            catch (Exception ex)
            {
                ULSLogging.LogError("{0} De la mise à jour des autorisations, message : " + ex.Message  + " StackStrace : " + ex.StackTrace, "Ereur :");
            }
        }
}
}

Ce code serveur, déployé sous forme de feature/WSP, est exécuté à chaque fois qu’une tâche est ajoutée dans la liste que je cible (association de l’event handler avec la liste dans la feature). Il récupère le groupe auquel est assigné la tâche pour lui donner les droits de contribution sur celle-ci. Il supprime toutes les autres autorisations grâce à cette méthode : myItem.BreakRoleInheritance(false);

Un nouvel outil disponible sur codeplex permet également de répondre à cette problématique. il s’appelle SharePoint Rules Permissions

Pas encore eu l’occasion de le tester mais ce cas d’usage est cité de la description. Je suis preneur de vos retours 🙂

Création d’un workflow de type State Machine (machine à état) 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 :

_______________________________________________________________________________________________

Besoin fonctionnel

Je veux pouvoir gérer toutes les tâches liées à l’arrivée d’un nouveau salarié dans mon entreprise, comme par exemple :

  • l’attribution de son bureau
  • l’attribution de son numéro de téléphone fixe et mobile (s’il doit avoir un mobile professionnel)
  • la création de son compte AD et de son adresse email Exchange (avec possibilité d’automatisation)
  • l’attribution de droits sur les applications de l’entreprise
  • etc.

Les information concernant ce nouveau collaborateur étant renseignées en premier lieu dans une application RH dotée d’une base de donnée SQL Serveur.

Chaque équipe concernée devra pouvoir valider chacune des étapes afin de tracer et finaliser le processus avant la date d’entrée du nouveau collaborateur.

Conception générale

Considérant ce besoin fonctionnel, il pourra être traduit dans SharePoint de la manière suivante :

  • un type de contenu externe « Personne » issu d’une base de la données RH (cf. articles précédents) ainsi que sa liste externe associée
  • une liste « Fiche accueil nouveau collaborateur » qui référence le type de contenu externe « Personne » et qui vient ajouter des colonnes telles que :
    • attribution téléphone portable
    • véhicule de fonction
    • emplacement bureau
    • etc.
  • un workflow SharePoint 2013 associé à cette liste
  • des groupes SharePoint correspondants à chaque service impliqué dans le processus (RH, moyens généraux, support IT)
  • éventuellement des types de contenu spécifiques pour les tâches de workflow afin que l’on puisse saisir le numéro de téléphone ou la plaque d’immatriculation attribuée lorsque celle-ci est terminée
  • un event handler permettant de récupérer les informations saisies lors de la validation de la tâche et venir compléter la fiche d’accueil
  • une webpart affichant les tâches affectées à l’utilisateur courant (même si ceci est déterminé via un groupe SharePoint)
  • un event handler permettant de rende la tâche visible uniquement par le groupe d’utilisateur auquel elle est affectée

Création du workflow machine à état avec Visual Studio 2012

Considérons qu’une nouvelle instance de liste « FicheAccueil » a déjà été créée avec les champs suivants :

  • Titre : une ligne de texte
  • Personne  : BusinessData
  • Téléphone mobile : booléen
  • Véhicule de fonction : booléen
  • Numéro de mobile : une ligne de texte
  • emplacement bureau : liste de choix

Se conférer aux posts précédents afin de voir comment référencer une colonne de données externe dans une liste / un type de contenu.

Ajouter un nouvel élément de type « Flux de travail » de liste au projet SharePoint. L’associer à la liste « FicheAccueil » créée au préalable.

workflow sharepoint 2013

list workflow sharepoint 2013

workflow sharepoint 2013paramètrage workflow sharepoint 2013

Identifier le workflow, les listes créées (historique et tâches) ainsi que ses propriétés. Les modifier si nécessaire.

workflow properties sharepoint 2013

Dans le designer qui vient de s’ouvrir (workflow.xaml) renommer la séquence par défaut en « Séquence racine ».

root sequence workflow sharepoint

Créer la machine à état avec ses étapes et ses transitions

Y ajouter une séquence « machine à état » (StateMachine ») depuis la boîte à outils et double cliquer sur le logo en haut à gauche de cette séquence comme indiqué dans le screenshot ci-dessous.

state machine workflow sharepoint 2013

statemachine workflow

Insérer les états de la fiche d’accueil tout au long de son cycle de vie. Ceci se fait en sélectionnant l’item « state » dans la boîte à outils.

états workflow sharepoint 2013

Ajouter un état final. Glisser déposer l’élément « FinalState » depuis la boîte à outils.

finalstate workflow sharepoint 2013

Ajouter des transitions entre chacune des étapes (elles se créent manuellement et très simplement avec votre souris en traçant un lien entre chaque étape)

transition machine à états workflow sharepoint

Modifier la première étape et ajouter des logs au workflow

Double cliquer sur l’étape d’INIT sur le logo en haut à gauche. Insérer un événement de log dans l’historique avec le texte « Début du workflow Accueil Nouveau collaborateur ». Noter que le texte doit être entre guillemet et qu’il est possible d’accéder à de nombreuses fonctions et autre variables depuis l’éditeur d’expressions (accessible dans la fenêtre propriétés).

workflow writetohistory sharepoint

S’il y a une erreur quelconque de validation de workflow celle-ci est visible via une petit icone bleue qui apparaît dans le coin supérieur droit de chacun des éléments parents concernés. Le survol de cette icône affiche la source de l’erreur.

erreur workflow sharepoint 2013

Ajouter un élément « WriteLine » ou un élément de « DEBUG » en phase d’output de l’INIT. Ceci permet juste de valider cette première étape et le fait que le workflow soit bien lancé. Il est possible d’instancier des variables ainsi que de logguer des informations beaucoup plus riches à cette étape.

writeline sharepoint 2013

Modifier la séquence de l’état « approbation manager » afin d’assigner une tâche d’approbation de cette fiche d’accueil au manager de ce futur collaborateur.  Le groupe auquel est affecté cette tâche est sélectionné dynamiquement en fonction du service. La transition entre les 2 états reste inchangée.

Récupérer une valeur dynamique depuis les éléments SharePoint

Ajouter un élément de type « LookupSPListItem » et modifier ses propriétés afin de le faire pointer vers l‘élément courant et la liste courante (celle sur laquelle est branchée le workflow). Créer une variable de type « DynamicValue » et de portée « séquence » afin de stocker l’élément récupéré en sortie.

lookupsplistitem workflow sharepoint

Ajouter une activité « GetDynamicValueProperties » à la séquence via la boîte à outil en glisser déposer. Cette activité permet d’aller récupérer des valeurs de champs en OData depuis n’importe quel élément SharePoint passé en INPUT.

getdynamicvalueproperties workflow sharepoint

Lui passer votre SPListItem récupéré au préalable en INPUT.

getdynamicvalueproperties source sharepoint

Sélectionner ensuite les colonnes dont vous voulez récupérer la valeur dans les propriétés. Pour cela sélectionner « Elément de liste FicheAccueil » en tant que type d’entité, sélectionner ensuite la ou les colonne(s) dont vous voulez la valeur (ici le service et l’auteur) et cliquer sur « remplir les variables » afin d’ajouter des noms de variable automatiquement.

getdynamicvalueproperties entity sharepoint workflow

Changer la portée d’une variable de workflow

Le nom des variables créées peut alors être modifié si nécessaire. Une nouvelle variable de portée « séquence » est apparue. Changer son scope si celle-ci doit être réutilisée hors de cette séquence.

variable workflow sharepoint 2013

Ajouter une activité permettant de tracer le nom du service récupéré dans les la liste d’historique de workflow

LogToHistory workflow sharepoint

Ajouter une conditionnelle dans le workflow

Puis en fonction du nombre de conditions ajouter une conditionnelle ou un switch. Dans notre cas un « if » suffit. Celui-ci va comparer la valeur du champs « service » récupéré avec notre variable inscrite ici en dur mais qui peut être récupérée depuis votre futur environnement via configuration ou n’importe quelle liste.

condition if workflow sharepoint

Assigner une tâche de workflow et modifier sa date d’échéance

Assigner une tâche au groupe « Manager du service 1 ». Pour cela glisser déposer une « singleTask » depuis la boîte à outils dans la clause la partie « then ».

singletaks workflow sharepoint 2013

Modifier les propriétés de cette tâche afin qu’elles conviennent à votre processus. Dans mon cas le groupe à qui elle est affectée est « Manager Service 1 », celui-ci correspond à un groupe SharePoint créé au préalable ou via une feature déployée par votre projet de workflow.

singletask properties workflow sharepoint

La « Date d’échéance » est créée à date de création de la tâche + 3 jours. Ceci ne correspond pas à 3 jours ouvrés, pour cela un algo spécifique devrait être mis en place pour calculer la date par rapport à un calendrier de travail annuel passé en INPUT.

Le corps du message a également été modifié.  D’autres propriétés non visibles sur l’écran ci dessus peuvent être modifiées via la fenêtre de propriétés de la tâche.

Récupérer le résultat d’une tâche de workflow

Il faut noter l’apparition d’une nouvelle variable nommée « outcome_0 » qui correspond à la valeur de sortie de cette activité. Si celle-ci est égale à 0, cela signifie que la tâche a été approuvée, une autre valeur signifie qu’elle a été rejetée si nous n’avons que ces deux possibilités.

outcome_0 workflow task sharepoint

La renommer en « tacheManager » et changer sa portée au niveau « state machine », le reporter dans les propriétés de la tâche.

task outcome workflow sharepoint

Ajouter ensuite une activité « WriteToHistory » afin de logguer qu’une tâche a bien été affectée au manager du service. Noter que la portée de la variable « service1 » a été modifiée afin que je puisse y accéder au niveau mon état « approbation manager » et non plus de ma séquence.

writetohistory workflow sharepoint 2013

Modifier une transition

Modifier la transition pour le passage au 2e état en fonction de l’approbation de la tâche.

transition workflow SharePoint 2013

Ouvrir la transition en cliquant sur T2 afin de définir la séquence suivante pour envoyer un email à l’initiateur du workflow une fois la tâche approuvée :

Si la tâche a été approuvée, alors :

workflows transition sharepoint 2013

Envoyer un email à l’initiateur du Workflow

Dans la zone d’action ajouter un élément de type « LookupWorkflowContextProperty » afin de récupérer l’initiateur du workflow.

lookupworkflowcontextproperty sharepoint 2013

Créer une nouvelle variable nommée « initiateur » afin d’y stocker le résultat de cette requête.

workflow SharePoint 2013 variable

Sélectionner cette variable comme élément de sortie de l’action précédente

workflow sharepoint 2013

Créer une nouvelle variable de nommée « destinataire » de type System.Collections.ObjectModel.Collection<T> choisir ensuite le type « String » afin de ne pas laisser le type Générique.

send email sharepoint 2013 workfow visual studio

 

send email workflows sharepoint 2013

 

System.ObjectModel.Collection

Ensuite ajouter l’initiateur à la liste des destinataires de l’email. Pour cela utiliser l’activité « BuildCollection<T> » typée en « String ».

BuildCollection sharepoint 2013 workflow

 

Dans les propriété de cette activité, ajouter des valeurs en cliquant sur les « … »

sharepoint 2013 email workflow

 

Créer une argumenter avec la variable « Initiateur »

sharepoint 2013 worfklow visual studio

 

Définir la variable « Destinataire » en tant que résultat (output) dans le fenêtre de propriété également.

send email workflow sharepoint visual studio

 

Ajouter une activité de type « Courrier électronique » et définir le destinataire avec la variable nouvellement créée.

email workflow visual studio 2012

 

Ajouter un log dans l’historique pour signifier l’envoi de cet email.

sequence envoi email worfklow sharepoint 2013

 

Pour les 2 étapes suivantes les principes sont les mêmes concernant la récupération dynamique d’élément et l’affectation de tâches.

Même opération et même logique pour les étapes suivantes

Pour le téléphone mobile il faudra enchaîner les opération suivantes : 

  • Récupérer la valeur du champs « téléphone mobile »
  • Poser une condition afin d’assigner une tâche à l’équipe en charge de l’attribution si la valeur est à « true »
  • Assigner une tâche au groupe « Telephonie mobile »
  • Si tâche OK alors passer à l’étape suivante

workfows sharepoint 2013 visual studio 2012

NB  : afin de récupérer le numéro de téléphone attribué au nouveau collaborateur, il est possible de créer un  type de contenu spécifique pour la tâche à destination de l’équipe téléphonie mobile. Celui-ci contiendra un champs « No De tel » qui devra obligatoirement être saisie pour que la tâche soit complétée. Il pourra ensuite être récupéré par le Workflow (GetDynamicValueProperty) et inséré dans la fiche d’accueil elle-même.

Le workflow une fois déployé 

Le formulaire de fiche d’accueil : 

workflow visual studio 2012

 

le workflow une fois déclenché avec sa liste de tâche et son historique (traces) : 

Sharepoint 2013 custom Workflow with visual studio 2012

CA DESIGN DONC MAIS CA NE DEVELOPPE PAS … ENCORE !

ENJOY !!

Sources :