office

[Skydrive Pro]–Sortie du client standalone pour Windows !

Posted on Updated on

 

Bonjour à tous.

Le travail en mobilité est devenu un vrai besoin à l’heure actuelle. A l’époque de SharePoint 2010 (pas encore révolu Sourire ), nous avions le client SharePoint Workspace 2010 qui permettait d’emporter ses documents en synchronisant le client avec SharePoint 2010.

Avec l’avènement de SharePoint 2013, Microsoft nous proposait le client Skydrive Pro… mais seulement avec le pack Office 2013 (et Office 365 Pro Plus ou Office 365 Small Business Premium). Il était impossible de se procurer ce client séparément ! Ce qui compliquait légèrement ce travail itinérant…

C’est maintenant chose faite, il est possible de le télécharger gratuitement ! par ici : http://www.microsoft.com/en-US/download/details.aspx?id=39050.

Il vous suffira de l’installer sur chacun des postes clients concernés et de lancer la synchronisation depuis le bouton “Sync” dans SharePoint 2013 :

image

 

Le client se lancera alors et vous demandera d’indiquer où il devra effectuer la synchronisation (répertoire local de la machine cliente) :

image

 

Le répertoire local sera alors synchronisé avec SharePoint 2013 dès que celui-ci sera accessible via le réseau :

image

 

Bonne installation !

Advertisements

[VSTO]–Mon premier VSTO pour Outlook 2013

Posted on Updated on

Bonjour à tous.

Aujourd’hui un petit article qui sort des traditionnels posts autour de SharePoint, avec au programme un VSTO pour Outlook (2013 dans mon cas), Visual Studio 2012 et les modèles de projets pour Office 2013.

Mon cas est simple, il faut que j’ajoute aux catégories proposées en standard par Outlook des catégories personnalisées pour colorer les Rendez-vous du calendrier suivant le type :

  • Absences (RTT, congés) : Rouge
  • Production : Orange
  • Formation : Mauve
  • Avant-Vente : Vert
  • Intercontrat (Le moins possible !!!) : Jaune

Je ne vais pas personnaliser le ruban dans cet exemple… peut être plus tard !

1/ La plateforme de développement

Dans le but de rentrer le plus vite dans le vif du sujet, ma plateforme de développement se compose de ma machine de travail quotidienne :

  • Windows 8 Enterprise x64 en anglais
  • Office Professional Plus 2013 x86 en anglais
  • Visual Studio 2012 Ultimate en anglais

Pour pouvoir développer avec les modèles de projet Office 2013, la première chose à faire est de télécharger les extensions pour Visual Studio 2012 que vous trouverez ici : http://msdn.microsoft.com/en-us/office/apps/fp123627.aspx

01

Une fois l’exécutable téléchargé, lancez le. Il s’agit d’un WebInstaller de Microsoft qui téléchargera le nécessaire et l’installera sur votre poste. Attendez la fin de l’installation.

2/ Création du projet Visual Studio

Vous pourrez ensuite lancer Visual Studio 2012 :

02

Créez un nouveau projet en faisant : File > New > Project. L’assistant de création d’un projet se lance. Dans les modèles de projet, vous devriez trouver (dans la section C# dans mon cas) la section Office/SharePoint, puis Office Add-ins. Dans cette section vous trouverez tous les modèles pour Office 2013 : Word, Excel, PowerPoint et autres… :

03

On choisit ici “Outlook 2013 Add-In”, on nomme le projet (Demo.Outlook.Addin) et on le place dans le bon répertoire. Puis on clique sur OK.

Le projet est créé dans l’explorateur de solution :

04

Le projet se compose pour le moment d’un élément (une classe) ThisAddin avec deux évènements : ThisAddIn_Startup et ThisAddIn_Shutdown. Ces deux évènements sont appelés au chargement de l’Add-in (lancement d’Outlook ou activation de l’Add-in via le gestionnaire) ou au déchargement (fermeture d’Outlook ou désactivation de l’Add-In).

05

3 / Le code

Dans mon cas c’est plutôt simple. Pour ajouter des éléments dans les catégories existantes, je vais m’appuyer sur le modèle objet (Interop) d’Outlook pour ajouter dans la collection des catégories de nouveau éléments.

Pour cela, nous allons recourir au namespace : Microsoft.Office.Interop.Outlook en utilisant la classe Categories. Cette classe possède une méthode Add() prenant en paramètres :

  • Un nom : string
  • Une couleur : Microsoft.Office.Interop.Outlook.OlCategoryColor [Option]
  • Un raccourci clavier : Microsoft.Office.Interop.Outlook.OlCategoryShortcutKey [Option]

Ce qui donne :

Application.Session.Categories.Add(“Absences”, Microsoft.Office.Interop.Outlook.OlCategoryColor.olCategoryColorRed, Microsoft.Office.Interop.Outlook.OlCategoryShortcutKey.olCategoryShortcutKeyCtrlF2);

Nous allons répéter cela pour toutes les catégories à ajouter :

06

Dans le souci de ne pas ajouter ces catégories à chaque activation de l’Add-In, j’ai ajouter une méthode CategoryExists() qui retourne True si la catégorie existe, False sinon :

private bool CategoryExists(string categoryName)
{
foreach (Microsoft.Office.Interop.Outlook.Category item in Application.Session.Categories)
{
if (item.Name == categoryName)
return true;
}
return false;
}

On vérifie pour cela que le nom n’apparaisse pas déjà dans les catégories existantes (on aurait pu vérifier la couleur, le raccourci etc.)

07

Le code étant ok, nous allons passer au debug.

3/ Debug

Pour tester, rien de plus simple ! On ferme toutes les instances d’Outlook ouvertes sur le poste de travail, et on utilise la touche F5 pour démarrer le débug. Visual Studio déploie le projet, lance Outlook… Et on a plus qu’à vérifier que tout fonctionne :

08

Nikel… Mais il manque quand même quelque chose… un projet pour déployer tout ça sur le poste des collègues !

4/ Projet de déploiement

Pour créer un projet de déploiement, avec Visual Studio 2012 vous pouvez utiliser InstallShield etc.

Mais dans mon cas, je voulais tester WIX depuis un moment… Vous pourrez télécharger le modèle de projet ici : http://wixtoolset.org/

WIX Toolset permet de créer des setup d’installation paramétrables et personnalisables à partir de fichiers XML. Il faut donc télécharger puis installer les modèles de projet et accessoirement redémarrer Visual Studio 2012.

Après avoir redémarré Visual Studio, nous allons commencer par réouvrir la solution VSTO. Puis nous allons faire un clic droit sur la solution, Add > New Project… :

09

Dans l’arborescence des modèles de projet disponibles, un nouveau regroupement est disponible : “Windows Installer XML”. Dans ce regroupement on sélectionnera “Setup Project” et bien sûr on nommera le projet (ici Demo.Outlook.Addin.Setup) et on clique sur OK :

10

Le nouveau projet est créé, il est composé principalement d’un fichier “Product.wxs” qui est en fait un fichier XML :

11

Ce fichier va décrire tout le processus de déploiement du VSTO sur les machines clientes. Nous allons parcourir le schéma pour ajouter les nœuds utiles. Je suis parti sur la base de cet article : http://www.add-in-express.com/creating-addins-blog/2012/11/13/wix-installation-vsto-office-addin/ pour décrire le processus de déploiement.

Première ligne, Product. Nous allons ici déclarer les attributs du produit à déployer. J’ai choisi de générer un GUID grâce à l’outil intégré à Visual Studio (Create GUID Tool) et de replacer l’attribut “Id”. Ensuite j’ai remplacé l’attribut Name avec le nom de mon VSTO, la langue par 1036 (Français, 1033 == Anglais) et le “Manufacturer” par Neos-SDI dans mon cas :

<Product Id=”E7F42E5E-7474-4E27-909B-D1E4A8A1B028″ Name=”Demo.Outlook.Addin” Language=”1036″ Version=”1.0.0.0″ Manufacturer=”Neos-SDI” UpgradeCode=”3786b23e-f5d5-4119-b0ef-0680416f6fae”>

Puis j’ai remplacé le MajorUpgrade par (en Français) :

<MajorUpgrade DowngradeErrorMessage=”Une version plus récente de [ProductName] est déjà installée.” />

NB : Toutes les sections suivantes seront ajoutées dans <Product>[…]</Product>

Ensuite, j’ai ajouté un “Property” & un “Condition” pour vérifier à l’installation si la bonne version des VSTO (Runtime version 4 pour Office 2013) est disponible sur la machine cliente (Recherche dans la base de registre de la machine). Pour cela on utilise :

<Property Id=”VSTORUNTIMEREDIST”>
<RegistrySearch
Id=”VSTORuntimeRedist”
Root=”HKLM”
Key=”SOFTWARE\Microsoft\VSTO Runtime Setup\v4R”
Name=”Version”
Type=”raw” />
</Property>

<Condition Message=”The Visual Studio 2010 Tools for Office Runtime is not installed. Please download and install from http://www.microsoft.com/en-us/download/details.aspx?id=20479.”>
<![CDATA[Installed OR VSTORUNTIMEREDIST>=”10.0.30319″]]>
</Condition>

Cela affichera un message d’erreur si la version du Runtime n’est pas la bonne, proposant de la télécharger grâce au lien http fourni.

Nous allons également vérifier que le Framework 4.0 est bien installé sur la machine cliente. Pour cela, on utilise une “PropertyRef” et une “Condition” :

<PropertyRef Id=”NETFRAMEWORK40FULL”/>
<Condition Message=”This application requires .NET Framework 4.0.”>
<![CDATA[Installed OR NETFRAMEWORK40FULL]]>
</Condition>

Nous allons maintenant nous occuper des composants à déployer. Pour cela nous allons utiliser des “<Component>”, “<ComponentGroup>” et des “<Feature>”.

En dehors de la balise <Product> nous allons déclarer les composants à déployer puis les références avec une <Feature> dans <Product>.

Les fichiers à déployer sont situés dans le répertoire de sortie (output) du projet Visual Studio, dans mon cas Demo.Outlook.Addin/bin/debug :

12

Commençons par créer les ComponentGroup nécessaires. Il faut référencer les output produits par la compilation du projet VSTO par Visual Studio. Pour cela, il faut utiliser (après </Product>) :

<Fragment>
<ComponentGroup Id=”ProductComponents” Directory=”INSTALLFOLDER”>
<Component Id=”OutlookAddin1_vsto_Component”>
<File Id=”OutlookAddin1_vsto” KeyPath=”yes” Name=”Demo.Outlook.Addin.vsto” Source=”$(var.AddinFiles)” />
</Component>

<Component Id=”OutlookAddin1_dll_manifest_Component”>
<File Id=”OutlookAddin1_dll_manifest” KeyPath=”yes” Name=”Demo.Outlook.Addin.dll.manifest” Source=”$(var.AddinFiles)” />
</Component>

<Component Id=”MSOfficeToolsCommon_dll_Component”>
<File Id=”MSOfficeToolsCommon_dll” KeyPath=”yes” Name=”Microsoft.Office.Tools.Common.v4.0.Utilities.dll” Source=”$(var.AddinFiles)” />
</Component>
<Component Id=”MSOfficeToolsOutlook_dll_Component”>
<File Id=”MSOfficeToolsOutlook_dll” KeyPath=”yes” Name=”Microsoft.Office.Tools.Outlook.v4.0.Utilities.dll” Source=”$(var.AddinFiles)” />
</Component>
<Component Id=”OutlookAddIn1_dll_Component” >
<File Id=”OutlookAddIn1_dll” KeyPath=”yes” Name=”Demo.Outlook.Addin.dll” Source=”$(var.AddinFiles)” />
</Component>
</ComponentGroup>
</Fragment>

Nous référençons ici le fichier *.vsto produit avec (Demo.Outlook.Addin.vsto) :

<Component Id=”OutlookAddin1_vsto_Component”>
<File Id=”OutlookAddin1_vsto” KeyPath=”yes”      Name=”Demo.Outlook.Addin.vsto” Source=”$(var.AddinFiles)” />
</Component>

Puis le manifest produit (Demo.Outlook.Addin.dll.manifest) :

<Component Id=”OutlookAddin1_dll_manifest_Component”>
<File Id=”OutlookAddin1_dll_manifest” KeyPath=”yes” Name=”Demo.Outlook.Addin.dll.manifest” Source=”$(var.AddinFiles)” />
</Component>

Puis les DLL pour les VSTO (Common + Outlook) :

  • Microsoft.Office.Tools.Common.v4.0.Utilities.dll
  • Microsoft.Office.Tools.Outlook.v4.0.Utilities.dll

<Component Id=”MSOfficeToolsCommon_dll_Component”>
<File Id=”MSOfficeToolsCommon_dll” KeyPath=”yes” Name=”Microsoft.Office.Tools.Common.v4.0.Utilities.dll” Source=”$(var.AddinFiles)” />
</Component>
<Component Id=”MSOfficeToolsOutlook_dll_Component”>
<File Id=”MSOfficeToolsOutlook_dll” KeyPath=”yes” Name=”Microsoft.Office.Tools.Outlook.v4.0.Utilities.dll” Source=”$(var.AddinFiles)” />
</Component>

Et enfin la DLL du projet (Demo.Outlook.Addin.dll) :

<Component Id=”OutlookAddIn1_dll_Component” >
<File Id=”OutlookAddIn1_dll” KeyPath=”yes” Name=”Demo.Outlook.Addin.dll” Source=”$(var.AddinFiles)” />
</Component>

Pour que WIX prenne en compte ces demandes d’installation des vsto, dll et autres manifests, il faut lui indiquer dans la balise <Product></Product> qu’il doit prendre en compte ces Components. Pour cela on ajoute une balise Feature dans <Product></Product> :

<Feature Id=”ProductFeature” Title=”Demo.Outlook.Addin.Setup” Level=”1″>
<ComponentGroupRef Id=”ProductComponents” />
</Feature>

Il se peut que la balise apparaisse déjà et soit déjà ok…

Il faut maintenant indiquer à WIX que lorsque le produit sera installé, il apparaitra dans le menu Ajout/Suppression de Programmes en ajoutant des clés de registre. Pour cela on utilise à nouveau des Components de la manière suivante :

<Fragment>
<Directory Id=”TARGETDIR” Name=”SourceDir”>
<Directory Id=”ProgramFilesFolder”>
<Directory Id=”NeosFolder” Name=”Neos”>
<Directory Id=”INSTALLFOLDER” Name=”Planning Outlook Add-in” />
<Component Id=”Registry_FriendlyName”>
<RegistryValue Id=”RegKey_FriendlyName” Root=”HKCU” Key=”Software\Microsoft\Office\Outlook\AddIns\Demo.Outlook.Addin” Name=”FriendlyName” Value=”Demo.Outlook.Addin Add-in for Outlook” Type=”string” KeyPath=”yes” />
</Component>
<Component Id=”Registry_Description”>
<RegistryValue Id=”RegKey_Description” Root=”HKCU” Key=”Software\Microsoft\Office\Outlook\AddIns\Demo.Outlook.Addin” Name=”Description” Value=”Demo.Outlook.Addin Add-in for Outlook to manage Categories in Calendars and Inbox.” Type=”string” KeyPath=”yes” />
</Component>
<Component Id=”Registry_Manifest”>
<RegistryValue Id=”RegKey_Manifest” Root=”HKCU” Key=”Software\Microsoft\Office\Outlook\AddIns\Demo.Outlook.Addin” Name=”Manifest” Value=”[INSTALLFOLDER]Demo.Outlook.Addin.vsto|vstolocal” Type=”string” KeyPath=”yes” />
</Component>
<Component Id=”Registry_LoadBehavior”>
<RegistryValue Id=”RegKey_LoadBehavior” Root=”HKCU” Key=”Software\Microsoft\Office\Outlook\AddIns\Demo.Outlook.Addin” Name=”LoadBehavior” Value=”3″ Type=”integer” KeyPath=”yes” />
</Component>
</Directory>
</Directory>
</Directory>
</Fragment>

On indique ici le répertoire d’installation par défaut du projet. Ici ce sera dans C:\Program Files (x86)\Neos\Planning Outlook Add-in. On y placera l’intégralité des composants à déployer et on créera 4 clés de registre dans HKEY_CURRENT_USER\Software\Microsoft\Office\Outlook\AddIns\Demo :

  • FriendlyName = Demo.Outlook.Addin Add-in for Outlook
  • Description = Demo.Outlook.Addin Add-in for Outlook to manage Categories in Calendars and Inbox.
  • Manifest = =[INSTALLFOLDER]Demo.Outlook.Addin.vsto|vstolocal
  • LoadBehavior = 3

Il faut ensuite référencer ces components dans la <Feature> utilisée précédemment, ce qui donne :

<Feature Id=”ProductFeature” Title=”Neos.Planning Add-in for Outlook” Level=”1″>
<ComponentGroupRef Id=”ProductComponents” />
<ComponentRef Id=”Registry_FriendlyName” />
<ComponentRef Id=”Registry_Description” />
<ComponentRef Id=”Registry_Manifest” />
<ComponentRef Id=”Registry_LoadBehavior” />
</Feature>

Dernière étape, ajouter des composants utiles à WIX pour le manifest de licence produit (EULA.rtf) et à préciser le type d’interface à utiliser :

<UIRef Id=”WixUI_Minimal” />
<WixVariable Id=”WixUILicenseRtf” Value=”EULA.rtf” />

Ce fichier EULA.rtf doit être ajouté à la solution (WIX en fournit un de base sur leur site) :

13

Si vous compilez dès à présent. Vous obtiendrez une erreur :

Undefined preprocessor variable ‘$(var.AddinFiles)’.

14

C’est tout à fait normal ! En effet, dans les déclaration des chemins vers les fichiers, nous avons utilisé cette directive “$(var.AddinFiles)” sans la déclarer. Pour cela, il faut se rendre dans les propriétés du projet WIX :

15

Dans la section “Build” nous allons déclarer une “preprocessor variable” (il vous faudra modifier le nom du projet en gras ici) :

  • AddinFiles=..\Demo.Outlook.Addin\bin\$(Configuration)\

16

On sauvegarde et on compile la solution.

De nouvelles erreurs apparaissent :

17

Rien de grave ici non plus, il manque seulement des références à des DLL utiles à la compilation. Nous allons faire un clic droit sur le répertoire References du projet WIX, puis “Add Reference” :

18

Une fenêtre d’ajout de références (pas celle de Visual Studio mais celle de WIX) apparait. On ajoute 2 références :

  • WixNetFxExtension.dll
  • WixUIExtension.dll

19

Et on recompile à nouveau ! Tout se passe bien :

20

5/ Tests

Il reste maintenant à tester le setup et que le projet fonctionne. Pour cela, rendez vous dans le répertoire de sortie du projet d’installation :

21

Lancer le .msi :

22

Le contenu apparaissant dans cette fenêtre est en fait le contenu du fichier EULA.rtf… On accepte les termes et on clique sur “Install”…

Puis on lance Outlook, les nouvelles catégories apparaissent !

23

Voila, le post s’achève… un merci tout particulier à Benoit Laut pour ses conseils et son aide ! A bientôt !

Télécharger le source : ici.

Convertir un document Office docx en page html grâce à SharePoint–Partie 2

Posted on Updated on

 

Rappels… et objectifs

 

Dans l’article précédent Partie 1, nous avons comment paramétrer simplement le service de conversion de documents au travers de la console d’administration SharePoint.

Nous avons également vu comment activer ce service dans une application Web choisie et même comment choisir les types de conversions disponibles dans celle-ci.

J’ai décidé d’écrire une suite d’articles reprenant le concept de conversion de documents et de l’intégrer au sein d’un développement réalisé pour MOSS 2007. Ce développement permettra d’utiliser la conversion de documents à partir d’une définition de bibliothèque de documents personnalisée et cette conversion produira des pages HTML automatiquement à partir de documents Office 2007/2010.

Nous allons donc voir comment créer une définition de bibliothèque de documents avec ses types de contenus associés, des colonnes de site et packager le tout dans cette partie.

La prochaine partie se concentrera sur une custom action permettant d’appeler une page “d’administration” personnalisée par nos soins. Cette page nous permettra, à terme, de renseigner certaines métadonnées ou des informations utiles, de vérifier que des conditions sont remplies, etc., avant de lancer la conversion.

Il sera également possible de lancer un workflow manuellement (par code),  de rediriger l’utilisateur vers une page souhaitée et il faudra aussi penser à gérer les cas d’erreur.

Nous penserons bien sûr à packager le tout dans une solution WSP grâce à Visual Studio 2008 et WSPBuilder que vous pouvez télécharger ici : WSPBuilder sur CodePlex.

 

Premières tentatives et échecs…

 

Le but de ce développement est d’intégrer la conversion d’un document Word en html à une page d’administration personnalisée appelée par une custom action. Bien sûr d’autres traitements seront réalisés dans le contexte de cette tâche… sinon on aurait pu utiliser la fonctionnalité standard proposée par SharePoint.

Donc première étape, vérifier la faisabilité de cette conversion par code.

Je me lance donc dans les premières recherches sur le net concernant le job de conversion… je trouve un article sur un blog (ici) que l’on peut interroger depuis du code .Net. Je me précipite donc avant de me rendre compte au bout de quelques minutes que cet article ne concerne que SharePoint Server 2010… et que je travaille sur MOSS 2007.

Du coup cela devient plus compliqué, pas d’API pour accéder au job permettant de lancer la conversion.

Idée suivante… analyser comment fonctionne la fonctionnalité standard, les pages utilisées. J’ouvre donc le fichier ConverterSettings.aspx situé dans 12/TEMPLATE/LAYOUTS/ avec Visual Studio et regarde l’héritage de la page.

On voit qu’elle hérite de :

Inherits="Microsoft.SharePoint.Publishing.Internal.CodeBehind.ConverterSettingsPage"

Classe VS 2008 - Conversion

 

Puis un petit coup de Reflector (ici) qui me permet d’analyser le code contenu dans les assemblies utilisées par ces pages. On charge donc l’assembly Microsoft.SharePoint.Publishing :

Reflector

 

La plupart des classes utilisées sont private ou internal… ça c’est une mauvaise nouvelle, impossible d’appeler ces classes directement… à moins de faire de la réflexion en .Net.

Cette solution ne me satisfait pas, il y a forcément plus simple !

Après quelques recherches, je me suis aperçu que sur un site de publication SharePoint, il existe une méthode Add() que l’on peut appeler sur la classe PublicationPages et qui permet de passer :

        • Un document docx ou xlsx, etc.
        • Un Guid “Transformer Guid”
        • Une priorité (low, normal et High).

        Reflector - PublishingPages

Je me suis donc penché sur cette méthode afin de parvenir à utiliser la conversion de documents par code. Première contrainte, utiliser un site de publication et la bibliothèque de pages “Pages” créée par défaut sur ce type de site. Deuxième contrainte, utiliser seulement des documents Office avec le modèle Open Document (donc à partir de Office 2007).

        Nous reviendrons à l’utilisation de cette analyse dans la partie 3 !

          Création de la définition de la bibliothèque et des types de contenu

          Création de la fonctionnalité (feature)

        Première chose, installer WSPBuilder si ce n’est déjà fait et lancer Visual Studio 2008.

        Créer un nouveau projet vide de type WSPBuilder
        Solution WSP 01
      Solution WSP 02

     

    Créer une fonctionnalité (feature) en ajoutant un élément sur le projet. Je choisis Site pour le Scope car je vais avoir des colonnes de sites et un type de contenu.

    Solution WSP 03

    Solution WSP 04

     

    Voici ce que WSPBuilder et Visual Studio vous ont créé :

    • Des répertoires : 12/TEMPLATE/FEATURES qui ciblent les répertoires d’installation de SharePoint 2007, appelés Hive ou Niche SharePoint.
    • Un répertoire ExempleConversion qui contiendra la fonctionnalité que nous allons créer
    • Deux fichiers XML
      • feature.xml : décrit le processus général du déploiement, c’est le point d’entrée pour SharePoint.
      • elements.xml : va décrire d’autres éléments à déployer
      • Vous pouvez en ajouter autant que vous voulez, comme nous allons le voir.

      Solution WSP 05

        Création d’un modèle de bibliothèque de documents personnalisé

        Pour commencer, je préfère intégrer une définition de bibliothèque de documents personnalisée à ma solution car cela me permet de déployer automatiquement toutes les briques nécessaires à cet exemple.
        Cette définition, lorsqu’elle sera déployée sera disponible dans la galerie des modèles de listes disponibles (lors de la création d’une nouvelle liste/bibliothèque) dès que la fonctionnalité sera activée.
        Pour se faire, j’ai juste créé une nouvelle bibliothèque de documents dans SharePoint, personnalisé les colonnes, types de contenus, vues puis utilisé un outil fourni dans les VSeWSS à savoir SharePoint Solution Generator (attention cela fonctionne très mal en 64bits…).
        Première étape, créé une collection de sites de type publication. Dans la “Console d’administration de SharePoint”, aller dans “Gestion des applications”, dans la section “Gestion des sites SharePoint”, “Créer une collection de sites

      Créer une collection de sites 01

       

      Renseignez les paramètres puis créez la collection de sites de type “Portail de publication

      Créer une collection de sites 02

       

      Créer une collection de sites 03

       

      En affichant tout le contenu du site, on remarque que la bibliothèque de pages a bien été créée :

      Contenu du site

       

      On va maintenant créer la bibliothèque de document personnalisée. Cliquez sur “Créer”.

      Dans la page de choix du type de liste/bibliothèque, choisissez “Bibliothèque de documents” et remplissez les champs. Vous pouvez choisir le type “”Document Microsoft Office Word” comme modèle de documents. Cliquez sur “Créer”.

      Création bibliothèque de documents

      La bibliothèque de documents est crée. Maintenant il faut la personnaliser en ajoutant les colonnes, vues, types de contenu, etc.

      Pour ma part, je vais créer un type de contenu avec un modèle de document Word “.dotx” et des colonnes tout en créant un package wsp.

      On créé donc le type de contenu en cliquant sur “Actions du site”, “Paramètres du site”, “Modifier tous les paramètres du site”. Dans la section “Galeries” sélectionnez “Types de contenu de site”. Dans la nouvelle page chargée, cliquez sur “Créer”.

      Création du type de contenu 01

       

      Nous allons en fait créer plusieurs types de contenu. Le but étant que l’on puisse créer rapidement de nouveaux types de contenu avec des modèles de documents associés différents.

      Donc le premier héritera du type de contenu “Document” et contiendra les colonnes de site communes à tous les types de contenu que je souhaite créer.

      Les autres hériteront de ce nouveau type de contenu et possèderont chacun leur modèle de document “dotx”. Ainsi je n’aurai pas à créer à chaque fois les colonnes de site communes à tous les type de contenu.

      Pour le type de contenu parent, renseignez les champs de cette manière et validez avec “OK”. On créé un type de contenu héritant de document et on le place dans un nouveau groupe “Exemple”.

      Création du type de contenu 02

      On personnalise ce content type en ajoutant les colonnes de site.

       

      Puis on créé un type de contenu par modèle de document en héritant de ce dernier. Voici un exemple :

      Création du type de contenu 03

       

      On ajoutera ensuite les colonnes de site supplémentaires et surtout le modèle de document adéquat dans les paramètres avancés de ce nouveau type de contenu.

      On créé donc un document Word 2010 dans mon cas, bien sûr au format dotx, basique. On pourra éventuellement utiliser les QuickParts afin de lier les colonnes du type de contenu  au document word, et donc les utiliser dans ce document en tant que métadonnées.

      Nouveau modele dotx

       

      Puis dans la page de “Paramètres avancés” du type de contenu, cliquez sur “Télécharger”, le document et validez la page.

      Ajout document au type de contenu

       

      Retournez sur les “Paramètres avancés”, le document est bien téléchargé. Cliquez sur le lien “Modifier le modèle”, Word se lance et vous permet de ré-éditer le modèle de document, comme par exemple pour lier des colonnes de sites de ce type de contenu au document par le biais de “QuickParts”.

      Edition modèle de document 01

       

      Mais où est donc téléchargé ce modèle de document ? A l’aide de SharePoint Designer 2007, vous pouvez voir que ce document est placé dans le répertoire “_cts” du site :

      SPDesigner Modele de document 

      C’est important car lors du packaging, nous allons déployer ce modèle de document au même endroit.

      Vous pouvez donc créer autant de types de contenu que souhaité en reproduisant ces manipulations.

      Il ne nous reste plus qu’à associer ce type de contenu à la bibliothèque de documents créée précédemment. On retourne sur la page où est affichée cette bibliothèque et on clique sur “Paramètres”, “Paramètres – bibliothèque de documents”.

      Ajout type de contenu 01

      Dans cette page, on clique sur “Paramètres avancés”

      Ajout type de contenu 02

      On autorise la gestion des types de contenu et on peut également interdire la création de dossiers, on valide la page.

      Ajout type de contenu 03

      Une nouvelle section apparait dans la page de paramétrage de la bibliothèque de documents

      Ajout type de contenu 04

       

      Dans cette section, cliquez sur “Ajouter à partir de types de contenu de site existants” et ajoutez le type de contenu que nous venons de créer et validez.

      Ajout type de contenu 05

       

      Vous pouvez également désactiver le type de contenu “Document” en cliquant sur le lien et en le supprimant (il ne sera que désassocié de cette bibliothèque, pas supprimé totalement bien entendu).

      En revenant sur la page d’affichage de la liste (page AllItems.aspx), en cliquant sur la flèche à coté de “Nouveau”, vous pouvez voir que le nouveau type de contenu est disponible, et en cliquant dessus, Word se lance avec le bon modèle de document

      Ajout type de contenu 06

       

      On ajoutera quelques documents pour les tests dans les parties suivantes.

       

      Création de la définition de bibliothèque de documents

       

      Afin d’arriver à déployer ma solution, je créé donc un package wsp. Il va déployer la définition de cette bibliothèque de documents sur les sites SharePoint quand la fonctionnalité sera activée.

      Pour créé cette définition, nous allons utiliser SharePoint Solution Generator, fourni par les VSeWSS. Attention, ils fonctionnent très bien en 32bits mais pas en 64 !!! Par ici.

      On choisi “List Definition”, “Next”.

      Solution Generator 01

      On entre l’url de notre bibliothèque et “Next”

      Solution Generator 02

       

      En on choisi notre bibliothèque et “Next”

      Solution Generator 03

       

      “Next”

      Solution Generator 04

       

      “Finish”

      Solution Generator 05

       

      La définition est générée, cliquez sur le lien en bas pour ouvrir le répertoire où la solution Visual Studio a été générée.

      Solution Generator 06

       

       

      Dans cette solution :

      • Un répertoire “Properties”
      • Un répertoire “Source Conversion” qui contient la définition et les fichiers nécessaires
      • Un fichier “csproj” pour ouvrir la solution dans Visual Studio
      • Un fichier de log de l’a création de la définition

      Solution Generator 07

       

      Copier le répertoire “Source Conversion” et allez le placer dans la solution créé dans Visual Studio, dans le répertoire de la “feature”.

      Solution Generator 08

       

      Allez dans Visual Studio, cliquez sur les deux icones en haut : “Show all files” puis “Refresh”

      Solution Generator 09

       

      Puis clic droit sur le dossier apparu et “Include In Project” (inclure dans le projet) :

      Solution Generator 10

      Le dossier et les fichiers contenus sont ajouté à la solution Visual Studio :

      Solution Generator 11

       

      Nous devons maintenant faire le nécessaire afin que ces fichiers soient déployés lors de l’activation de la fonctionnalité. En fait, les fichiers seront déployés sur le système de fichiers, dans le répertoire 12 de SharePoint (WSPBuilder copie par défaut les fichiers contenus dans ce répertoire 12 visible dans Visual Studio dans le répertoire 12 de SharePoint). Par contre ils ne sont pas encore référencés dans la fonctionnalité, nous allons le faire dès à présent.

      Ouvrez le fichier “feature.xml” dans Visual Studio. Modifiez les paramètres souhaités (voir SDK de SharePoint), ce qui est important :

      • Scope=”Site” car nous allons déployer des colonnes de sites et un type de contenu qui se déploient au niveau “Site”
      • Id : doit être unique, vous pouvez utiliser l’outil “Create GUID” de Visual studio (ici)
      • Hidden=”FALSE” pour que la fonctionnalité soit visible dans la page d’activation des fonctionnalités de la collection de sites
      • On ajoute la ligne <ElementManifest Location="ListTemplates.xml"/> pour séparer les déclarations de définitions de liste dans un fichier à part.
        On sauvegarde.

      Feature 01

       

      Puis dans le même répertoire que ce fichier “feature.xml”, on ajoute un autre fichier de type xml, nommé “ListTemplates.xml” qui vient d’être référencé dans le fichier précédent. On ouvre ce fichier.

      Feature 02

      On ouvre également le fichier “ListDefinition.xml” contenu dans le répertoire “Source Conversion” et on copie son contenu dans le fichier “ListTemplates.xml”. On aurait pu également déplacer ce fichier dans le bon répertoire et le renommer, mais je préfère le garder en référence le temps d’éditer le deuxième. Je supprimerai ce fichier en fin de manipulation.

      Gardez seulement ouvert le fichier “ListTemplates.xml”. Observez sa structure, il contient 3 lignes, 2 balises “Elements” et 1 balise “ListTemplate” qui est celle qui nous interesse.

      Nous allons modifier principalement 2 choses :

      • Type : créer votre propre identifiant de modèle de liste, pour ma part ce sera 1001
      • DocumentTemplate : 121 soit le modèle Word 2007/2010

      Feature 03

      Feature 04

      Sauvegardez, puis ouvrez le fichier “schema.xml” content dans le répertoire “Source Conversion” et modifiez l’attribut “Type” de la balise “List” en début de fichier "(2ème ligne) et mettez le même nombre que la balise “Type” dans le fichier “ListTemplates.xml”, soit 1001 et sauvegardez.

      Feature 05

      Vous pouvez maintenant supprimer le fichier “ListDefinition.xml” et également le fichier “template.dotx”, ajoutez à la place votre fichier “dotx” créé en début d’article (n’oubliez pas de les inclure dans la solution depuis l’arbre de projet).

      Feature 06

      Pour référencer ce modèle de document, nous allons devoir packager les types de contenu et changer les références vers ce fichier. C’est ce que nous allons voir dans la section suivante.

       

       

      Création de la définition de type de contenu

       

      Nous allons maintenant packager nos types de contenu dans la solution pour qu’ils soient déployés en même temps. Ce package embarquera également les colonnes de site utilisées par ces types de contenu et le modèle de document Office.

      Cette création du package reprend le principe précédent dans Visual Studio, mais j’utiliserai un outil afin d’extraire la définition de ces types de contenu : MOSS Content Types Viewer.

      Première étape, ajouter un fichier “ContentTypes.xml” dans Visual Studio, tout comme on l’a fait pour “ListTemplates”. Pensez à éditer le fichier “feature.xml” afin de référencer ce dernier fichier dans la fonctionnalité.

      Feature 07

      Feature 08

       

      Lancez le fameux outil MOSS Content Types Viewer et connectez le au site où l’on a créé les types de contenu puis recherchez les types de contenu voulus. Pour ma part, je veux récupérer le type de contenu parent et un enfant : Demande et Demande de réservation.

       

      Commençons par le type de contenu parent : Demande.

      Cliquez sur “Show Fields” puis sur le bouton en bas “Copy to Clipboard”.  Puis allez coller tout ça dans le fichier “ContentTypes.xml” en conservant les balises “Element”.

      Feature 09

       Feature 10

      Puis revenez dans l’outil d’extraction du type de contenu, et cliquez sur “Show Fields Refs” et copiez le contenu (sans la balise “Element”)

      Feature 11

       

      Et collez le contenu après les éléments collés précédemment (pensez à ajouter un tag fermant </ContentType>, l’outil l’oubli lors de l’extraction). Voici le résultat :

      Feature 12

      Faites de même avec le type de contenu fils : Demande de réservation. Attention, les balises <Fields> se répètent entre les deux types de contenu, pensez à supprimer les colonnes en double.

      Feature 13

       

      Il reste une toute dernière manipulation, référencer le modèle de document dans la définition du type de contenu et également dans la définition de la bibliothèque de documents ainsi que le déployer à l’aide d’un “Module”. Vous trouverez des informations utiles ici.

      Ouvrez le fichier “feature.xml” et ajoutez une ligne : <ElementFile Location="Source Conversion\Demande de reservation.dotx"/> dans les “ElementManifests” .

      Feature 14

       

      Puis ouvrez le fichier “ContentTypes.xml” et ajoutez le module comme suit : le fichier modèle de document Office sera déployé dans le répertoire _cts du site, dans un sous-répertoire portant le nom du type de contenu courant (nom interne).

      Feature 15

      Ouvrez donc le fichier “schema.xml” et localisez les tags XML “ContentTypes”. Vous trouverez dedans le content type que nous venons de créer. Supprimez les lignes le concernant et remplacez les par un ContentTypeRef pointant vers notre Type de Contenu tout en changeant le répertoire cible comme suit :

      Feature 16

      Voilà, tout est rassemblé dans le package wsp qui sera préparé par WSPBuilder dans Visual Studio. Pour cela, clic droit sur le projet, puis “WSP Builder” et enfin “Build WSP”

      Feature 17

      Puis même chose en cliquant sur “Deploy” et testez.

      Pour cela rendez vous dans la gallerie de fonctionnalités de la collection de sites. Il est possible que la fonctionnalité ne s’y trouve pas, elle n’a pas été installée par Visual Studio. Recourez à STSADM pour installer et déployer cette fonctionnalité avec stsadm –o installfeature et stsadm –o activatefeature (ici et ici).

      Une fois fait, activez la fonctionnalité et créez une bibliothèque de documents type “Source Conversion” et testez que vous pouvez ajouter des documents basés sur le modèle.

      Corrigez les éventuels problèmes que vous avez pu rencontrer en adaptant à vos besoins cette solution.

      Conclusion de cette partie

       

      Dans cette partie, nous avons vu comment utiliser Visual Studio 2008 et WSP Builder pour les développement autour de SharePoint 2007. Nous avons également utilisé des outils tiers, gratuits provenant la plupart du temps de Codeplex (vous y trouverez pléthore d’outils utiles…).

      Nous avons également vu comment créer une définition de bibliothèque de documents (s’adapte bien sur aux divers modèles de listes), des colonnes de sites, des types de contenus, et bien sur comment “packager” le tout afin de le déployer simplement dans SharePoint.

      Dans la prochaine partie, nous verrons la création d’une action personnalisée (custom action) permettant d’appeler une page d’administration que nous allons personnaliser également, tout en “packageant” encore et toujours grâce aux outils disponibles.

      Rendez-vous donc dans quelques temps !

      Convertir un document Office docx en page html grâce à SharePoint–Partie 1

      Posted on Updated on

      SharePoint dans sa version payante (MOSS 2007 ou SharePoint Server 2010) propose un outil permettant de convertir certains types de documents en pages html afin d’être intégrées aux pages d’un site.

      Parmi ces types, je me concentrerai sur le type Word “docx” avec son modèle Open Document disponible dans les versions 2007 et 2010.

      SharePoint sait donc se charger de la conversion au travers d’un TimerJob dont la fréquence d’exécution est paramétrable. Nous allons donc essayer d’utiliser au maximum ce que propose SharePoint plutôt que de réinventer la roue.

       

      Paramétrage du service de conversion


      Commençons par activer et paramétrer le service de conversion de documents.

      Lancer la console d’administration et allez dans l’onglet “Opérations” puis cliquez sur “services sur le serveur”. Repérez le “Service d’équilibrage de la charge de la conversion de documents” et démarrez ce service en cliquant sur le lien “Démarrer”.

      Console d'administration 01

      Faites de même avec le service “Service de lancement des conversions de documents”. Vous allez être redirigé vers cette page :

      Console d'administration 02

      Dans mon cas, je conserve les paramètres tels quels, et je clique sur OK. On arrive donc sur la page “Services sur le serveur” dans cet état: les deux services sont “Démarré”.

      Console d'administration 03

      Je n’ai changé aucun paramètre car je suis sur une installation “Standalone”, tous les services sont sur le même serveur.

      Deuxième étape, paramétrer la conversion de documents. Direction l’onglet voisin “Gestion des applications”. Dans la section “Connexion à des services externes”, cliquez sur “Conversion de documents”.

      Console d'administration 04

      Nous allons paramétrer le service de conversion sur une ou plusieurs WebApplication. Choisir une application, activer la conversion grâce aux radio-buttons ainsi que le serveur d’équilibrage où vous avez activé le service d’équilibrage auparavant.

      Choisissez une période d’exécution (Schedule) et cliquez sur “Appliquer”.

      Console d'administration 05

      Par curiosité, vous pouvez cliquer sur un des liens (le deuxième dans mon cas en bas de page : “Personnaliser …”. Notez que vous pouvez choisir d’activer une conversion sur une application Web, et également limiter la taille des fichiers docx à convertir.

      Console d'administration 06

      C’est bon, tout est prêt !