Microsoftdownload.microsoft.com/documents/France/MSDN/20… · Web viewBien sur, on peut inclure les instances de listes directement dans le modèle de site mais il peut être intéressant

Microsoft Créer vos propres Features SharePoint – Atelier 3

Coach Sharepoint 2007

< Atelier 3 />Créer vos propres Features

SharePoint

Printemps 2009 Tutorial Découverte de SharePoint 2007 Page 1 sur 47


Sommaire

1 INTRODUCTION......................................................................................................................................................3

1.1 CONTEXTE FONCTIONNEL........................................................................................................................31.2 CONTEXTE TECHNIQUE............................................................................................................................3

2 INTRODUCTION ET DÉCOUVERTE DES FEATURES...................................................................................5

2.1 PRÉSENTATION SIMPLIFIÉE:......................................................................................................................52.2 ARBORESCENCE ET FICHIER.....................................................................................................................72.3 LA NOTION DE SCOPE...............................................................................................................................92.4 DÉPENDANCE ET ASSOCIATION..............................................................................................................10

2.4.1 Dépendance (regroupement)............................................................................................102.4.2 Association (Stapling).......................................................................................................11

2.5 QUELQUES EXEMPLES DE FEATURES INSTALLÉES PAR DÉFAUT............................................................142.5.1 Features du modèle GLOBAL...........................................................................................142.5.2 Feature du modèle de collaboration..................................................................................16

3 CONCEPTION D’UNE SOLUTION DE DÉVELOPPEMENT VISUAL STUDIO :......................................17

3.1 PRÉPARATION ET CONFIGURATION DE L’OUTIL.....................................................................................183.2 CRÉATION DU PROJET............................................................................................................................203.3 CRÉATION DU CORPS D’UNE FEATURE...................................................................................................21

3.3.1 Sous-arborescence spécifique..........................................................................................213.3.2 Manifest de la Feature......................................................................................................223.3.3 Fichiers de ressource........................................................................................................233.3.4 Fichiers d’action et fichiers physique................................................................................24

3.4 BATCHS DE DÉPLOIEMENT D’UNE FEATURE..........................................................................................243.5 DÉVELOPPEMENT : AJOUT D’ACTION !...................................................................................................26

3.5.1 Ajout de Master Pages......................................................................................................263.5.2 Ajout de menu................................................................................................................... 273.5.3 Création de Liste...............................................................................................................323.5.4 Création de Page avec ses WebParts associés...............................................................353.5.5 Tester et évaluer...............................................................................................................45

4 POUR ALLER PLUS LOIN…................................................................................................................................46

5 RENDEZ-VOUS DANS LE PROCHAIN ATELIER….......................................................................................47



1 IntroductionCet atelier s’inscrit dans le cadre du tutorial de découverte du développement avec la technologie SharePoint 2007. L’objectif est la réalisation d’un modèle de site entièrement personnalisé avec la méthodologie expliquée pas à pas.

Les exercices de l’atelier N°3 vous permettront d’aller encore plus loin dans la personnalisation de votre plateforme SharePoint en s’appuyant sur le système de Feature inhérent à SharePoint 2007.

Les Features assurent les notions de flexibilité, granularité, déploiement et maintenance à la plateforme 2007. Vous parcourrez ces notions ainsi que leurs modèles XML à travers la réalisation de véritables Feature tout en profitant de plusieurs astuces de conception.

1.1 Contexte fonctionnel

Rappel du contexte fonctionnel du Tutorial de découverte de la technologie SharePoint 2007

L’objectif du tutorial est de construire, pas à pas, un site personnalisé SharePoint incluant les grands axes de développement SharePoint tels que

1. Création d’un modèle de site avec son design et sa charte graphique2. Ajout de fonctionnalités déclaratives par les « Features ».3. Ajout de fonctionnalités associées avec des événements de code .Net4. Composants WebPart5. Son Packaging et Déploiement complets

Contexte fonctionnel de l’atelier 2 dans le cadre du Tutorial

L’objectif est de découvrir la conception et la réalisation de véritables Features pour des sites SharePoint.

Ce concept prônant le mode déclaratif associé à des cycles de vie très pratique (activables/ désactivables à tout moment) simplifie grandement la gestion d’un site SharePoint. Grace aux Features, la conception SharePoint peut se rapprocher enfin d’une vision plus « composants ».

Chaque fonctionnalité, élément ou brique constituant un site SharePoint, de la Master Page au Workflow peut être ainsi conçu de manière unitaire mais pensé pour concevoir un tout, pardon, un modèle de site bien plus grand.

Les Features ne sont pas qu’un « Best Practice » comme tant d’autres. Ils sont au cœur même du fonctionnement de SharePoint 2007.

Les WebParts ou les types de base, les modèles des listes de gestion et même l’administration Central ne sont que le fruit de l’activation d’un groupe de Features particulières.

Par conséquence, un projet SharePoint ne peut se limiter qu’au seul modèle de site ou de composant ASP.Net mais il sera forcement composé d’une Feature, et même de plusieurs au final.

1.2 Contexte technique

Comme rappelé précédemment, une Feature SharePoint est un fragment d’un modèle de site SharePoint. Soit, en pratique, en une collection de fichiers XML basé sur le métalangage XML, le CAML

Comme les « Site Definitions », les Features profitent de la même richesse fonctionnelle du CAML mais en possèdent aussi la même complexité « tout XML » dans leur conception.



A la différence des modèles de site, leur approche PRO composant permet de créer des fragments XML bien plus légers voir spécifiques à des lots fonctionnels. Des lors, La conception de site devient bien plus commode.

L’objectif de ce tutoriel est de vous permettre de bien comprendre la réalisation de Features via la création d’un jeu complet de nouvelles fonctionnalités pour un site SharePoint. Les Best Practices, les astuces de développement ainsi qu’un peu de retour d’expérience seront au cœur même des exemples

A la fin, vous saurez comment :

6. Créer votre propre Feature7. Monter une solution de développement SharePoint pour vous faciliter sa conception8. Travailler avec les listes, les paramètres, ses menus ainsi que ses pages ASPX de

votre site SharePoint9. Allez plus loin dans la découverte du langage CAML

Soit en pratique :

1. Introduction et découverte des Features Présentation simplifiée Arborescence et fichier La notion de Scope Dépendance et association Quelques exemples de Features installées par défaut

2. Conception d’une solution de développement Visual Studio : Préparation et configuration de l’outil Création du projet et des scripts de travail Création d’une Feature simple

3. Divers exemples clés en main Gestion des menus Création de liste et d’arborescence de dossier Ajout de Master Page Création de bibliothèque avec des pages à WebParts Association et dépendance sur un modèle

Cet atelier se base sur l’utilisation de la technologie SharePoint 2007 via son offre de base Windows SharePoint Services V3 (WSS). La lecture des tutoriels du Coach 1 & 2 est un vrai plus pour la compréhension d’ensemble

Note :



2 Introduction et découverte des Features Dans cet exercice, vous allez découvrir :

- La composition d’une Feature SharePoint.- Les différents concepts utilisés par le système des Features.- Le rôle des différents fichiers et références

ObjectifL’objectif de ce chapitre est de vous permettre de mieux appréhender le contenu des fichiers XML composant une Feature SharePoint et leur intégration au cœur même de la plateforme. Vous pourrez ainsi, aisément créer vos propres Features et décomposer ceux existants

Contexte fonctionnel

La base fondamentale de SharePoint 2007 repose surtout sur le principe d’usine à sites et de son moteur de génération. Si les modèles reposent exclusivement sur l’utilisation et la personnalisation des « Site Definitions », les Features assurent leur extensibilité.

Comme les Site Definition, les Features reposent sur le métalangage XML dit le CAML. Mais à leur différence, ils sont pensés comme des composants autonomes et réutilisables avec un cycle de vie propre.

Il est ainsi possible de modifier facilement un site SharePoint après sa création en activant simplement la bonne Feature tout en les mutualisant dans des modèles de sites différents

2.1 Présentation simplifiée:

Comme nous avons vu dans le second tutoriel, Le moteur de génération de SharePoint fonctionne exclusivement à partir des Site Definitions, qui, via le schéma CAML, assure la définition complète du site à générer. ASP.Net ne jouant, lui, que le rôle de framework Web une fois la génération finie.

Les Features, eux, sont là pour faciliter la création et la gestion des modèles de site SharePoint.

Sous SharePoint 2003, la composition d’un site était contenue entièrement dans un modèle de site XML, les inconvénients les plus connus étaient :

Un gros volume de nœud XML Le manque d’interaction possible avec les sites une fois générés Le texte des libellés en dur L’évolution des sites sous SharePoint 2003 demandait bien des acrobaties et des astuces de

développement.

SharePoint 2007 a volontairement changé d’architecture afin de simplifier les Site Definition, et de la, la plateforme en générale

Le premier travail a été de mutualiser les bases d’un site SharePoint dans un modèle GLOBAL afin de ne gérer que les spécificités des sites dans leur modèle propre.

Le second fut de profiter des fichiers de ressources ASP.Net pour gérer l’aspect multilingue des différents modèles. Il n’est plus nécessaire de dupliquer tout le Site Definition, il suffit de fournir les fichiers de traduction.

Le dernier point fut de pouvoir externaliser du modèle de site, les composantes d’un site de son modèle afin de les rendre interchangeables et réutilisables. C’est ici qu’intervient le système des Features. Ainsi, les schémas de listes, des champs, des types de contenus ou autres sont spécifiés dans des Features via leurs références de GUID dans le site Definition



Les Features sont ainsi la réponse au besoin de modularité des Sites SharePoint.

En pratique, il s’agit de simples fragments de CAML pouvant être activé/désactivé à la création d’un site ou bien plus tard si le besoin est. En fait, elles sont assimilables à de véritables portions d’un Site Definition, complètement autonomes.

Ils permettent ainsi de regrouper tous les composants logiques d’un site dans un objet indépendant et réutilisable à volonté. Leur cycle de vie couvre aussi bien la notion d’activation/désactivation sur un site que l’installation et la désinstallation.

Ces 2 notions rendent les Features vraiment incontournables dans la conception même de projet SharePoint. En effet, elles permettent les scénarios suivants :

Le partage de composants entre différents modèles de site La centralisation des composants de base Le déploiement et l'activation de nouvelles fonctionnalités sur des sites déjà existants (et leur

retrait) L’ajout à des fermes, de fonctionnalités tiers Faciliter les déploiements de composants logiques

SharePoint 2007 implémente cette notion de composant au plus bas de sa conception, et pas simplement dans les modèles de site. Tout est déployé dans SharePoint via cette notion de Feature.

Qu’il s’agisse des modèles de listes, des modèles de pages et de menus de gestion jusqu'au différents workflows métiers, tous reposent sur les Features dans SharePoint 2007.



Ainsi, les Features représentent la clé du déploiement logique de la plateforme SharePoint. Quel que soit le développement que l’on doit intégrer dans SharePoint 2007, en dehors d’un composant ASP.Net ou d’un Site Definition, il sera forcement constitué d’une Feature.

2.2 Arborescence et fichier

Les Features sont composées au minimum de fichiers XML organisés en sous répertoires en dessous de 12/TEMPLATE/FEATURE. Chaque Feature possède un sous répertoire à son nom.

Le nom du dossier contenant les fichiers XML est très important car il représente une des clés identifiantes de la Feature. Dés lors, il faut mieux éviter des noms peu explicites et/ou composés de caractères exotiques ou d’espace.

La conception d’un Feature est bien plus simple qu’un Site Definition. Elle se compose de 2 fichiers XML de base :

Un fichier Feature.xml : il se trouve en racine de répertoire et représente le contrat d’utilisation et de définition de ses paramètres comme son titre, sa description ou son identifiant unique

Un ou plusieurs fichiers element.xml : ils définissent le code déclaratif en CAML à exécuter à l’activation. Ils sont référencés par le Feature.xml

Voici un détail rapide des propriétés du fichier Feature.xml

Attribut DescriptionId Identifiant unique (GUID) mais sans les accoladesTitle Titre de la fonctionnalitéDescription (Optionnel) Description de la fonctionnalitéVersion Version de la fonctionnalitéScope Zone d’activationHidden Faux par défaut, si vrai, elle ne pourra être activée que par ligne de

commande ou développement.AlwaysForceInstall (Optionnel) Si vrai, la Feature remplace toute ancienne version déjà installé.DefaultRessourceFile (Optionnel) définit le fichier de traduction par défautPrintemps 2009 Tutorial Découverte de SharePoint 2007 Page 7 sur 47


ImageUrl (Optionnel) définit l’adresse de l’image représentant la Feature dans l’administration. La taille conseillée est de 32x32

ReceiverAssembly (Optionnel) Nom fort de l’assemblée métier contenant des événements attachés

ReceiverClass (Optionnel) Nom complet de la classe de l’assemblée d’événementActivationDependecies (Optionnel) liste des identifiants de Features à activer ElementManifest Ensemble des fichiers CAML définissant les actions à faire sur le scope de la

Feature

Voici un détail rapide des propriétés des fichiers element.xml

Attribut DescriptionCustom Action Définit un lien dans une des menus préconfigurés comme le menu d’action

ou d’administration par exempleCustom Action Group Définit un groupe d’actionHide Custom Action Permet de cacher un lien dans une des menus préconfigurésControl Identifier un « user control » ou un contrôle web à placer dans un " Delegate

Control "Scope Zone d’activationFeature Site Template Association

Permet d’accrocher une Feature tierce à un modèle de site. Cette opération est appelé "Stapling"

Document Converter Identifie une assemblée métier pour faire les conversions de type de fichierModule Permet de déclarer un upload virtuel de fichier dans SharePoint. Il peut cibler

les répertoires du site comme les listes documentairesList Template Définie un nouveau modèle de liste à utiliser dans la plateforme. List Instance Crée une liste selon le modèle préciséContent Type Définie les colonnes, les workflows et le modèle par défaut à attacher à une

instance de liste : c’est la déclaration du Content TypeContent Type Binding Attache un Content Type à une liste existanteReceiver Permet d’associer une bibliothèque d’événement à un objet SharePointWorkflow Définie un Workflow dans la galerie attaché, il peut être attaché à une liste

ou un Content Type particulier

Feature Schemahttp://msdn.microsoft.com/en-us/library/ms414322.aspx

Pour mieux comprendre voici un petit exemple basé sur la Feature de déclaration du modèle de liste d’annonce : AnnouncementsList


http://msdn.microsoft.com/en-us/library/ms414322.aspx

http://msdn2.microsoft.com/


Comme toutes les Features sont stockées dans un répertoire Features, il n’est pas forcement nécessaire de devoir les préfixer par … Feature . Ce serait un peu redondant et inutile

2.3 La notion de scope

Comme nous l’avons vu dans le premier tutoriel, SharePoint 2007 suit une arborescence logique assez simple :

Les Features respectent aussi cette hiérarchie dans leur système d’activation. En effet, chaque Feature possède un niveau d’application dit « Scope » qui reprend les 4 niveaux principaux :

Ferme Web Application Site Collection Web

Ce niveau est important car, en plus de définir la portée de la Feature, les éléments déployés doivent correspondre aux propriétés du niveau. C’est simple, en pratique. Un modèle de contenu peut être déployé au niveau d’une collection de site pour être utilisable sur l’ensemble des sites web de celle-ci mais qu’un menu d’administration sera forcement de niveau Web Application ou ferme.

Voici quelques exemples pour mieux l’appréhender


Physical Server

Web Application(s)

Top Level Site(s)

Site(s)

Site(s)Site Collection


Prenons un peu d’avance. Le déploiement d’une WebPart s’appuie elle aussi à travers une Feature (Ce sujet sera le centre d’intérêt du tutoriel des WebPart). Comme la galerie des WebPart est une spécificité des « Site Collection », le niveau de la Feature sera forcement le même. Ce qui explique pourquoi on ne peut restreindre le choix des WebParts dans un site, ce sont forcement ceux déclarés de la collection.

2.4 Dépendance et association

Il existe des options avancées dans la déclaration des Features qui leur permettent des scenarii très intéressants : Regroupement et Association

2.4.1 Regroupement (Dépendance)

Dans le cas de projet d’envergure, vous pouvez vous trouver dans une situation ou vous devriez gérer un nombre important de Features. En effet, il suffit qu’un lot de développement impose une suite de fonctionnalités complexes pour vous retrouvez avec :

Plusieurs Module Plusieurs Content Type Différents Event et Workflow …

Le premier réflexe est souvent de créer plusieurs fichiers « Element » pour sa Feature plutôt qu’un seul fichier lourd et monolithique. Cependant, on obtient une Feature bien complexe et difficile à maintenir

Il faut mieux privilégier l’utilisation de plusieurs micros Features, plus légères qu’il suffit de regrouper à l’activation. Vous pouvez ainsi paralléliser le développement et les phases de test tout en gardant une approche composant.

L’implémentation est finalement assez simple. Il suffit de respecter 2 conditions !1. Il faut créer une Feature Maitre qui référence l’ensemble des GUID des sous Features à

activer2. Créer un ensemble de Feature invisible (attribut Hidden=true)



Si jamais les sous Features sont visibles, il n’y aura pas une activation par cascade de celles-ci. SharePoint vous redirigera vers une interface listant les Features regroupées, vous demandant de les activer individuellement.

Le principe de regroupement est utilisé par exemple dans le modèle de site d’équipe STS pour gérer l’ensemble des lots spécifiques à la collaborationIl s’agit de la Feature « TeamCollab » (référencé dans le nœud WebFeature du Site Definition)

Voici son fichier Feature.xml

2.4.2 Association (Stapling)

Le Stapling permet d’associer une Feature à un ou plusieurs « Site Definition » particulier.

C’est un mode très important si l’on tient compte des problématiques de la génération de site. En effet, Il est souvent impossible de pouvoir modifier un modèle de site sans craindre d’effets sur des sites déjà existants.

La moindre modification non contrôlée peut très bien générer une erreur sur des sites déjà existants à la différence de sites totalement « neufs ». Le Stapling vient répondre à cette problématique.

En associant des Features à des identifiants de Site Definition, vous pouvez modifier la génération sans impacter les sites existants ni risquer de modifier ou cloner un modèle déjà bien compliqué.

En fait, il s’agit de la troisième méthode de déploiement de Feature :1. Activer les Features à posteriori2. Inclure les Features dans le Site Definition3. Les associer à un modèle existant



Bien des experts communautaires préfèrent utiliser ce mode afin de limiter leur interaction avec les Site Definitions, typiquement dans le cas des modèles de Publishing de MOSS qui sont relativement complexes.

En pratique, il suffit de créer une Feature et de définir dans son fichier Element.xml des associations selon ce modèle

<FeatureSiteTemplateAssociation Id="GUID de la Feature" TemplateName="Identifiant du modèle # configuration" />

Dans le cas du respect de la garantie du produit, le « Stapling » permet de contourner aisément les restrictions imposées sur les fichiers d’installation. En effet, tout service pack peut très bien remplacer les fichiers d’origine et donc supprimé vos modifications par exemple. En utilisant le « Stapling », vous ne risquez absolument rien.

Cette dernière remarque est particulièrement importante dans le cas de MOSS. Sans le « Stapling », vous ne pouvez interagir proprement avec le modèle de site des « My Site » ou le GLOBAL. Ceux-ci font partie des fichiers dits d’origine, donc non modifiables selon le contrat de garantie Avec le « Stapling », il ne s’agit que de regrouper sous plusieurs Feature l’ensemble de vos modifications et d’effectuer l’association.

Cet exemple montre comment gérer un changement de Master Page sur les « My Site »http://blogs.msdn.com/sharepoint/archive/2007/03/22/customizing-moss-2007-my-sites-within-the-enterprise.aspx

Voici un exemple pris de la plateforme MOSS avec la Feature BaseSiteStapling

Feature.xml

basesitestapling.xml<Elements xmlns="http://schemas.microsoft.com/sharepoint/">

<FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="STS#0" /> <FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="STS#2" /> <FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="MPS#0" /> <FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="MPS#1" /> <FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="MPS#2" /> <FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="MPS#3" /> <FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="MPS#4" /> <FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="WIKI#0" /> <FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="BLOG#0" />

<FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="BDR#0" />

<FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="EAWF#0" />

<FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="OFFILE#0" /> <FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="OFFILE#1" />

<FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="PWA#0" />


http://blogs.msdn.com/sharepoint/archive/2007/03/22/customizing-moss-2007-my-sites-within-the-enterprise.aspx

http://blogs.msdn.com/sharepoint/archive/2007/03/22/customizing-moss-2007-my-sites-within-the-enterprise.aspx



<FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="PWS#0" />

<FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="SPS#0" /> <FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="SPSMSITE#0" /> <FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="SPSTOC#0" /> <FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="SPSTOPIC#0" /> <FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="SPSNEWS#0" /> <FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="SPSNHOME#0" /> <FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="SPSSITES#0" /> <FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="SPSBWEB#0" /> <FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="SPSCOMMU#0" /> <FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="SPSREPORTCENTER#0" /> <FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="SPSPORTAL#0" /> <FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="SRCHCEN#0" /> <FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="PROFILES#0" />

<FeatureSiteTemplateAssociation Id="B21B090C-C796-4b0f-AC0F-7EF1659C20AE" TemplateName="CMSPUBLISHING#0" />

<FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="STS#0" /> <FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="STS#2" /> <FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="MPS#0" /> <FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="MPS#1" /> <FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="MPS#2" /> <FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="MPS#3" /> <FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="MPS#4" /> <FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="WIKI#0" /> <FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="BLOG#0" />

<FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="BDR#0" />

<FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="EAWF#0" />

<FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="OFFILE#0" /> <FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="OFFILE#1" />

<FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="PWA#0" /> <FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="PWS#0" />

<FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="SPS#0" /> <FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="SPSMSITE#0" /> <FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="SPSTOC#0" /> <FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="SPSTOPIC#0" /> <FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="SPSNEWS#0" /> <FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="SPSNHOME#0" /> <FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="SPSSITES#0" /> <FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="SPSBWEB#0" /> <FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="SPSCOMMU#0" /> <FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="SPSREPORTCENTER#0" /> <FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="SPSPORTAL#0" /> <FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="SRCHCEN#0" /> <FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="PROFILES#0" />

<FeatureSiteTemplateAssociation Id="99FE402E-89A0-45aa-9163-85342E865DC8" TemplateName="CMSPUBLISHING#0" />

<FeatureSiteTemplateAssociation Id="541F5F57-C847-4e16-B59A-B31E90E6F9EA" TemplateName="SRCHCENTERLITE#1" >

<Property Key="IncludeInGlobalNavigation" Value="false" />

<Property Key="IncludeInCurrentNavigation" Value="false" />

<Property Key="InheritCurrentNavigation" Value="true" />

<Property Key="IncludePages" Value="false" />

</FeatureSiteTemplateAssociation>

</Elements>

Comme vous pouvez le constatez, l’installation de MOSS peut, via cette Feature, mettre à jour l’ensemble des modèles de sites avec plusieurs jeux de Feature comme :

BaseSite (B21B090C-C796-4b0f-AC0F-7EF1659C20AE) BaseWeb (99FE402E-89A0-45aa-9163-85342E865DC8)

Ces Features sont justement des regroupements de Feature. Elles gèrent par exemple, en fonction du scope, l’ajout des différents menus d’administration de MOSS, les workflows, les contrôles de recherche et bien d’autres fonctionnalités indisponibles sur la plateforme WSS par défaut.



Soit un très bon exemple de packaging et de déploiement logique dans le cas de grands projets.

2.5 Quelques exemples de Features installées par défaut

Avant de rentrer dans un aspect plus pratique avec la création de vos propres Features via Visual Studio, nous allons parcourir quelques exemples de Feature.

Lors du déploiement ou la création des sites de base, SharePoint 2007 active nombre de Feature de base initialisant 90% des contenus des sites. Soit 32 Features pour WSS seul, plus de 250 avec MOSS !

En les parcourant, vous pourrez découvrir une grande partie des possibilités des Features et de SharePoint, et donc pouvoir les réutiliser dans vos propres conceptions.

2.5.1 Features du modèle GLOBALCes Features font parties des fondamentaux de la plateforme. Elles permettent de déclarer les types de base des sites SharePoint; d’où leur référencement à travers le modèle GLOBAL.

FieldsElle gère la description des tous les modèles de colonnes utilisés par les diverses listes

CtypesElle définit l’ensemble des Content Types (modèles de contenu) utilisés dans la taxonomie des listes.

Ces 2 dernières Features sont déclarés au niveau « Site » ou collection de site pour être plus précis. Ainsi, les colonnes et autres types de contenu sont aussi disponibles dans tous les sites Web et sous site de l’arborescence de la collection de site

BasicWebPartsElle ajoute dans la galerie des WebParts les manifestes de déclaration des 8 WebParts de base. La DLL des WebPart étant déjà installée par le serveur dans le Global Assembly Cache (GAC)

GAChttp://msdn.microsoft.com/fr-fr/library/yf1d93sz(VS.80).aspx

MobilityRedirectElle ajoute le lien de redirection vers les pages d’accès mobile de SharePoint

IssueTrackingWorkflowElle déploie le modèle de workflow à 3 étapes dans WSS.

Dans le cas de MOSS, une demi-douzaine est rajoutée en plus de ceux de WSS




AdminlinksElle crée et ajoute les groupes et liens d’administration des 2 onglets Opérations et Application de l’administration Centrale. Attention, il s’agit bien de l’ensemble des liens, sans cette Feature, l’Administration Centrale ne serait qu’un simple site avec 2 pages entièrement vierge

WikiWelcomeElle permet de modifier la page d’accueil d’un site pour utiliser une page WIKI si le site utilise justement le modèle WIKI.

Par sécurité, cette Feature est invisible pour éviter justement une activation non contrôlée en dehors d’un modèle Wiki

Le set de Feature suivant n’est pas spécifique à un modèle mais ces Features sont activées par regroupement pour assurer la cohérence des sites SharePoint de base

ContentLightUpElle met en place les différents contrôles de SharePoint dans la Master Page via les Delegate Control. Dans ce cas, il s’agit des contrôles de recherche ainsi que les liens d’export des listes de contact ou d’événement

Le Delegate Control est très important dans la conception SharePoint. C’est un control dit d’injection ou même un Wrapper, il est de plus spécifique à SharePoint. En pratique, il permet de définir des zones d’injection dans une page ou une Master Page SharePoint. Ensuite, grâce au code CAML des Features, vous pouvez spécifier quel « Web Control » ou même « User Control » vous voulez injecter en lieu et place.

Le code CAML utilisé pour injecter les contrôles s’appuie sur le nœud « Control ». Voici l’exemple pour le cas du pavé de recherche :

<Control Id="SmallSearchInputBox" Sequence="100" ControlSrc="~/_controltemplates/searcharea.ascx">

Le code de séquence permet de définir une priorité dans l’injection. C’est ainsi que MOSS ou Search Server 2008 change le contrôle de recherche dans le cas d’une mise à jour de votre ferme SharePoint. Il utilise simplement une Feature sur l’id « SmallSearchInputBox » avec une séquence plus petite

Delegate Controlhttp://msdn.microsoft.com/en-us/library/ms463169.aspx

ContentTypeSettingsElle définit les divers liens d’administration présents dans une liste de gestion

SiteSettingsIdentique à la Feature de gestion des liens de l’administration central mais spécifique à la gestion d’un simple site

Volontairement, je ne décris pas le contenu de ces Features car ce serait prendre un peu trop d’avance sur ce chapitre mais le contenu de ces diverses Features sont de très bons exemples. Le code CAML utilisé lui sera largement couvert dans le prochain chapitre 3





2.5.2 Feature du modèle de collaboration

A ce niveau, les Features sont bien plus spécifiques au contenu propre du modèle, soit collaboration et stockage documentaire. En pratique, il ne s’agit que d’une seule Feature : TeamCollab. Elle regroupe un petit ensemble de Feature invisible (grâce à l’ActivationDependency) qui chacune traite un contenu spécifique. Soit :

AnnoucementList ContactList CustomList DatasourceLibrary DiscussionList DocumentLibrary EventsList GanttList GridList IssuesList

LinksList NoCodeWorkflowsLibrary SurveysList TasksList PictureLibrary WebPageLibrary WorkflowHistoryList WorkflowProcessList XmlFormLibrary

Vous remarquez rapidement que ces Features représentent la déclaration des différents types de listes que vous pouvez créer dans SharePoint.

TeamCollab est très fragmentée mais permet aussi à chaque Feature d’être plus simple à maintenir. De plus, il facilite bien la réutilisation des modèles de liste dans d’autre Feature de regroupement si vous devez réaliser des modèles plus « métier ». Comme un modèle PRO documentaire n’autorisant aucune autre liste que celle des bibliothèques et les news par exemple.

Clairement, la notion de Feature est vraiment fondamentale dans le déploiement et le fonctionnement même de SharePoint 2007. Voyons donc comment appréhender la conception de vos propres Features dans le prochain chapitre.



3 Conception d’une solution de développement Visual Studio :

Dans cet exercice, vous allez apprendre à :

- Créer votre propre Feature déclarative ;- Analyser et architecturer vos Features d’interface ou de backoffice- Implémenter :

o Une Master Page et une page personnaliséeo De nouvelles listes et du contenuo Des WebParts dans une page

ObjectifL’objectif de cet exercice est de créer des Features de site SharePoint ne reposant que sur le code déclaratif CAML. Ce tutoriel illustrera certains des exemples de bases des personnalisations de Site SharePoint.

Contexte fonctionnelNous allons implémenter les bases de personnalisation d’un site SharePoint via différentes Features entièrement en code déclaratif. Cette approche favorise la réutilisation du code CAML existant que l’on peut reprendre puis étendre des différentes Features et modèle de site existant. Ainsi, la création de Features devient bien plus accessible et d’autant plus simple à faire.

Dans la découverte des Features déclaratives, nous parcourrons plusieurs scénarii fonctionnels comme l’ajout de liste, de Master Pages, de contenu ainsi que des menus de gestion

Afin de respecter au mieux une démarche projet, nous nous placerons en situation en implémentant le tout dans une solution Visual Studio en détaillant la méthodologie utilisée.

Pour mieux comprendre le fonctionnement intrinsèque de la plateforme, ce chapitre et l’ensemble de ces exercices ne seront pas basés sur les extensions SharePoint pour Visual Studio. Ces extensions créent une abstraction de la plateforme pour le développeur afin de lui faciliter le travail. L’objectif du Coach SharePoint étant de vous aider à découvrir et comprendre le fonctionnement de cette technologie, nous travaillerons au plus proche de celle-ci.


Création de liste

Création de menu

Création de hiérarchie

Création de pages à WebPart

Ajout de Master Page


L’utilisation des extensions pour Visual Studio ainsi que des projets communautaires comme le WSPBuilder ou STSDev sont un vrai « plus » pour les développeurs. Nous ne pouvons que vous encourager à les découvrir une fois ces exercices réalisés.

3.1 Préparation et configuration de l’outilA vrai dire, il n’y a pas de pré requis ou de configuration plus spécifique que celle que nous avions vue dans le tutoriel des Site Definitions (second tutoriel).

Nous utiliserons donc toujours notre cher Visual Studio en respectant la structure du fameux répertoire 12 de SharePoint 2007, le tout dans une machine Virtuel SharePoint 2007.

Chemin du répertoire 12:[Program Files]\Common Files\Microsoft Shared\web server extensions\12\

Virtual PC 2007http://www.microsoft.com/downloads/details.aspx?displaylang=fr&familyid=04d26402-3199-48a3-afa2-2dc0b40a73b6

Windows SharePoint Services 3.0 SP1 Developer Evaluation VPC Imagehttp://www.microsoft.com/downloads/details.aspx?familyid=1beeac6f-2ea1-4769-9948-74a74bd604fa&displaylang=en&tm

Les Features déclaratives reposant exclusivement sur le CAML, l’assistance du Schema WSS.XSD dans l’édition XML de Visual Studio est indispensable pour limiter les risques d’erreur.

Pour définir le schéma SharePoint dans ceux par défaut de Visual Studio. Il suffit de paramétrer Visual Studio selon cette procédure

Pour info, WSS.xsd se trouvant dans 12/TEMPLATE/XML

Procédure Aller dans le répertoire [Installation de VS2005]\XML\Schemas Dupliquez le fichier catalog.xml en SPcatalog.xml Ouvrir dans un Notepad le fichier SPcatalog.xml Supprimer toutes les nœuds Associations & Schéma pour ne garde que la racine Coller le contenu suivant

<SchemaCatalog xmlns="http://schemas.microsoft.com/xsd/catalog"><Schema href="%CommonProgramFiles%/Microsoft Shared/web server extensions/12/TEMPLATE/XML/wss.xsd" targetNamespace="http://schemas.microsoft.com/sharepoint/"/>

</SchemaCatalog>

Désormais, il vous suffit de rajouter l’attribut xmlns dans le nœud racine de vos fichiers XML pour que VS.Net vous propose la liste des schémas disponibles


http://www.microsoft.com/downloads/details.aspx?familyid=1beeac6f-2ea1-4769-9948-74a74bd604fa&displaylang=en&tm

http://www.microsoft.com/downloads/details.aspx?familyid=1beeac6f-2ea1-4769-9948-74a74bd604fa&displaylang=en&tm

http://www.microsoft.com/downloads/details.aspx?displaylang=fr&familyid=04d26402-3199-48a3-afa2-2dc0b40a73b6

http://www.microsoft.com/downloads/details.aspx?displaylang=fr&familyid=04d26402-3199-48a3-afa2-2dc0b40a73b6




Et en sélectionnant le schéma http://schemas.microsoft.com/sharepoint, vous obtenez automatiquement le contrôle et l’IntelliSense du CAML de votre fichier

Schema Cachehttp://msdn2.microsoft.com/en-us/library/ms255821(VS.80).aspx

Une machine virtuelle SharePoint 2007 avec Visual Studio et ses configurations de modèle, ainsi que ces outils tiers ou communautaire, constitue la véritable boite à outil du développeur SharePoint. Pensez toujours à garder une copie « propre » de cette machine !N’oubliez pas le système d’annulation et/ou de différentiation de Virtual Pc !

Une dernière remarque. Comme SharePoint 2007 est un générateur de site, rien ne vous empêche de créer une collection dédiée ou un sous site Web pour chaque développement. Ainsi, vous évitez de mélanger les Features, DLL et autres composants entre eux pendant vos tests et développements. Vous travaillez donc sur des environnements propres à chaque développement, facteur de succès bien connu et surtout sans risque

Pour ce tutoriel, nous rajouterons simplement une collection de site dédié :


http://msdn2.microsoft.com/en-us/library/ms255821(VS.80).aspx

http://schemas.microsoft.com/sharepoint

http://www.flickr.com/photos/andrewconnell/274840489/



Comme les Features sont spécifiques à des scopes, il faut mieux créer une instance du scope de son développement pour pouvoir mieux l’évaluer en situation, avec le moins d’interférence possible avec d’autres jeux de test ou composants.

3.2 Création du projet

La première phase de tout projet SharePoint est de pouvoir créer un environnement de développement dédié et favorable à ses spécificités.

Comme nous l’avons vu dans les premiers chapitres, nous utiliserons une arborescence similaire au fameux répertoire 12 contenant l’ensemble des fichiers systèmes mais dans le projet Visual Studio.

Déroulement de l’exercice :

1. Ouvrir Visual Studio et créer un projet de développement de type Projet vide.



Nous allons créer un modèle de site que nous appellerons « SharePointCoach »

2. Reproduire l’arborescence du répertoire 12 nécessaire à notre projet via l’ajout de dossier dans l’explorateur Visual Studio

Il faut créer l’arborescence suivante

12 (le cœur système de SharePoint)o Ressources (pour gérer les fichiers de traduction Resx)o TEMPLATE (répertoire des modèles)

IMAGES (stockage des images) FEATURES (Stockage des « Features»)

Batchs (scripts d’initialisation du projet)

3.3 Création du corps d’une Feature

3.3.1 Sous-arborescence spécifique

Les Features sont avant tout un regroupement de fichier XML. L’utilisation des Features étant pensée autour de la notion de composant, leur déploiement doit leur assuré un maximum d’indépendance par rapport aux serveurs SharePoint les hébergeant.

Des lors, tous les fichiers composant une Features possède une arborescence spécifique dans le sous répertoire 12/TEMPLATES/FEATURES

Un dossier [NomDeLaFeature]C’est le répertoire racine même de la Feature ainsi que son nom

Le nom du dossier dans Features est très important car il s’agit simplement d’un des identifiants d’une Feature. Il sera réutilisé aussi bien dans les fichiers de configuration que dans le modèle objet en cas de référencement dynamique ou de scripting.

Un sous dossier [NomDeLaFeature]/ResourcesCe dossier contient par défaut les fichiers de ressources (.RESX) gérant l’aspect multilingue des libellés de la Feature

Tous sous dossier en dessous de [NomDeLaFeature]Ils n’ont pas de rôle particulier mais permettent de classifier les fichiers plutôt que simplement tous les ajouter en sous racine.



3.3.2 Manifest de la FeatureLe premier fichier à créer dans une Feature est son fichier Manifest « feature.xml ». Il sert de référence au moteur SharePoint puisqu’il définit les différentes propriétés générales décrivant le rôle propre de la Feature.

Voici le fichier feature.xml de notre tutoriel

Code XML le fichier feature.xml de notre tutoriel: 12/TEMPLATE/FEATURES/SimpleFeature/feature.xml<Feature Id="5A30C81B-861D-48e2-8799-929A7252A163" Title="$Resources:FeatureName" Description="$Resources:FeatureDescription" Version="1.0.0.0" Scope="Web" Hidden="FALSE" ImageUrl="Wygwam/WygFeature.jpg" xmlns="http://schemas.microsoft.com/sharepoint/">

<ElementManifests><ElementManifest Location="element_CustomAction.xml" /><ElementManifest Location="element_MasterPage.xml" /><ElementManifest Location="element_List.xml" /><ElementManifest Location="element_ListWebPage.xml" /><ElementFile Location="Resources\Resources.en-US.resx"/> <ElementFile Location="Resources\Resources.fr-FR.resx"/><ElementFile Location="Resources\Resources.resx"/>

</ElementManifests></Feature>

Il y a quelques points qu’il est bon de préciser :

ID : C’est un GUID identifiant de manière unique la Feature dans SharePoint Attention de bien le changer si vous recopier un fichier feature.xml pour vous servir d’exemple !

Pour créer un GUID facilement, il vous suffit d’aller dans l’onglet outil de Visual Studio et de cliquer sur le raccourci « CreateGUID »



Titre/Description/Version : Ces attributs définissent la Features pour les utilisateurs, l’utilisation du token « $Resources:Alias » précise juste l’utilisation des fichiers de traduction pour obtenir le bon libellé selon le code de langue du site utilisant la Feature

ImageUrl : il contient le chemin URL d’une image représentant la Feature dans l’interface d’administration.

La base de l’adresse URL correspond au chemin virtuel de « _layouts/images ». Il faut donc que le fichier image soit copié dans le répertoire 12/TEMPLATE/IMAGE. Dans notre exemple, nous avons crée un icône dans un sous dossier d’image au nom de wygwam pour plus facilement les classer.

xmlns="http://schemas.microsoft.com/sharepoint/" : il définit la référence au schéma XSD de SharePoint. Ainsi le contrôle de validation et l’IntelliSense est assuré automatiquement par Visual Studio.

Hidden : Notre Feature étant une démo, nous la laissons visible afin de pouvoir l’utiliser depuis l’interface d’administration

Scope : l’objectif de cette Feature est d’ajouter de nouveaux contenus à n’importe quel site SharePoint, nous avons donc choisi le scope « Web »

Si votre Feature concerne plus la partie configuration comme par exemple les WebParts ou les Layouts de Publishing dans WCM, il faudrait alors utiliser un scope : Site. En effet, les galeries de WebPart comme celle des Layouts sont des galeries de racine des collections de site, d’où le choix évident.

La Feature de démo possède plusieurs références « ElementManifest » et « ElementFile » : ElementFile pointe les fichiers utilisés par la Feature comme les fichiers RESX par exemple ElementManifest pointe les fichiers XML d’action. Soit le flux CAML décrivant les actions de

génération à mener dans le site lors de l’activation de la Feature.

Il n’est pas nécessaire de préciser tous les fichiers physiques utilisés dans une Feature. Cependant, il est conseillé de le faire afin de faciliter la phase de packaging/déploiement « Solution » car il permet à la Feature d’être auto descriptive. Il évite ainsi de refaire un recensement du contenu de la Feature car celle-ci le gère déjà via son manifest.

3.3.3 Fichiers de ressource

Ceci n’est pas une nouveauté mais l’utilisation de fichier de ressource RESX est certainement un des Best Practices les plus importants afin de pouvoir maitriser la gestion des libellés de la Feature en dehors de ces fichiers techniques et surtout selon plusieurs codes de langue.

Le fonctionnement des ressources est strictement identique à celui des « Site Definition » comme nous l’avons vu dans le second tutoriel. Il utilise les mêmes fichiers de ressource ainsi que l’extension builder de traduction « $Resources;AliasDeTraduction ».

A une petite différence prés, les Features étant autonomes, elles possèdent leurs propres fichiers RESX dans leurs arborescences dédiés : [NomDeLaFeature]/Resources



Si vous désirez mutualiser un fichier RESX entre plusieurs Features et aussi avec les Site Definitions, vous pouvez déployez les fichiers dans 12/RESOURCES et utiliser un appel direct à celui-ci selon la règle suivante : « $Resources:NomDuFichier;AliasDeTraduction ».

3.3.4 Fichiers d’action et fichiers physique

Si le manifest permet de décrire la Feature, ce sont les fichiers d’action qui décrivent l’action de génération de la Feature.

Ils peuvent être légers ou très volumineux selon le code CAML que vous allez utilisez.Au minimum, ils contiennent le code XML suivant :

Code XML d’un fichier d’action: 12/TEMPLATE/FEATURES/SimpleFeature/xxx.xml<Elements xmlns="http://schemas.microsoft.com/sharepoint/">…</Elements>

Bien sur, la référence à xmlns="http://schemas.microsoft.com/sharepoint/" permet d’assurer la référence au schéma CAML comme dans le cas de Feature.xml.

Une Feature est composée d’un ou de plusieurs fichiers Actions. Il n’y a pas de règles ou de norme précise mais par expérience, il est bon de diviser votre code CAML en plusieurs actions et de ne les regrouper que par rôle fonctionnel.Si vous prenez par exemple le cas d’un type de contenu spécifique, la Feature contiendrait 2 fichiers actions : un pour définir les types de colonnes à créer, un second définissant le content type et référençant les identifiants des colonnes déclarés avant.

Bien sur, si votre Feature devient très importante, n’oubliez pas de la diviser en de multiples micro Feature. Prenez en exemple, la Feature TeamCollab. La conception et la maintenance de l’ensemble n’en sera que plus simple.

3.4 Batchs de déploiement d’une FeatureA la différence des Site Definitions qui nécessitent pas de paramétrage particulier pour être utilisés, les Features doivent être déclarés au niveau du moteur SharePoint, et uniquement par un administrateur.

Cette opération doit se faire obligatoirement par script via l’outil de gestion en ligne de commande STSADM.

Pour faciliter la gestion des lignes de commande sur STSADM, pensez bien à paramétrer les variables d’environnement de votre machine SharePoint sur l’adresse de 12/Bin



Il suffit simplement d’utiliser l’appel suivant

stsadm.exe -o installfeature -filename [NomDuDossierDeFeature]\feature.xml

Ensuite vous pouvez activez la Feature depuis l’interface de gestion de SharePoint.

Afin de gagner du temps dans vos développements, il est d’autant plus pratique de scripter toute l’opération. Soit installer et activer votre Feature directement sur l’URL de votre site SharePoint de Test. Une remarque cependant, pensez toujours à désactiver, désinstaller la Feature si vous travailler toujours sur le même site. A la différence du mode « force » d’installfeature, vous êtes sur que votre configuration SharePoint reste propre et saine.

Batch de déploiement dans le sous répertoire Batchs de la solution VS.Netcd ..cd 12@echo off

ECHO "-- FULL Deploy of the solution --"

@SET SPDIR="c:\program files\common files\microsoft shared\web server extensions\12"@SET FEATUREPath="SimpleFeature"@SET URLWss="http://o12srv:141/sites/CoachSP/"@SET PATHWss="C:\Inetpub\wwwroot\wss\VirtualDirectories\141"

xcopy TEMPLATE %SPDIR%\TEMPLATE /s /yxcopy Resources %SPDIR%\Resources /s /y

ECHO "desactivefeature"%SPDIR%\bin\stsadm.exe -o deactivatefeature -filename %FEATUREPath%\feature.xml -url %URLWss% -force

ECHO "uninstallfeature"%SPDIR%\bin\stsadm.exe -o uninstallfeature -filename %FEATUREPath%\feature.xml -force

ECHO "installfeature"%SPDIR%\bin\stsadm.exe -o installfeature -filename %FEATUREPath%\feature.xml -force

ECHO "activatefeature"%SPDIR%\bin\stsadm.exe -o activatefeature -filename %FEATUREPath%\feature.xml -url %URLWss% -force

REM cscript.exe c:\windows\system32\iisapp.vbs /a "SharePoint - 141" /rREM IISRESET

Pause

L’utilisation des commentaires avec REM permet d’invalider certaines parties du code. Bien pratique quand vous ne voulez que redéployer les fichiers .Net sans devoir relancer entièrement le processus de désinscription/inscription.



3.5 Développement : ajout d’action !

Désormais, votre Feature est prête à être personnalisée : la solution VS.Net existe, le déploiement et le site de test sont aussi la. Vous pouvez passez enfin à la partie Développement

Vous avez du remarquer dans le contenu du Feature.xml de notre Démo la présence de 4 différentes ElementManifest. En effet, pour mieux découvrir le monde passionnant du CAML et des Features, nous allons utiliser 4 scénarii différents dans la même Feature.

Bien sur, en enlevant la référence « ElementManifest », la Feature n’exécute plus l’ensemble des actions mais uniquement celle précisée.

Une autre manière de constituer cette démo aurait été de diviser les 4 actions en 4 Feature et d’utiliser le regroupement avec une Cinquième. Le but étant de présenter le code déclaratif des Features, un seule Feature suffisait largement.

3.5.1 Ajout de Master Pages

Dans le tutoriel sur les « Site Definition », nous avons découvert comment créer et personnaliser son propre modèle de site. Un des grands classique de personnalisation de modèle de site est d’inclure un design spécifique grâce à une Master Page dédié.

Cette opération en CAML s’appuyait sur l’utilisation du nœud « Module » et « File ».

Pour rappel, les modules sont une sorte d’upload virtuel. Ils permettent de préciser à SharePoint la référence physique d’un fichier ASP.Net et sa position dans le site SharePoint. En pratique, tout est géré par le compilateur .Net et le SPVirtualPathProvider, la base de contenu précise le chemin réel du fichier ASP.Net qui sera utilise lors de l’appel d’une URL d’un page dans le SharePoint

Modulehttp://msdn.microsoft.com/en-us/library/ms453137.aspx

How to: Provision a Filehttp://msdn.microsoft.com/en-us/library/ms441170.aspx

Si vous voulez pouvoir mutualiser plusieurs designs pour un site SharePoint, l’idéal reste de créer une simple Feature qui gérera l’ajout d’un jeu de Master Page. Techniquement parlant, il faut que la Feature télécharge les fichiers Master directement dans la galerie des Master Page du site.

Si vous ne savez plus comment utiliser les Modules pour ajouter des Master Pages dans SharePoint, il vous suffit d’inspecter le fichier ONET.XML du modèle Global. Et de s’inspirer de son module de la Default.master : [12]/Template/GLOBAL/XML







Code XML du fichier l’anglais : element_List.xml<Elements xmlns="http://schemas.microsoft.com/sharepoint/">

<Module Name="MasterPages" List="116" Url="_catalogs/masterpage" Path="MP" RootWebOnly="FALSE">

<File Url="default_R.master" Type="GhostableInLibrary" /><File Url="default_G.master" Type="GhostableInLibrary" /><File Url="default_B.master" Type="GhostableInLibrary" />

</Module></Elements>

Ce qu’il est bon de noter : La référence du module à la galerie des Pages Maitres

o List=116 : elle correspond au type de la listeo Url="_catalogs/masterpage" : soit l’alias d’adresse de la listeo Path="MP" : dans notre solution de projet, il existe un répertoire MP dans le sous

répertoire dédié à la Feature ou nous stockons les diverses pages (surtout dans le but de classer un peu le contenu de la Feature)

o RootWebOnly="FALSE" : comme les Master Pages seront utilisable à tout niveau d’une collection de site, nous évitons de les restreindre à la racine

Le module gère 3 téléchargements en parallèles. Ce sont 3 Master Pages (une bleue, une verte et une rouge)

o Type="GhostableInLibrary" : Afin de profiter du système de cache de SharePoint et de la compilation JIT de .Net, nous précisons bien l’utilisation de la virtualisation SharePoint dans une liste vie "GhostableInLibrary"

Une fois, la Feature active, vous trouverez 3 nouvelles Pages Maitres disponibles pour votre site.

Ce scénario est facilement réutilisable et extensible comme par exemple : Référencer l’identifiant de Feature dans votre Modèle de site Intégrer la Feature dans un regroupement de Feature projet (Dépendance) Utiliser le Stapling sur un modèle de site particulier voir la modèle Global pour avoir ces pages

maitres dans toutes création de site sur la ferme (Association)

Pour appliquer une nouvelle Page Maitre sous MOSS, vous pouvez utilisez l’administration du site mais ce n’est pas possible sous WSS. Il faudra soit utiliser le code soit utiliser SharePoint Designer.

Ce projet propose une Feature applicative rajoutant un lien de gestion de page maitre pour WSS. Un bon exemple et complément de cette démohttp://www.codeplex.com/SPMasterPicker

3.5.2 Ajout de menu

Les menus de gestion et même d’action de SharePoint 2007 reposent pour la plupart sur l’activation de Feature. Qu’il s’agisse du menu de création, de l’administration des sites ou des Web Application jusqu’à l’administration centrale et le paramétrage des liste.

A vrai dire, un lien de gestion de SharePoint peut être résumé en 3 parties bien distinctes : Une zone fonctionnelle précise : le menu d’action, le « Site Settings », …


http://www.codeplex.com/SPMasterPicker

http://www.codeplex.com/


Une catégorie de lien : souvent les liens sont regroupés par une catégorie comme Galeries, Aspect ou Administration

Le lien : l’url, le titre, l’icône et tout ce qui peut définir le menu en question.

Le tag CAML utilisé est « CustomAction », on peut paramétrer ces 3 paramètres principaux via les attributs :

Location (Zone fonctionnelle) GroupId (Catégorie de lien) UrlAction (l’adresse URL)

Ce fonctionnement repose sur un contrôle web bien particulier que vous pouvez réutilisez pour créer vos propres pages « dynamiques » : <SharePoint:FeatureLinkSections ID="Sections" runat="server" CellPadding="4" CellSpacing="4" Columns="2" Location="Microsoft.SharePoint.Administration.Operations" Width="100%"OnAddLink="OnAddLink" />

Comme précisé plus tôt, c’est ainsi que l’administration centrale est construite via la Feature « AdminLinks ». Cette Feature crée les diverses catégories grâce au tag CustomActionGroup et ajoute les liens via le tag CustomAction.

Custom Action Definitionshttp://msdn.microsoft.com/en-us/library/ms465980.aspx

Cependant, avant d’ajouter des liens de gestion, il est bon de connaitre à l’avance l’interface et la catégorie que vous voulez utiliser afin d’intégrer au mieux votre nouveau lien dans un site existant. Comme par exemple, l’interface d’administration : « Microsoft.SharePoint.SiteSettings » et la catégorie administration de la collection : « SiteAdministration »

Voici une liste de la plupart des GroupIds et des Location utilisé dans SharePoint 2007 par défaut :

Location GroupId(Administration Centrale / Opérations)Microsoft.SharePoint.Administration.Operations

Topology GlobalConfiguration Security BackupRestore LoggingAndReporting DataConfiguration Upgrade

(Administration Centrale / Application)Microsoft.SharePoint.Administration.ApplicationManagement

WebApplicationConfiguration

SiteManagement ApplicationSecurity ExternalService WorkflowManagement

(Administration locale des sites)Microsoft.SharePoint.SiteSettings

UsersAndPermissions Customization QuickLaunch Galleries SiteAdministration SiteCollectionAdmin

(menu standards)Microsoft.SharePoint.StandardMenu

ActionsMenu(menu d’action dans les





listes et les vues documentaires)

ActionsMenuForSurvey NewMenu

(menu d’ajout dans les listes et les vues documentaires) SettingsMenu (menu de gestion dans les listes et les vues documentaires)

SettingsMenuForSurvey SiteActions (menu déroulant d’action

du site) UploadMenu

(menu de téléchargement dans les listes et les vues documentaires)

Microsoft.SharePoint.ContentTypeTemplateSettings …

Microsoft.SharePoint.ContentTypeSettings …

Microsoft.SharePoint.Administration.ApplicationCreated …

(Administration des SharedServices)Office.Server.ServiceProvider.Administration

…

Microsoft.SharePoint.ListEdit.DocumentLibrary …

Microsoft.SharePoint.Workflows …

NewFormToolbar …

DisplayFormToolbar …

EditFormToolbar …

Liste complète : Default Custom Action Locations and IDshttp://msdn.microsoft.com/en-us/library/bb802730.aspx

Les possibilités de personnalisation des menus ne sont pas limitées du tout. D’ailleurs, le tag « HideCustomAction » permet même de supprimer des menus existants pour introduire de nouveau en remplacement.

Pour notre démo, nous allons juste rajouter un lien de gestion dans le menu d’action de site. Ce sera un simple raccourci sur la page de gestion des thèmes,


http://msdn.microsoft.com/en-us/library/bb802730.aspx



Code XML du fichier l’anglais : element_CustomAction.xml<?xml version="1.0" encoding="utf-8"?><Elements xmlns="http://schemas.microsoft.com/sharepoint/"> <CustomAction

Id="SelectThemeSite" GroupId="SiteActions"

Location="Microsoft.SharePoint.StandardMenu"Sequence="10"RequireSiteAdministrator="True"Title="Select the theme"ImageUrl="~/_layouts/images/lg_ICBMP.gif"Description="">

<UrlAction Url="_layouts/themeweb.aspx"/> </CustomAction></Elements>

Le constat est rapide : c’est extrêmement simple à faire !

Ce qu’il est bon de noter : Le GroupId du menu d’action est « Site Action » associé à la Location

« Microsoft.SharePoint.StandardMenu »

L’attribut « Sequence » permet de définir une priorité à l’activation de l’action. Si jamais 2 Features interfèrent sur le même composant, c’est celui qui aura la séquence la plus petite qui sera prioritaire.

L’attribut RequireSiteAdministrator permet de restreindre l’accès à ce lien qu’aux utilisateurs administrateurs

Cet exemple est simple tout comme son implémentation. Il est possible de l’enrichir aisément avec d’autres options comme :

Restriction de sécuritéIl est possible aussi de préciser un masque de permission minimal d’accès au menu via l’attribut « Rights »

Exemple : « Rights= ’ViewListItems,ManageAlerts,… ‘».

Ce masque s’appuie sur les permissions de base de SharePoint et fonctionne sur un « ET » logique. Seul un utilisateur qui possédant l’ensemble des permissions définis peut accéder au menu

SPBasePermissions Enumeration (Microsoft.SharePoint)http://msdn.microsoft.com/en-us/library/microsoft.sharepoint.spbasepermissions.aspx

Filtrage par type


http://msdn.microsoft.com/en-us/library/microsoft.sharepoint.spbasepermissions.aspx



Certains des liens de gestion sont dans les menus des listes tels que les contacts ou les bibliothèques de contenu. Ce sont aussi des pistes de personnalisation très intéressantes. Des menus de transfert de fichier, conversion OpenXML/PDF, compression, synchronisation, …, tout serait possible avec ASP.Net en support et directement intégré depuis l’interface utilisateur des listes.

Cependant SharePoint favorise la création de liste de manière générique. Il est donc compliqué de cibler une liste précise dans le volume de génération de SharePoint. Vous pouvez cependant spécifier un filtrage de type que ce soit :

o ContentType o FileType o List o ProgId

Vous pouvez restreindre une « CustomAction » selon un critère de type de contenu voir un type de liste par exemple. Ainsi, tout nouvelle liste générée qui implémenterait un de vos types de contenu métier, héritera aussi du menu métier spécifique de la Feature.

Exemple

Code XML du fichier l’anglais : element_CustomAction.xml<?xml version="1.0" encoding="utf-8"?><Elements xmlns="http://schemas.microsoft.com/sharepoint/"> <CustomAction Id="UserInterfaceLightUp.DocLibNewToolbar" RegistrationType="List" RegistrationId="101" GroupId="NewMenu" Rights="ManagePermissions" Location="Microsoft.SharePoint.StandardMenu" Sequence="1000" Title="Nouveau boutton de gestion de permission dans les listes documentaires"> <UrlAction Url="/_layouts/LightupHello.aspx?NewMenu"/> </CustomAction>

<CustomAction Id="UserInterfaceLightUp.DocLibNewToolbar" RegistrationType="ContentType" RegistrationId="0x010100F52DEB6C7A623E42B012E39700B92945" Rights="ManagePermissions" Sequence="11" Title="Demonstration de menu d'édition de document"> <UrlAction Url="/_layouts/Hello.aspx?NewMenu"/> </CustomAction> </Elements>

Ce qu’il est bon de noter :o Cibler une liste documentaire : type = List, RegistrationId=101 (type de la liste)o Cibler un ContentType : type = ContentType, RegistrationId=0x101… (GUID hexa

type de contenu)

What are Content Type IDs?http://blogs.msdn.com/andrew_may/archive/2006/06/24/SharePointBeta2WhatAreContentTypeIDs.aspx


http://blogs.msdn.com/andrew_may/archive/2006/06/24/SharePointBeta2WhatAreContentTypeIDs.aspx

http://blogs.msdn.com/andrew_may/archive/2006/06/24/SharePointBeta2WhatAreContentTypeIDs.aspx



Utilisation de Token

Les tokens servent de clé de remplacement de valeur système. En les utilisant dans le XML, vous pouvez ainsi préciser un code représentant des données SharePoint qui seront évaluées dynamiquement et surtout selon le contexte de votre Feature.

Ce sont souvent les compagnons idéaux des CustomActions et du Filtrage de type. En effet, si le filtrage permet de préciser des menus spéciaux, les Tokens permettent de fournir des paramètres aux adresses via Querystring

Ainsi, si vous rajoutez dans le système applicatif, une page ASPX et une DLL, vous pouvez la rendre générique si elle accepte simplement en paramètres de ligne, l’identifiant de liste, d’item et/ou l’adresse du site

Voici la liste des Tokens :

Token Valeur ~site Adresse relative du site courant ~sitecollection Adresse relative du site collection courant {ItemId} ID (Entier) représentant l'item courant d'une liste {ItemUrl} Url de l'item en cours dans une Document Library {ListId} Guid de la liste {SiteUrl} Url du site courant

Exemple

Code XML du fichier l’anglais : element_CustomAction.xml<?xml version="1.0" encoding="utf-8"?><Elements xmlns="http://schemas.microsoft.com/sharepoint/"> <CustomAction Id="ClearListItems" Location="Microsoft.SharePoint.StandardMenu" GroupId="ActionsMenu" Title="Delete All Items" RegistrationType="List" Sequence="10"> <UrlAction Url="~site/_layouts/App/ClearList.aspx?List={ListId}"/> </CustomAction> </Elements>

How to: Add Actions to the User Interfacehttp://msdn.microsoft.com/en-us/library/ms473643.aspx

3.5.3 Création de Liste

Il est difficile de dissocier dans le monde SharePoint, les sites web et les listes. Ils sont intimement liés structurellement et techniquement.

Ainsi, un bon modèle de site SharePoint se constitue aussi bien d’interface et de design que d’ensemble de liste prête à l’emploi.

Un exemple simple : prenez le modèle de site vierge





Sans aucune liste et donc aucune ListViewWebPart ramenant le contenu à l’accueil, le site n’est qu’une coquille creuse.

Bien sur, on peut inclure les instances de listes directement dans le modèle de site mais il peut être intéressant de les factoriser dans une Feature : c’est d’ailleurs le but de cette Démo.

Code XML du fichier l’anglais : element_List.xml<?xml version="1.0" encoding="utf-8"?><Elements xmlns="http://schemas.microsoft.com/sharepoint/"> <ListInstance FeatureId="00BFEA71-E717-4E80-AA17-D0C71B360101" TemplateType="101" Title="$Resources:TitleList" Url="ProjectDocs" Description="$Resources:DescriptionList" QuickLaunchUrl="ProjectDocs/Forms/AllItems.aspx" />

  <ContentTypeBinding ListUrl="ProjectDocs" ContentTypeId="0x010109" />

 <Module Path="Global" Url="ProjectDocs/Global" />

 <Module Path="Phase1" Url="ProjectDocs/Phase1" /> <Module Path="Phase2" Url="ProjectDocs/Phase2" /> <Module Path="Final" Url="ProjectDocs/Final" /> <Module Path="Alpha" Url="ProjectDocs/Final/Alpha" /> <Module Path="Beta" Url="ProjectDocs/Final/Beta" /> <Module Path="Release" Url="ProjectDocs/Final/Release" /></Elements>

Ce qu’il est bon de noter :

Ajout d’une nouvelle instance de liste

Notre démo crée une simple liste documentaire « Documents du projet »Nous utilisons donc le nœud « ListInstance ».

Ces attributs sont assez simples :o Titre et Description : une petite recommandation, il faut mieux utiliser les fichiers de

ressources de la Feature pour leur libellé o URL : il s’agit de définir son alias qui composera de manière définitive son adresse

dans le site SharePoint à la différence de son titre qui peut être modifié.o QuickLaunchUrl : il définit l’url représentant la liste dans le menu de lancement

rapide. Souvent, on utilise un lien vers l’une des vues de la liste soit [ALIAS de la Liste]/Forms/[page de la vue].aspx

o TemplateType : chaque liste s’appuie sur un type de base qu’il faut préciser.Voici la liste de ceux par défaut d’un serveur WSS classique

Type de liste codeAnnouncement 104 Discussion Boards 108Document Library 101



Events 106Generic List 100Issue List 1100Contacts List 105Task List 107Survey List 102InfoPath Form Library 115Image Library 109Links List 103

o FeatureId : afin d’éviter de décrire toute la composition de la liste, des vues et des champs, cet attribut permet de préciser simplement l’identifiant de Feature qui elle déclare le type de Feature

Les identifiants de Feature des listes de bases SharePoint ont tous un point communIls utilisent tous le format suivant ‘00BFEA71-E717-4E80-AA17-D0C71B360’ + Identifiant du typeSoit pour une liste documentaire 00BFEA71-E717-4E80-AA17-D0C71B360101

Référencement d’un Content Type

Afin de jouer la carte de la catégorisation, nous appliquons à notre nouvelle instance de liste le Content Type des pages HTMLS (Basic Pages). Ainsi, les utilisateurs pourront aussi ajouter de simples pages HTML.

Cette action est très simple, on utilise le nœud ContentTypeBinding

 <ContentTypeBinding ListUrl="ProjectDocs" ContentTypeId="0x010109" />

L’application du type de contenu sur une liste spécifique demande de bien préciser l’alias de la liste via l’attribut « ListUrl », soit dans notre cas, la valeur « ProjectDocs » comme définit dans l’attribut Alias du nœud « ListInstance ».

Quand au choix du type de contenu, il faut juste préciser son identifiant hexadécimal 0x010109

Nous avons obtenu cet identifiant en lisant simplement la Feature « ctypes »

Ces Identifiants sont construits par héritage de l’identifiant de leur type de base. Ici, il s’agit d’un liste documentaire dont l’identifiant de type de contenu est 0x0101 (on retrouve d’ailleurs le type de base 101, comme par hasard)

Création d’une structure de dossier

Bien que nous vous conseillions toujours d’organiser votre taxonomie par l’utilisation de catégorie et de type de contenu, les dossiers resteront toujours une solution de classement bien pratique. Cependant, il ne gère rien de plus qu’un point de stockage

La création de dossier correspond à la génération d’un contenu dans un Site SharePoint. Pour ceux qui ont lut le chapitre, c’est effectivement le rôle du nœud « Module »



Par définition, un Module est utilisé pour ajouter un fichier dans un dossier ou une liste d’un site SharePoint. Cependant, si vous ne précisez aucun fichier, le Module crée quand même le chemin précisé.

Ainsi, pour créer une arborescence comme

Finalo Alphao Beta

Global Phase1 Phase2

Il faut recréer la même structure via plusieurs « Modules » avec bien sur, en référence, l’adresse de l’alias de la liste ciblé, soit « ProjectDocs » pour notre exemple

 <Module Path="Global" Url="ProjectDocs/Global" />

 <Module Path="Phase1" Url="ProjectDocs/Phase1" /> <Module Path="Phase2" Url="ProjectDocs/Phase2" /> <Module Path="Final" Url="ProjectDocs/Final" /> <Module Path="Alpha" Url="ProjectDocs/Final/Alpha" /> <Module Path="Beta" Url="ProjectDocs/Final/Beta" /> <Module Path="Release" Url="ProjectDocs/Final/Release" />

3.5.4 Création de Page avec ses WebParts associées

Ce scénario est une variante de la création de liste mais sur un type particulier : les pages à WebPart.

Cet exemple est important car c’est vraiment un des grands classiques d’extension de SharePoint. Bien souvent, les utilisateurs reprochent que les espaces de travail SharePoint sont trop légers en termes de page de contenu. En effet, en utilisant les modèles de base, un site SharePoint n’est constitué que d’une seule et simple page d’accueil avec 2 zones à WebPart. Moralité, le choix de mise en page est restreint et, pire que tout, plus les gens ajoutent des WebParts, plus l’accueil devient lourd … Pourquoi ne pas rajouter d’autres pages à WebPart et changer aussi leur Mise en page ?

L’exercice n’est pas si compliqué, voici le code (certaines portions verbeuses ont été ignorées)

Code XML du fichier l’anglais : element_ListWebPage.xml<Elements xmlns="http://schemas.microsoft.com/sharepoint/">

<ListInstanceFeatureId="00BFEA71-E717-4E80-AA17-D0C71B360101"TemplateType="101"Title="$Resources:TitleListWebPage"Url="$Resources:UrlListWebPage"Description="$Resources:DescriptionListWebPage"QuickLaunchUrl="$Resources:UrlListWebPage/Forms/AllItems.aspx"



DocumentTemplate="106" />

<ContentTypeBinding ListUrl="$Resources:UrlListWebPage"

ContentTypeId="0x010109" />

<ContentTypeBinding ListUrl="$Resources:UrlListWebPage"

ContentTypeId="0x01010901" />

<Module Name="CoachWebPage" List="101" Url="$Resources:UrlListWebPage" Path="Pages">

<File Url="SPPageMono.aspx" Name="Credits.aspx" Type="GhostableInLibrary" >

<AllUsersWebPart WebPartZoneID="Right" WebPartOrder="1"><![CDATA[<?xml version="1.0" encoding="utf-8"?>

<WebPart xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> …</WebPart>]]>

</AllUsersWebPart></File><File Url="SPPageMono.aspx" Name="Credits_NonItalic.aspx"

Type="GhostableInLibrary" ><AllUsersWebPart WebPartZoneID="Right" WebPartOrder="1">

<![CDATA[<?xml version="1.0" encoding="utf-8"?><WebPart xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" >…

</WebPart>]]>

</AllUsersWebPart></File>

</Module></Elements>

L’objectif de cette Feature est de crée une liste spécifique « Liste des Webpages » utilisant les types de contenu de page web avec un jeu de pages pré chargé.

Pour aller plus loin, nous pourrions aussi développer une WebPart qui construirait un menu déroulant facilitant la navigation entre ces pages et le site SharePoint.

Avec un peu plus de recul, vous remarquerez vite, que ce scénario n’est qu’une simplification de ce qu’utilise le moteur de publishing de MOSS via sa bibliothèque de « Pages » et ses types de contenu « Layouts ».

Première étape : création de la listeOn retrouve la démo précédente avec la création d’une liste documentaire (type 101).La plupart des informations ont été externalisées dans le fichier de ressource. Si pour le titre et la description la raison est surtout le multilinguisme, pour les autres attributs, il s’agit surtout de pouvoir créer des variables de configuration



En gérant les valeurs clés de votre Feature dans le fichier de ressource, vous pouvez ainsi rendre réutilisable vos éléments puisqu’ils ne contiennent plus de référence en dur. Ils sont devenus paramétrables !

Seconde étape : association de Content Type

Notre nouvelle liste sera associée avec 2 types de contenu qui sont les pages de bases (0x010109) et les pages à WebPart (0x01010901)). Ainsi, l’interface permettra la création aisée de tout contenu Web en 2 cliques

Troisième étape : ajouter des Pages à WebPart

Un grand classique désormais : les Modules.






</Module>

Dans notre exemple, nous utilisons notre nouvelle liste en précisant son URL «$Resources:UrlListWebPage » ainsi que son type 101 pour bien spécifier qu’il s’agit d’un module pour une liste et non le dossier d’un site SharePoint.

L’attribut Path définit le répertoire de stockage des fichiers ASPX dans le répertoire de la Feature.



La page utilisée est très simple, il s’agit d’une copie d’une des pages à WebParts proposées par défaut dans SharePoint 2007 : SPPageMono.aspx, une page avec une seul zone à WebPart

Code : SPPageMono.aspx<%-- _lcid="1033" _version="12.0.4518" _dal="1" --%><%-- _LocalBinding --%><%@ Page language="C#" MasterPageFile="~masterurl/default.master" Inherits="Microsoft.SharePoint.WebPartPages.WebPartPage,Microsoft.SharePoint,Version=12.0.0.0,Culture=neutral,PublicKeyToken=71e9bce111e9429c" %> <%@ Register Tagprefix="SharePoint" Namespace="Microsoft.SharePoint.WebControls" Assembly="Microsoft.SharePoint, Version=12.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %> <%@ Register Tagprefix="Utilities" Namespace="Microsoft.SharePoint.Utilities" Assembly="Microsoft.SharePoint, Version=12.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %> <%@ Import Namespace="Microsoft.SharePoint" %> <%@ Register Tagprefix="WebPartPages" Namespace="Microsoft.SharePoint.WebPartPages" Assembly="Microsoft.SharePoint, Version=12.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %><asp:Content ContentPlaceHolderId="PlaceHolderPageTitle" runat="server">

<SharePoint:ListProperty Property="Title" runat="server"/> - <SharePoint:ListItemProperty Property="BaseName" MaxLength=40 runat="server"/></asp:Content><asp:Content ContentPlaceHolderId="PlaceHolderPageTitleInTitleArea" runat="server">

<WebPartPages:WebPartZone runat="server" Title="loc:TitleBar" ID="TitleBar" AllowLayoutChange="false" AllowPersonalization="false"/></asp:Content><asp:Content ContentPlaceHolderId="PlaceHolderTitleAreaClass" runat="server"> <style type="text/css">

Div.ms-titleareaframe {height: 100%;}.ms-pagetitleareaframe table {background: none;}

</style></asp:Content><asp:Content ContentPlaceHolderId="PlaceHolderAdditionalPageHead" runat="server">

<META Name="GENERATOR" Content="Microsoft SharePoint">



<META Name="ProgId" Content="SharePoint.WebPartPage.Document"><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=utf-8"><META Name="CollaborationServer" Content="SharePoint Team Web Site"><script>var navBarHelpOverrideKey = "wssmain";</script>

</asp:Content><asp:Content ContentPlaceHolderId="PlaceHolderSearchArea" runat="server">

<SharePoint:DelegateControl runat="server"ControlId="SmallSearchInputBox" />

</asp:Content><asp:Content ContentPlaceHolderId="PlaceHolderLeftActions" runat="server"></asp:Content><asp:Content ContentPlaceHolderId="PlaceHolderPageDescription" runat="server">

<SharePoint:ProjectProperty Property="Description" runat="server"/></asp:Content><asp:Content ContentPlaceHolderId="PlaceHolderBodyRightMargin" runat="server">

<div height=100% class="ms-pagemargin"><IMG SRC="/_layouts/images/blank.gif" width=10 height=1 alt=""></div></asp:Content><asp:Content ContentPlaceHolderId="PlaceHolderPageImage" runat="server"></asp:Content><asp:Content ContentPlaceHolderId="PlaceHolderLeftNavBar" runat="server"></asp:Content><asp:Content ContentPlaceHolderId="PlaceHolderNavSpacer" runat="server"></asp:Content><asp:Content ContentPlaceHolderId="PlaceHolderMain" runat="server">

<table cellpadding="4" cellspacing="0" border="0" width="100%"><tr>

<td id="_invisibleIfEmpty" name="_invisibleIfEmpty" valign="top" width="100%"> <WebPartPages:WebPartZone runat="server" Title="loc:FullPage" ID="FullPage" FrameType="TitleBarOnly"/> </td>

</tr><script

language="javascript">if(typeof(MSOLayout_MakeInvisibleIfEmpty) == "function") {MSOLayout_MakeInvisibleIfEmpty();}</script>

</table></asp:Content>

Pour vous servir d’un modèle de base, vous pouvez utiliser :o La page par défaut du modèle Global :

[12]/TEMPLATE/GLOBALo Les modèles de pages à WebPart : [12]\TEMPLATE\1036\STS\DOCTEMP\

SMARTPGS

Cette page est désormais indépendante de SharePoint et n’est liée qu’à sa Feature. En travaillant directement sur le ASP:Content « PlaceHolderMain », vous pouvez créer votre propre mise en page en HTML et positionner de multiples zones à WebPart au besoin

Soit en pratique, rajouter le tag ASP.Net suivant.

<WebPartPages:WebPartZone runat="server" Title="loc:FullPage" ID="FullPage"



FrameType="TitleBarOnly"/>

Sur notre exemple, le menu de lancement rapide a disparu. Ce n’est pas un bug mais un choix de design. Ce menu n’a pas vraiment été supprimé mais son ContentPlaceHolder a juste été utilisé dans notre page pour y inclure un simple espace. Ainsi, il remplace le code ASP.Net originel du menu présent dans la page maitre du site et crée un vide.

<asp:Content ContentPlaceHolderId="PlaceHolderLeftNavBar" runat="server"></asp:Content>

Dans notre exemple, nous utilisons une petite astuce : 2 files dans le même module. Certes ce n’est pas une nouveauté de placer plusieurs fichiers dans le même module si la destination est la même. L’astuce est autre : en jouant avec les paramètres Url et Name du nœud File, nous pouvons utiliser un seul fichier ASPX pour générer 2 fichiers différents dans SharePointEn effet, si on ne précise que l’url du fichier à générer, SharePoint utilise le nom du fichier comme celle de destination. En précisant un Name différent, on peut renommer le fichier et donc le réutiliser.

Ainsi, nous générons 2 fichiers dans la liste : Credits.aspx et Credits_NonItalic.aspx à partir du même fichier SPPageMono.aspx

Quatrième étape : ajouter des WebParts dans Pages à WebPart

Maintenant, que la liste est créée, que les types de contenu sont appliqués, que les modules ont ajoutés les pages à WebPart, il ne reste plus qu’à les initialiser. Soit rajouter plusieurs WebParts.

La configuration des WebParts d’une page se fait justement dans les nœuds enfants des Modules et toujours en CAML.

Pour la Démo, nous utiliserons 2 instances différentes de la WebPart Editeur de contenu (CEWP). La méthodologie utilisée étant la même quelque soit la WebPart, il n’est pas nécessaire de utiliser une complexe.

Une WebPart est techniquement parlant qu’un simple contrôle Web utilisant le framework WebPart pour pouvoir être intégré dynamiquement dans des pages Web. Afin de gérer ce comportement, il est nécessaire de définir un contrat recensant toutes les caractéristiques du composant comme son titre, sa taille, ses propriétés publiques et surtout la classe objet associée à sa dll (afin de l’identifier pour l’instancier). Ce contrat, au format XML, est connu sous le terme générique de manifeste mais aussi par ses extensions que sont :

.dwp : format SPS 2003 .webpart : format ASP.Net 2.0

Quand un gestionnaire ajoute une WebPart par glisser/déplacer, il indique simplement au moteur SharePoint, quel manifeste de WebPart il faut utiliser pour instancier le composant dans une zone précise. C’est exactement ce comportement que nous reproduirons en CAML dans cette démo.

Il nous faut juste utiliser le nœud « AllUsersWebPart » dans la définition « File » de votre « Module »








</Module>

Les attributs « WebPartZoneID » et « WebPartOrder » précisent juste le positionnement de la WebPart en tant que Zone et d’ordre d’apparition avec les autres WebPart (c’est une pile)

Pour intégrer le manifeste du composant, il ne reste plus qu’à ajouter la source XML. Afin qu’il ne soit pas mal analysé par le parseur CAML, le manifeste est déclaré entre les balises < ![CDATA[ … ]]> (pour "Character Data", données de caractère)le manifeste est utilisé comme paramètre de la page après génération, il n’est pas utile autrement

La rédaction d’un manifeste de WebPart peut être complexe, il existe une bonne alternative pour éviter toute erreur : vous pouvez l’exporter depuis une interface SharePoint avec toutes ses propriétés déjà paramétrées. Ainsi plus de risque d’erreur

Voici le manifest de la WebPart Editor de contenu avec un simple message « Bienvenue sur un site »

<?xml version="1.0" encoding="utf-8"?><WebPart xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://schemas.microsoft.com/WebPart/v2"> <Title>Introduction</Title> <FrameType>None</FrameType> <Description>Use for formatted text, tables, and images.</Description> <IsIncluded>true</IsIncluded> <ZoneID>FullPage</ZoneID> <PartOrder>0</PartOrder> <FrameState>Normal</FrameState> <Height /> <Width /> <AllowRemove>true</AllowRemove>



<AllowZoneChange>true</AllowZoneChange> <AllowMinimize>true</AllowMinimize> <AllowConnect>true</AllowConnect> <AllowEdit>true</AllowEdit> <AllowHide>true</AllowHide> <IsVisible>true</IsVisible> <DetailLink /> <HelpLink /> <HelpMode>Modeless</HelpMode> <Dir>Default</Dir> <PartImageSmall /> <MissingAssembly>Cannot import this Web Part.</MissingAssembly> <PartImageLarge>/_layouts/images/mscontl.gif</PartImageLarge> <IsIncludedFilter /> <Assembly>Microsoft.SharePoint, Version=12.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c</Assembly> <TypeName>Microsoft.SharePoint.WebPartPages.ContentEditorWebPart</TypeName> <ContentLink xmlns="http://schemas.microsoft.com/WebPart/v2/ContentEditor" /> <Content xmlns="http://schemas.microsoft.com/WebPart/v2/ContentEditor"><![CDATA[

<FONT size=5>Bienvenue sur ce site personnalisé</FONT> ]]></Content> <PartStorage xmlns="http://schemas.microsoft.com/WebPart/v2/ContentEditor" /></WebPart>

Le flux décrit bien l’ensemble des propriétés du composant ainsi que sa définition de type. On remarque que la webPart Editeur de contenu ou CEWP fait partie du namespace

« Microsoft.SharePoint.WebPartPages » de la DLL « Microsoft.SharePoint »

Le texte HMTL est précisé par le sous nœud « Content », encodé en HTML

ATTENTIONL’intégration des manifeste de WebPart se fait dans le flux CAML du Module. En dehors des problématiques pro SharePoint ou CAML, il faut aussi respecter la cohérence du format XML. En l’occurrence, il n’est pas possible de créer un enchainement de CDATA.Le fait que le .webpart contienne pour le contenu un fragment de code html balisé, il rend le flux XML mal formé et donc inutilisable

La solution est de ré-encoder les caractères spéciaux de votre propriété HTML. Soit en pratique, remplacer les < et > par « < » et « > », ni plus ni moins

Partant de ce principe, voici les 2 sources XML de nos manifestes telles que nous les utiliserons dans les modules

Code XML pour le manifest de WP « Bienvenue en italique»<WebPart xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://schemas.microsoft.com/WebPart/v2"> <Title>Introduction</Title> <FrameType>None</FrameType> <Description>Use for formatted text, tables, and images.</Description> <IsIncluded>true</IsIncluded> <ZoneID>Left</ZoneID> <PartOrder>0</PartOrder>



<FrameState>Normal</FrameState> <AllowRemove>true</AllowRemove> <AllowZoneChange>true</AllowZoneChange> <AllowMinimize>true</AllowMinimize> <AllowConnect>true</AllowConnect> <AllowEdit>true</AllowEdit> <AllowHide>true</AllowHide> <IsVisible>true</IsVisible> <HelpMode>Modeless</HelpMode> <Dir>Default</Dir> <MissingAssembly>Cannot import this Web Part.</MissingAssembly> <PartImageLarge>/_layouts/images/mscontl.gif</PartImageLarge> <Assembly>Microsoft.SharePoint, Version=12.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c</Assembly> <TypeName>Microsoft.SharePoint.WebPartPages.ContentEditorWebPart</TypeName> <ContentLink xmlns="http://schemas.microsoft.com/WebPart/v2/ContentEditor" /> <Content xmlns="http://schemas.microsoft.com/WebPart/v2/ContentEditor">

<FONT size=5><EM>Bienvenue sur ce site personnalisé</EM></FONT> </Content>

<PartStorage xmlns="http://schemas.microsoft.com/WebPart/v2/ContentEditor" />

</WebPart>

Code XML pour le manifest de WP « Bienvenue »<?xml version="1.0" encoding="utf-8"?><WebPart xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://schemas.microsoft.com/WebPart/v2"> <Title>Introduction</Title> <FrameType>None</FrameType> <Description>Use for formatted text, tables, and images.</Description> <IsIncluded>true</IsIncluded> <ZoneID>Left</ZoneID> <PartOrder>0</PartOrder> <FrameState>Normal</FrameState> <AllowRemove>true</AllowRemove> <AllowZoneChange>true</AllowZoneChange> <AllowMinimize>true</AllowMinimize> <AllowConnect>true</AllowConnect> <AllowEdit>true</AllowEdit> <AllowHide>true</AllowHide> <IsVisible>true</IsVisible> <HelpMode>Modeless</HelpMode> <Dir>Default</Dir> <MissingAssembly>Cannot import this Web Part.</MissingAssembly> <PartImageLarge>/_layouts/images/mscontl.gif</PartImageLarge> <Assembly>Microsoft.SharePoint, Version=12.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c</Assembly> <TypeName>Microsoft.SharePoint.WebPartPages.ContentEditorWebPart</TypeName> <ContentLink xmlns="http://schemas.microsoft.com/WebPart/v2/ContentEditor" /> <Content xmlns="http://schemas.microsoft.com/WebPart/v2/ContentEditor">

<FONT size=5>Bienvenue sur ce site personnalisé</FONT> </Content>

<PartStorage xmlns="http://schemas.microsoft.com/WebPart/v2/ContentEditor" />



</WebPart>

Les 2 manifestes sont similaires, nous avons juste modifié leur propriétés de titre et de contenu html afin d’avoir un message simple et un message en italique.

Notre démonstration est finie, lorsque vous exécutez cet Action via la Feature vous obtenez au final :

1. Une nouvelle liste avec 2 nouvelles Pages à WebParts

2. 2 contenus de pages différentso Message en italique

o Message normal

Ce dernier scénario met bien en valeur les possibilités de génération combiné au modèle composant des Features. Vous pouvez packagez simplement en XML, la création dynamique de contenu dans SharePoint et les activer au besoin dans le cycle de vie de vos sites SharePoint

Pour rappel, ce scenario est extrêmement proche de la méthode utilisée pour le déploiement de Layouts dans le moteur de publication WCM : Feature, Aspx, Content Type et Module.



3.5.5 Tester et évaluer

Votre Feature et ses divers composants sont finis, vous pouvez les déployez via les batchs précisés au chapitre 3.4

Soit : Recopiez vos fichiers dans le 12 de votre serveur Inscrire votre Feature dans le moteur SharePoint (StsAdm –o installFeature, …) L’activer et valider depuis le navigateur

N’oubliez pas de créer toujours une collection de site vierge pour faire vos tests pour éviter tout effet collatéral. Voir même une nouvelle différentiation de votre machine virtuelle si vous travaillez sur un projet comprenant de multiples DLLS.

Et bon développement !

Note :



4 Pour aller plus loin…Ce tutoriel a eu pour vocation de vous évangéliser sur la création et la conception de Feature SharePoint. Seule l’approche déclarative du CAML a été vue afin de se focaliser surtout sur les notions de bases des Features.

Désormais, la création de Feature, le CAML font partie intégrante de votre boite à outil du développeur. Cependant, il faut bien comprendre que plus que tout, le système des Features est l’élément central du fonctionnement de SharePoint 2007.

Il y a très peu de cas ou quelque soit le développement que vous devez réalisez pour une plateforme SharePoint, vous ne pouviez le faire autrement que via une Feature. Pour rappel, dites vous bien que l’ensemble des fonctionnalités de MOSS sont déployé à partir de 3-4 Features majeures enchainant un large nombre de micro Feature fonctionnelles ; que ce soit des listes, des pages, des modèles ou des workflows.

Il faut donc bien pondérer la notion de Feature dans vos projets SharePoint en ce qui concerne : Leur nombre Leur réutilisation Le regroupement ou les dépendances La définition des lots et leur interaction

Ces taches spécifiques seront les facteurs premiers de réussite de vos projets, il ne faut surtout pas les minorer. En ce qui concerne le CAML, bien qu’il soit un schéma XML assez spartiate, il reste très efficace en termes de génération. En quelques lignes de XML, vous pouvez définir bien des comportements et des personnalisations de la plateforme SharePoint. Tout en assurant son déploiement sur un large volume de site via le Stapling et les modèles de site.

Les exemples utilisés dans ce tutoriel ne couvrent qu’une partie de la richesse du CAML. N’hésitez pas à explorer le MSDN pour la découvrir comme, par exemple, dans :

La définition de modèle de liste La définition de modèle de colonnes (fields) La définition de Type de contenu L’injection de contrôle via les Delegate

http://msdn.microsoft.com/en-us/library/ms463169.aspx Mixer les diverses options …

Le dernier point à noter reste aussi le cycle de vie unique des Features dans le monde SharePoint. C’est lui qui, via les modes d’installation/activation/désactivation/désinstallation, valide définitivement l’approche composant et la modularité de la plateforme.

Mais ce chapitre ne clôt pas encore le sujet des Features. Si elles exploitent le CAML par défaut, il est tout à fait possible de leur rattacher les API SharePoint via ses propres événements ; et donc allé plus loin que les restrictions du schéma CAML




5 Rendez-vous dans le prochain atelier…Dans l’atelier 4, « créer votre Feature avec code behind pour SharePoint », vous allez mettre en place une solution complète sous Visual Studio d’une Feature SharePoint mais utilisant des événements avec du vrai code. Vous découvrirez un autre axe fondamental d’extensibilité. Ce prochain tutoriel tachera de vous le présenter tout en introduisant les premières notions d’API et d’utilisation du code métier.

Lexique

Truc et astuce

Zoom sur la technique

Définition d’un concept avancé

Référence MSDN

Attention sécurité