bewise labs rss

[SharePoint 2013] – Installation des Office Web Apps 2013 avec SharePoint Server 2013

Florent Cazenave — Wed, 15 May 2013 14:14:05 Z

Bonjour à tous.

Un nouvel article pour vous montrer comment installer et configurer les Office Web Apps 2013 couplées à SharePoint Server 2013.

Pour l’histoire, les Office Web Apps sont arrivées dans leur deuxième version : nous avons les Office Web Apps 2010 et 2013 à ce jour. Ces OWA vont nous permettre, couplées à SharePoint, d’ouvrir des documents Word, Excel, PowerPoint et OneNote directement dans le navigateur, sans utiliser les composants clients Office. Ce qui peut être évidemment très pratique lors les collaborateurs utilisent des plateformes hétérogènes de types tablettes iPad, Android, des téléphones mobiles ou encore des postes de travail sous MacOS ou une distribution Linux.

Il faut bien intégrer pour commencer qu’à chaque version de SharePoint correspond une version des Office Web Apps :

SharePoint 2010 (Foundation ou Server) => Office Web Apps 2010
SharePoint 2013 (Foundation ou Server) => Office Web Apps 2013

Coté Licencing, vous pourrez installer ces OWA (2010 ou 2013) suivant le type de licences que vous possédez pour le pack Office. Si vous possédez les packs Office (en volumes) version 2010 vous pourrez éditer les fichiers Office. Si vous ne les possédez pas, vous pourrez seulement lire des documents Office via les OWA.

De plus, avec la version 2010 des OWA, il était possible d’installer ce composant logiciel sur le même serveur que le serveur SharePoint (en le boostant un peu…). Avec la version 2013, ce n’est plus possible et ces composants s’installe sur un serveur dédié, rattaché au même domaine que SharePoint. Il y a quelques contraintes supplémentaires comme de ne pas avoir installé le pack Office sur ce serveur. Pour plus de renseignements : http://technet.microsoft.com/fr-fr/library/jj219458.aspx

Pour l’architecture utilisée pour cet article, j’ai 3 machines virtuelles (VM) :

1 contrôleur de domaine : DOMAIN
1 serveur SharePoint Server 2013 Enterprise (EN) : SP2013-DEV
1 serveur Office Web Apps 2013 : SPOWA2013

Ces trois serveurs sont rattachés au même domaine : DEMO, sont installés sous Windows Server 2012 ou Windows Server 2008R2 (EN) et à jour :

Et oui… une belle débauche de mémoire et de processeurs…

Je précise que mes machines Active Directory & SharePoint étaient déjà installées et fonctionnelles avant l’installation d’Office Web Apps.

Première étape installer et configurer Windows Server 2012 (et mettre à jour !), je ne détaillerai pas cela dans cet article.

1/ Préparation du serveur pour Office Web Apps 2013

Lorsque le serveur a été installé et configuré, il faut commencer par télécharger les Office Web Apps 2013. Pour cela, vous pouvez télécharger la Preview ici : http://www.microsoft.com/en-us/download/details.aspx?id=30358 ou ici http://www.microsoft.com/fr-fr/download/details.aspx?id=35489. Vous pourrez également télécharger l’iso depuis votre compte MSDN ou Technet.

Connectez vous ensuite à votre serveur OWA avec un compte du domaine qui est administrateur local du serveur (dans mon cas, c’est le même que le compte d’installation de SharePoint : DEMO\spadmin).

Il faut ensuite exécuter un script PowerShell sur le serveur OWA en lançant la commande en administrateur. Pour cela, rendez-vous sur les “tuiles” de Windows Server 2012, repérez la tuile Windows PowerShell :

Faites un clic-droit sur la tuile :

Et cliquez sur “Run as administrator” :

Vous pouvez avoir l’UAC qui se déclenche, on clique sur “Yes” :

Et PowerShell 3.0 :

Nous allons lancer un script permettant d’installer et de configurer les rôles et services nécessaires sur le serveur pour OWA 2013. Vous trouverez des informations complémentaires ici : http://technet.microsoft.com/fr-fr/library/jj219455.aspx.

On copie / colle le script :

Add-WindowsFeature Web-Server,Web-Mgmt-Tools,Web-Mgmt-Console,Web-WebServer,Web-Common-Http,Web-Default-Doc,Web-Static-Content,Web-Performance,Web-Stat-Compression,Web-Dyn-Compression,Web-Security,Web-Filtering,Web-Windows-Auth,Web-App-Dev,Web-Net-Ext45,Web-Asp-Net45,Web-ISAPI-Ext,Web-ISAPI-Filter,Web-Includes,InkandHandwritingServices

Le script d’installation se lance et devrait durer… moins de 3 minutes :

Mais que fait ce script me direz-vous ? Il se charge d’installer le rôle Web Server de Windows Server 2012 (installer IIS), et active sur ce rôle les différents protocoles, utilitaires qu’utiliseront les OWA 2013.

Lorsque le script est terminé, redémarrer le serveur OWA 2013. En allant dans le gestionnaire du serveur, on voit tout de suite le nouveau rôle IIS qui apparait :

Les extensions et fonctionnalités activées :

2/ Installation des Office Web Apps 2013

Maintenant que les prérequis sont installés, il va falloir installer les binaires des Office Web Apps 2013. Pour cela il faut monter l’iso téléchargé précédemment sur la machine virtuelle et lancer le setup d’installation :

Pour cela, on se rend dans l’explorateur de fichier et on fait un clic-droit sur le lecteur DVD avec l’iso monté, puis “Install or run program from your media” (s’il ne démarre pas tout seul).

Encore une fois, l’UAC peut s’activer, on clique sur “Yes” :

Le contrat de licence apparait, on sélectionne la case à cocher en bas, puis on clique sur “Continue” :

On nous demande ensuite d’indiquer l’emplacement d’installation des binaires. Je conserve l’emplacement par défaut : C:\Program Files\Microsoft Office Web Apps et on clique sur “Install Now” :

L’installation débute… on patiente :

L’installation est terminée, on clique sur “Close” :

En option, vous pouvez également installer les languages packs pour OWA 2013. Pour plus de renseignements, visitez ceci : http://technet.microsoft.com/fr-fr/library/jj219455.aspx => Etape 3.

3/ Déploiement des Office Web Apps

L’étape suivante consiste à créer l’application Web qui permettra d’afficher nos documents. Il existe plusieurs types de configurations suivant votre besoin : http ou https, équilibrage de charge, etc.

Dans mon cas, je reste dans un périmètre interne, tous les utilisateurs se connectent en http. Pour corser un peu le tout, nous allons créer l’application en PowerShell. Pour cela, on reprend notre console PowerShell lancée en administrateur et on exécute :

New-OfficeWebAppsFarm –InternalURL "http://servername" –AllowHttp -EditingEnabled

Où :

New-OfficeWebAppsFarm : permet de créer la ferme OWA 2013
InternalURL : adresse du serveur courant, dans mon cas http://spowa2013
AllowHttp : puisque je reste en http
EditingEnabled : puisque je veux permettre de lire / modifier les documents

Cela donne :

New-OfficeWebAppsFarm –InternalURL http://spowa2013 –AllowHttp -EditingEnabled

Un avertissement vous stipule que pour utiliser le mode édition de document des OWA 2013, il faut que vos utilisateur aient les licences adéquates. Pour savoir si vous pouvez utiliser le mode édition, je vous renvoie vers : http://technet.microsoft.com/fr-fr/library/ff431682.aspx#license.

Pour faire simple, vous avez les licences pour Office 2013, vous pouvez éditer. Sinon la lecture des fichiers est “offerte” par Microsoft.

Pour configurer les licences à utiliser, reportez vous à : http://technet.microsoft.com/fr-fr/library/jj219627.aspx.

Dans mon cas, je choisis donc “Yes” (Y) :

La configuration se poursuit. A la fin, un résumé apparait :

Remarque MSDN : Si des composants de .NET Framework 3.5 ont été installés puis supprimés, il est possible que vous rencontriez des messages de type « Exceptions de service web (500) » ou « Erreur interne du serveur (500.21) » lorsque vous exécutez des applets de commande OfficeWebApps. Pour résoudre ces problèmes, exécutez les exemples de commandes suivants à partir d’une invite de commandes avec élévation de privilèges afin de supprimer les paramètres susceptibles de gêner le fonctionnement normal d’Office Web Apps Server :

%systemroot%\Microsoft.NET\Framework64\v4.0.30319\aspnet_regiis.exe –iru
iisreset /restart /noforce

4/ Vérification que tout est ok…

Pour cela, nous allons utiliser le service de discovery des Office Web Apps en se connectant tout simplement sur une URL :

http://servername/hosting/discovery

Dans mon cas :

http://spowa2013/hosting/discovery

Je lance donc simplement un navigateur (IE 10 ici) et on entre l’adresse ci-dessus. Si Office Web Apps Server fonctionne comme prévu, vous verrez s’afficher un flux XML de découverte WOPI (Web app Open Platform Interface). Les premières lignes de ce fichier doivent se présenter comme dans l’exemple suivant : :

Et ce n’est pas fini…

5/ Configurer SharePoint Server 2013 pour Office Web Apps 2013

Il nous reste maintenant à faire le lien entre notre ferme SharePoint Server 2013 et les Office Web Apps 2013. Et encore une fois… une bonne dose de PowerShell !

Cependant, nous n’allons pas utiliser la console PowerShell 3.0 de Windows Server 2012, mais le SharePoint Management Shell de SharePoint Server 2013… un outil bien connu des administrateurs SharePoint !

Lançons donc la console SharePoint Management Shell, sur le serveur SharePoint bien entendu !

Puis toujours dans cette console, on lance la commande :

New-SPWOPIBinding -ServerName <WacServerName> -AllowHTTP

Dans mon cas (attention aux paramètres suivant ceux fixés lors de la configuration des OWA : http / https en particulier) :

New-SPWOPIBinding –ServerName SPOWA2013 -AllowHTTP

Le Shell vous liste un ensemble de connections WOPI disponibles :

Puis on exécute :

Get-SPWOPIZone

Dans les résultats vous devez avoir absolument :

Internal-https

Et bien sûr nous voudrions avoir du http ! Nous allons donc modifier cette zone avec la commande :

Set-SPWOPIZone –zone “internal-http”

Et on relance avec Get-SPWOPIZone pour vérifier que cela a bien été pris en compte :

Maintenant nous avons :

Internal-http

Ca sent la fin… mais pas tout de suite. Il nous reste à autoriser l’authentification OAuth sur http pour que cela fonctionne. Pour cela on éxécute :

(Get-SPSecurityTokenServiceConfig).AllowOAuthOverHttp

Si cela renvoie “False” dans la console, alors il faut forcer la valeur à “True” :

$config = (Get-SPSecurityTokenServiceConfig)
$config.AllowOAuthOverHttp = $true
$config.Update()

On relance une petite vérification :

(Get-SPSecurityTokenServiceConfig).AllowOAuthOverHttp

La valeur renvoyée doit être maintenant à “True” :

Pour plus d’informations : http://technet.microsoft.com/fr-fr/library/ff431687.aspx.

6/ Vérification de la configuration globale

Pour vérifier… il faut tester ! Nous allons donc nous connecter sur un de nos sites SharePoint avec un compte utilisateur / collaborateur (pas d’administrateur, super admin etc.)

J’ajoute quelques documents de type Office… dans une bibliothèque de documents :

On clique sur un des fichiers (PowerPoint pour ma part)… et ça marche !

Et du Word :

Et de l’Excel :

Et un OneNote :

Notez à chaque fois la présence des boutons dans le ruban pour éditer les documents, les sauvegarder etc. Ca marche plutôt bien !

Grâce aux Office Web Apps 2013, nous avons aussi la prévisualisation des documents (dans la bibliothèque de documents et dans la recherche) :

Si vous avez activé l’édition / création des documents depuis OWA 2013, lorsque vous cliquez sur le bouton Nouveau document Word, vous pourrez créer vos document directement en Web !

Voilà, c’est fini !

Ajouter un texte de description dans le “Chrome Control” de vos APPs SharePoint 2013

Lionel — Thu, 09 May 2013 16:14:17 Z

Voici la KB technique du mois ! ça faisait longtemps que j’avais pas fait de billet technique…. En ce moment je prépare des APPs pour la Conf SharePoint, et récemment j’ai mis un petit “hook” en place pour le look de mes APPs qui utilisent le Chrome Control

C’est quoi le Chrome Control ? En quelques mots c’est un composant client (JavaScript) qui permet, dans une APPs de type “Provider Hosted” (donc hébergée ailleurs que sur le site SharePoint), d’utiliser la css du site SharePoint ”parent” ainsi que son “look & feel”. En gros on est à la base sur une page blanche d’un site asp maison, et avec quelques lignes de JS on à l’impression d’être dans SharePoint . Voilà ce que ça peut donner :

Pour plus de détail sur son utilisation : http://msdn.microsoft.com/fr-fr/library/fp179916.aspx

Mais la KB n’est pas là …

Au niveau du bandeau ce composant permet un minimum de paramétrage : Logo, Titre, Lien d’aide, Menu de settings. Ni plus, ni moins.

Pour l’utiliser c’est très simple comme vous le verrez dans la doc msdn citée ci dessus, voilà ma version initiale de la fonction renderChrome :

  function renderChrome() {
          var options = {
              "appIconUrl": "../img/Logo Bleu.png",
              "appTitle": "Bon App'"

          };

          var nav = new SP.UI.Controls.Navigation(
                                  "chrome_ctrl_placeholder",
                                  options
                            );
          nav.setVisible(true);
	}

Et ça donne ça :

Un peu vide non ?…

Malheureusement, le composant ne semble pas prendre en charge aujourd’hui l’ajout d’une description (ou sous titre, ou slogan, appelez ça comme vous voulez).

Et c’est là que je vous offre ce magnifique Tips (bon j’avoue j’ai pas eu à chercher très longtemps l’id de la div qui va bien où insérer mon texte)

Le Tips consiste à ajouter un poil de JQuery et de “compléter” le html généré par le Chrome Control :

	function renderChrome() {
          var options = {
              "appIconUrl": "../img/Logo Bleu.png",
              "appTitle": "Bon App'"

          };
          var nav = new SP.UI.Controls.Navigation(
                                  "chrome_ctrl_placeholder",
                                  options
                            );
          nav.setVisible(true);


	  //récupération de la div contenant le titre de l'APP
          var titleDiv = $("#chromeControl_bottomheader_apptitle").parent().parent();
	  //sauvegarde du html de cette div
          var originalHtml = titleDiv.html();
 	  //ajout d'une div en plus pour le message secondaire
          titleDiv.html(originalHtml + "<div style="clear: left"><p>L'app SharePoint qui vous dit Bon appétit !</p></div>");
         
      }

Et voilà le résultat :

Plus sympa non !?

TOP 10 Des Influenceurs SharePoint

Lionel — Thu, 09 May 2013 15:26:10 Z

Un petit concours pour le Fun ! Après le vote au niveau Européen, cette fois ci à l’occasion de la 1ere conf SharePoint qui aura lieu très bientôt (22 au 24 mai 2013), Harmon.ie remet le couvert avec ce concours mais limité aux Francophones !

Donc pour ceux qui lisent ce billet et n’ont pas vu mon message sur twitter ou linkedin, il est encore temps de voter pour vos “SharePointistes” favoris ! ça ce passe ici : http://harmon.ie/top-10-french-sharepoint-influencers

Si vous voulez voter pour moi, je suis dans la colonne du milieu vers le bas

Les résultats lors de la Conf et bien sûr je mettrais un petit billet pour vous donner ces résultats…

WinJS : ouvrir une url dans le navigateur du système

Mon, 06 May 2013 16:15:00 +0200

Aujourd’hui c’est une toute petite astuce que je vous propose, puisqu’elle tient en 2 lignes de code. Mais comme à chaque fois que j’ai besoin de ces 2 lignes, je cherche sur Google, je me suis dit que j’allais le mettre ici, histoire de savoir où le trouver la prochaine fois.

Donc le problème : comment on fait en WinJS pour ouvrir une url dans le navigateur ? La réponse se trouve sur ce blog, et la doc sur msdn. Il suffit d’utiliser le Launcher adéquat.

var uri = new Windows.Foundation.Uri('http://www.yoururl.com/');
Windows.System.Launcher.launchUriAsync(uri);

Notez qu’ici on utilise LaunchUriAsync pour ouvrir le navigateur, mais d’autres applications peuvent être démarrées ; par exemple un éditeur d’image pour une uri associée à une image, ou une autre de vos applications présente sur le store.

Par contre, vous n’avez aucune visibilité sur ce que votre utilisateur fera une fois le launcher démarré : il peut utiliser une autre application que celle que vous lui recommandez, c’est son droit. Faites-y attention.

Pour plus de détails, la doc est toujours là !

[SharePoint 2013]–Nouvel outil : SharePoint Color Palette Tool

Florent Cazenave — Thu, 18 Apr 2013 07:15:10 Z

Avec la sortie de la nouvelle version de SharePoint 2013, nous avons vu (encore) son design général changé. Ce design reprend les principes de Modern UI dictés par Microsoft et repris sur l’intégralité des plateformes : Windows 8, Windows Phone, Xbox.

Nous retrouvons donc dans SharePoint en particulier les Tuiles bien connues, et d’autres un peu moins “Visibles” au premier abord.

SharePoint 2013 apporte également son lot de nouveau thèmes graphiques natifs sur lesquels on peut personnaliser le jeu de couleurs, l’icône, et même la navigation latérale via les materpages oslo.master & seattle.master. Cet éditeur de thèmes permet quand même bien des personnalisations, mais il se peut que cela ne suffise pas !

Dans ces cas là, on peut utiliser le Design Manager permettant d’importer des découpages html pour les convertir en masterpages, les canaux, etc. (voir mon article : SP2013–Design Manager).

Pour nous permettre d’aller plus loin, mais sans recourir à SharePoint Designer, aux CSS, aux masterpages, Microsoft nous propose un nouvel outil fraichement releasé : SharePoint Color Palette Tool ! Les prérequis sont Internet Explorer 8 ou supérieur et le Framework 4.5.

Pour ceux qui le connaitraient, pour SharePoint 2010 nous avions Theme Builder renommé Open XML Theme Builder et disponible récemment sur CodePlex : Open XML Theme Builder.

Voyons ensemble à quoi cela ressemble !

On télécharge l’outil ici : SharePoint Color Palette Tool (1,1Mb).

Et on l’installe (ici sur une machine Windows 8 Enterprise x64 en anglais) :

On lance le setup, “Next” :

On accepte les termes du contrat de licence et “Next” :

On choisit l’emplacement d’installation, puis “Next” :

Résumé des information, “Next” :

L’installation est terminée, on coche “Launch the program”, “Finish” :

Le programme se lance :

Premières impressions… plutôt bonnes ! On retrouve sur la gauche un ensemble de contrôles “couleur” avec prévisualisation et code couleur RGB. Au centre, une prévisualisation du résultat (on reprend le thème général de SharePoint 2013) et tout en haut le choix du layout (oslo ou seattle), en dessous un affichage des warnings & erreurs. Sur la droite, un contrôle permet de placer une image en fond, de choisir un jeu de couleurs originel, et au centre un outil permettant de tester le contraste appliqué…

Première chose que je vérifie… qu’est-ce que génère cet outil ? En faisant File > Save, on me propose de sauvegarder un fichier *.spcolor :

Ce fichier spcolor n’est autre qu’un fichier XML :

Qu’il faudra importer dans SharePoint 2013, pour en savoir plus, direction MSDN : http://msdn.microsoft.com/en-us/library/jj945889.aspx

En fait on retrouve une certaine analogie entre ce fichier spcolor et les css, mais seulement pour la partie couleurs. En effet, on ne retrouve dans ce fichier aucun information sur la masterpage, le layout etc. Donc les paramètres dans l’outil Color Palette ne servent qu’à la prévisualisation, pas au paramétrage du thème en lui-même.

Notons également que dans la zone de gauche, on a des sous items sur lesquels on pourra modifier les couleurs :

A mon avis, cela va être difficile de faire un jeu de couleur correct dès le premier essai ! Il y a beaucoup de couleurs à paramétrer…

Avec 3 ou 4 clics, on arrive à quelque chose… ou pas ! (Notez les warnings…)

A bientôt !

MVP du mois

Lionel — Wed, 17 Apr 2013 11:51:30 Z

Petit moment de “gloire” ! http://technet.microsoft.com/fr-fr/bb291006.aspx

Non ce n’est pas l’employé du mois, mais un “remerciement” de Microsoft pour ma participation active sur les forums Technet. C’est sympa, surtout en terme de référencement ! Merci donc aux community manager de Technet !

Conf SharePoint 2013

Lionel — Sun, 07 Apr 2013 08:28:43 Z

L’agenda et la liste des sessions sont confirmés ! Je serais conférencier à la 1ere Conférence Française entièrement dédiée à SharePoint qui se déroulera au centre des congrès du « Disney’s Hôtel New-York » à Paris du 22 au 24 Mai 2013 !

Cette conférence s’annonce très riche en découvertes, informations techniques et autres retours d’expérience avec 4 parcours différents :

· Usages et retours clients

· Gouvernance et stratégie

· Infrastructure

· Développement

Au total, pas loin de 60 sessions reparties sur les 3 jours, vous pouvez consulter l’agenda ici

Pour ma part je serais accompagné de Benoit Bernardin (l’un de mes « anciens » collègues de chez Bewise by AI3) sur la session « Géolocalisation, Mobile et SharePoint 2013 » planifiée Mercredi 22 à 14H50. Nous vous ferons découvrir qu’elle nouveautés apporte SharePoint 2013 sur la gestion des données de localisation ainsi que sur la prise en charge facilité des accès mobile. Pour plus de détail : cliquez ici

Et le lendemain j’aurais le plaisir d’animer une seconde session avec Thomas Merly (là aussi un de mes « anciens » collègues de chez Bewise by AI3) sur la session « Développez pour SharePoint 2013 sans intrusion » planifiée donc Jeudi 23 à 14H50. Cette fois ci nous vous ferons découvrir le développement d’APP pour SharePoint 2013 et en particulier l’intérêt que cela peut amener en mode « Provider Hosted » au sein du SI de votre entreprise. Pour plus de détail : cliquez ici

Enfin je vous rappelle que l’accès à cette conférence est payant et vous devez vous inscrire directement sur le site ici. Pour ceux d’entre vous qui m’aideront à promouvoir cet évènement (par exemple en relayant ce billet) j’ai la possibilité de vous obtenir un prix réduit donc n’hésitez pas à me le demander mais 1er arrivé, 1er servi et vous avez jusqu’au 27 Avril !

Je vous donne donc rdv très bientôt pour faire découvrir SharePoint à Mickey et tous ses amis

WebCast les 10 commandements de SharePoint 2013

Lionel — Thu, 21 Mar 2013 14:21:04 Z

Le WebCast de la session à laquelle j’ai participé est disponible ici

Ma partie est de la min 30 à 38, mais bien sûr je vous invite à visionner l’intégralité de la session !

[Visual Studio & SharePoint]–Paramètres remplaçables

Florent Cazenave — Mon, 04 Mar 2013 08:37:11 Z

Bonjour à tous.

Si vous développez des projets SharePoint 2010 ou 2013 avec Visual Studio 2010 ou 2012, vous devez connaitre les paramètres remplaçable. En effet, Visual Studio vous permet d’utiliser des sortes de “Pragmas” remplacés à la compilation par Visual Studio lui-même.

Vous reconnaitrez ces paramètres remplaçables rapidement car ils sont entourés par des “$”, du type : $SharePoint.Project.FileName$

Vous retrouverez ces paramètres par exemple dans les pages d’application (Applications Pages), dans l’entête de chacune des pages :

<%@ Assembly Name=”$SharePoint.Project.AssemblyFullName$” %>

Lorsque on lancera la compilation du projet dans Visual Studio, ces paramètres seront remplacés par :

<%@ Assembly Name=”MonProjet.SharePoint, Version=X.X.X.X, Culture=neutral, PublicKeyToken=XXXXXXXXXXXX” %>

Voici le tableau des paramètres remplaçables que vous pourrez utiliser :

Nom du paramètre	Description
$SharePoint.Package.Name$	Nom du package
$SharePoint.Package.FileName$	Nom du fichier de définition du package
$SharePoint.Package.FileNameWithoutExtension$	Nom sans extension du fichier de définition du package
$SharePoint.Package.Id$	ID unique SharePoint du package
$SharePoint.Feature.FileName$	Nom du fichier de définition d’une fonctionnalité
$SharePoint.Feature.FileNameWithoutExtension$	Nom du fichier de définition d’une fonctionnalité sans l’extension du nom de fichier
$SharePoint.Feature.Id$	ID unique SharePoint de la fonctionnalité
$SharePoint.Feature.DeploymentPath$	Nom du dossier de la fonctionnalité dans le package
$SharePoint.Project.FileName$	Nom du projet
$SharePoint.Project.FileNameWithoutExtension$	Nom du projet sans l’extension
$SharePoint.Project.AssemblyFullName$	Nom complet de l’assembly du projet
$SharePoint.Project.AssemblyFileName$	Nom de l’assembly du projet
$SharePoint.Project.AssemblyFileNameWithoutExtension$	Nom de l’assembly du projet sans l’extension
$SharePoint.Project.AssemblyPublicKeyToken$	PublicKeyToken de l’assembly
$SharePoint.ProjectItem.Name$	Nom de l’élément de projet
$SharePoint.Type.[GUID].AssemblyQualifiedName$	Nom qualifié de l’assembly
$SharePoint.Type.[GUID].FullName$	Nom complet de l’assembly

Microsoft précise également que l’on peut utiliser ces paramètres remplaçables dans les fichiers de type :

XML
ASPX
ASCX
WebPart
DWP

Il est possible d’étendre ces possibilités en modifiant le fichier : Microsoft.VisualStudio.SharePoint.targets qui se trouve dans : …\<program files>\MSBuild\Microsoft\VisualStudio\v10.0\SharePointTools

On l’édite avec NotePad par exemple :

On ajoute des extensions de fichier supportées si besoin. Par contre, si on change de machine, on prendra cette configuration !!! Donc attention, ces paramètres ne seront plus remplacés.

En résumé, ces paramètres sont vraiment très pratiques, et on les utilise très souvent (Visual Studio en utilise lui aussi fréquemment lorsque l’on créé une page d’application par exemple).

Pensez-y !

[VSTO]–Mon premier VSTO pour Outlook 2013

Florent Cazenave — Thu, 28 Feb 2013 10:21:30 Z

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

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 :

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… :

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 :

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).

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 :

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.)

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 :

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… :

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 :

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

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 :

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) :

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

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

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 :

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)\

On sauvegarde et on compile la solution.

De nouvelles erreurs apparaissent :

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” :

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

Et on recompile à nouveau ! Tout se passe bien :

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 :

Lancer le .msi :

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 !

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.

Arrêtons avec le browser-sniffing !

Thu, 14 Feb 2013 18:34:00 +0100

En tant qu’utilisateur d’Opera*, ça fait un petit moment que j’ai envie de parler de ce sujet, et l’annonce récente de l’abandon du moteur Presto par mon navigateur fétiche m’a enfin décidé à écrire cet article.

Le “browser-sniffing”, pour ceux qui ne savent pas ce que c’est, consiste à activer ou désactiver des fonctionnalités d’un site web en fonction du user-agent du navigateur. Mais avant de voir pourquoi c’est si mal de faire ça, nous allons faire un peu d’histoire.

Petit historique des user-agents

Le “user-agent” d’un navigateur est une chaine de caractères, qui est incluse dans l’en-tête de chaque requête HTTP effectuée. Ceci permets de fournir diverses informations sur le navigateur, la version, la langue…

Le user-agent “Opera/8.50 (Windows NT 5.1; U; en)” par exemple, représente le navigateur Opera, en version 8.5, qui tourne sous Windows XP, et installé en anglais (le “U” ne veut plus rien dire).

Remontons un peu dans le temps. À l’origine, il y avait Mosaic, le premier navigateur web devenu populaire. Il se faisait appeler à l’époque tout simplement “NCSA_Mosaic/2.0 (Windows 3.1)”.
Puis est arrivé Mozilla (“Mozilla/1.0 (Win3.1)”), rapidement renommé en Netscape, mais qui n’a pas changé de user-agent. Très vite, Netscape s’est mis en avant avec un meilleur support du html que son concurrent, à l’époque où les “frames” devenaient populaires. Vu que Mosaic ne supportait pas les frames, les développeurs ont commencé à différencier les navigateurs : c’est le début du browser sniffing : si le navigateur est Mozilla, il a droit aux frames, sinon il a une version light du site.

Ensuite est arrivé Internet Explorer (“Microsoft Internet Explorer/4.0b1 (Windows 95)”), et les ennuis commencent : Microsoft a fait un navigateur qui supporte les frames, mais son nom n’étant pas “Mozilla”, de nombreux sites web refusaient d’envoyer le site complet, quand ils ne bloquaient pas totalement l’accès.
La solution pour Microsoft : se déguiser en Mozilla. Dès la seconde version du navigateur, le user-agent est devenu “Mozilla/1.22 (compatible; MSIE 2.0; Windows 95)”, ce qui signifie un navigateur “compatible mozilla”, et dont le vrai nom MSIE, se trouve plus loin.
Et ceci dure toujours, le user agent de la dernière version d’Internet Explorer se présente toujours comme “Mozilla compatible” : “Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; WOW64; Trident/6.0; Touch)”

Sautons quelques années pour voir un autre cas intéressant : Opera 9.64.
Opera*, le seul navigateur à avoir les cojones de se présenter sous son vrai nom (:D), affichait fièrement un “Opera/9.64 (Windows NT 5.1; U; en) Presto/2.1.1”. Certains sites, ne voyant pas la compatibilité Mozilla dans le user-agent, étaient dégradés (donnant une mauvaise image totalement injustifiée au navigateur), mais globalement ça marchait quand même plutôt bien.
Puis Opera est devenu le premier navigateur à passer en version 10, dont les versions beta s’identifiaient en tant que “Opera/10”. Et là, de gros soucis sont de nouveau apparus : beaucoup de site se sont retrouvés cassés sur cette version, car les serveurs vérifiaient le navigateur (Opera), et le premier caractère de la version. Les serveurs web ne se sont pas étonnés de voir une vieille version “1” revenir à la mode et se sont contentés de bloquer ces versions.
Ce user-agent n’a donc pas passé la beta, depuis la version 10, Opera indique être “Opera/9.80”.

Je pense que vous commencez à comprendre le problème.

Pourquoi le browser-sniffing c’est mal

J’en viens donc au point de mon article : le browser-sniffing doit cesser. Il est toujours tentant de vérifier quel navigateur on a en face, pour lui renvoyer un rendu correct, mais ce n’est pas la bonne solution. Réfléchissons, comment pouvons nous reconnaitre à coup sûr le navigateur ?

On va lire son nom et sa version dans le user-agent.
Non, vous avez bien vu juste au dessus, ce n’est pas comme ça que vous aurez les bonnes valeurs. D’une version à l’autre le nom du navigateur ou son numéro de version peut se retrouver à des emplacements différents. Le user-agent n’est pas standardisé, vous ne pourrez pas retrouver toutes les valeurs possibles comme ça.
On peut faire une base de données des user-agents
Vous pouvez essayer, vous n’y arriverez pas. Avec les différents navigateurs, les différents OS, et les navigateurs mobiles (qui souvent incluent aussi le modèle du téléphone et le nom de l’opérateur de téléphonie), les combinaisons sont infinies. Et ça impliquerait de rester à jour

De plus, revenons au cas d’Opera* : dans sa version 12, il utilise le moteur de rendu Presto, la prochaine version utilisera WebKit, avec forcément des différences (certaines fonctionnalités qui n’étaient pas supportés le seront, mais inversement, peut-être certaines supportées par Presto ne le sont pas par WebKit). Si vous faites aujourd’hui des règles spécifiques à Opera, vous allez devoir les mettre à jour pour la prochaine version. Et qui sait si d’autres navigateurs ne feront pas la même chose dans les prochains mois ?

Si vous ne me croyez toujours pas

Il suffit de faire une recherche Google :

Les premiers résultats sont dans l’ordre:

la page Wikipedia (avec un paragraphe qui en décrit les problèmes)
3 articles qui disent qu’il ne faut pas l’utiliser
Les documentations de Dojo et jQuery sur les fonctionnalités de sniffing ; les deux commencent par expliquer qu’il faut éviter de l’utiliser.

Voilà, j’espère vous avoir convaincu de ne plus utiliser cette méthode pour le développement de vos sites.

Avant de nous quitter, je vous laisse les quelques liens qui m’ont aidé à la rédaction de cet article, et je vous dit à très bientôt !

Sources :

http://my.opera.com/ODIN/blog/300-million-users-and-move-to-webkit
http://fr.wikipedia.org/wiki/User-Agent
http://webaim.org/blog/user-agent-string-history/
http://whatsmyuseragent.com/

* Je vous assure, ce billet n’est pas sponsorisé par Opera, promis ! :-)

New Life, New Blog

Mimetis — Thu, 07 Feb 2013 14:18:53 Z

Bonjour à tous !

Je migre vers MSDN. Et oui, je viens d’intégrer la division DPE de Microsoft France, vous me retrouverez donc à l’adresse :

http://blogs.msdn.com/b/mim/

A tout de suite

Seb

WinJS : problèmes pouvant survenir avec les listes groupées

Tue, 22 Jan 2013 13:05:00 +0100

J’ai eu des bugs sur mes applications WinJS, et je me suis dit que j’allais partager avec vous, parce que vous savez, j’aime bien partager (et puis ça fait plus de 6 mois que j’ai pas blogué, y’a des gens qui risquent de s’inquiéter).

Donc j’ai trouvé 2 bugs, les 2 en rapports avec des listes groupées.

1 – SemanticZoom : “Object doesn't support property or method 'itemFromDescription'”

Si vous ne connaissez pas le principe du SemanticZoom, c’est tout simple. Vous avez deux vues : une liste d’éléments, affichés par groupe, et une liste n’affichant que les groupes. À l’utilisation, vous avez votre liste d’éléments, vous faites un zoom arrière (en pinçant les doigts, ou Ctrl+molette) et la liste des groupes apparait. Lorsque vous cliquez sur un groupe vous repassez sur la liste d’éléments, avec le groupe cliqué affiché. C’est le fonctionnement du start menu de Windows 8.

En mettant en place mon contrôle SemanticZoom, j’ai donc eu l’exception suivante : “Object doesn't support property or method 'itemFromDescription'”, dont la description ne fournit absolument aucun détail sur l’origine du bug.

Après investigation, j’ai donc trouvé que l’origine venait des identifiants du groupe : ils étaient de type entier. Et ça, le SemanticZoom, il aime pas.

La solution : utiliser des Strings.

var bindingList = new WinJS.Binding.List().createGrouped(
function(item) { return item.group.id.toString(); },
function(item) { return item.group; });

2 – Liste groupée et filtrée : “Unable to get property 'id' of undefined or null reference”

Une fois que j’ai réussi à gérer ma liste groupée, j’ai voulu ajouter un filtre. Au lieu d’afficher tous mes items, je décider de n’afficher que mes items favoris.

Pour ça, je peux créer une binding list filtrée, de la manière suivante, en me basant sur la liste précédente.

var bindingList = new WinJS.Binding.List().createGrouped(
function(item) { return item.group.id.toString(); },
function(item) { return item.group; }
);

var filteredList = bindingList.createFiltered(
function(item) { return item.isFavorite; }
);

Et là, encore une fois, j’ai une exception : “Unable to get property 'id' of undefined or null reference”. Et encore une fois, l’erreur est très explicite. Comme ce n’est pas le message de l’exception qui va vous aider, je vous dis de suite ce qu’il s’est passé :

En créant la liste, la binding list a récupéré la liste des groupes, en fonction des items présents. Puis lorsque le filtre a été appliqué, on s’est retrouvé avec des groupes vides. Et là paf, exception.

La solution : inverser les appels à createGrouped et createFiltered :

Ainsi, les groupes sont calculés à partir de la liste déjà filtrée, et tout fonctionne !

SP2010–Remplacer les formulaires–Part 2

Florent Cazenave — Mon, 14 Jan 2013 07:00:45 Z

Bonjour à tous.

Dans la partie précédente, nous avons vu comment créer trois modèles de listes SharePoint 2010 (fonctionnera également avec 2007 et 2013, Server ou Foundation). Avec ces modèles nous avons déployé pour chacun d’eux une instance : Pays, Villes et Commandes.

Le tout bien sûr “packagé” dans une solution SharePoint avec Visual Studio 2010. Ainsi nous avons utilisé une “Feature” pour déployer le tout qui, lorsqu’elle s’active, déploie les modèles, créée les instances de ces listes et remplit les listes Pays et Villes avec un ensemble de données.

Dans cette nouvelle partie, nous allons tenter de remplacer les formulaires standards :

DispForm.aspx
NewForm.aspx
EditForm.aspx

Dans le but de surcharger leur comportement, principalement au niveau des listes déroulantes : la liste des villes disponibles sera filtrée en fonction du pays qui sera sélectionné.

Pour compléter, vous pourriez également faire appel à quelques projets CodePlex fournissant ces listes déroulantes liées par le biais de champs personnalisés (Custom Fields) qui sont réutilisables et en soit plus “propres”. Je vous propose une autre méthode, sans passer par ces fonctionnalités additionnelles, plus dans le cas d’un usage unique.

1/ Comprendre la structure – le pourquoi…

Avant d’entamer la phase technique du développement/déploiement, il est essentiel de comprendre comment fonctionnent les formulaires standards, où ils sont déployés, etc.

Vous pouvez utiliser SharePoint Manager 2010 ou SharePoint Designer 2010 pour explorer la structure utilisé par les listes pour rediriger l’utilisateur vers ces fameux formulaires lorsqu’il souhaitera ajouter/modifier/voir les propriétés d’un élément/document dans une liste/bibliothèque de documents SharePoint. La structure est plutôt simple. Elle se compose de :

Un répertoire racine : RootFolder. Ce répertoire est créé par défaut.
Des sous-répertoires créés par les utilisateurs
Des items/documents créés par les utilisateurs
Un répertoire particulier : “Forms” qui contient les formulaires en question pour les bibliothèques de documents
Pour les listes, les formulaires en questions sont placés directement dans le RootFolder.

Il m’est arrivé, bien souvent, de reprendre des projets SharePoint, par les biais de missions de conseil, d’assistance et je vois assez régulièrement des développeurs ayant essayé de “surcharger” ces formulaires en créant leurs propres formulaires (par copier/coller)… ayant des nom différents. Et en général… :

DispForm.aspx devient DisForm2.aspx
NewForm.aspx devient NewForm2.aspx
EditForm.aspx devient EditForm2.aspx

Et moi…. ça ne me convient pas ! En effet, les anciens formulaires restent disponibles, ils ne sont pas masqués… et restent donc accessible pour quelqu’un d’observateur qui saura assez rapidement appeler ces url et pourra donc se passer des règles de gestion que l’on souhaite imposer. Nous allons voir maintenant comment écraser ces fichiers standards en déployant notre solution SharePoint et les associer à nos listes Villes et Commandes.

2/ Déployer des Formulaires personnalisés

Reprenons notre solution. On remarque tout de suite que nous n’avons aucun fichier “aspx” dans les répertoires de la solution (répertoires des listes en particulier).

Première manipulation : utiliser SharePoint Designer 2010 pour récupérer les fichiers “aspx” originaux.

On commence donc par lancer SharePoint Designer 2010 (de préférence en 32bits ), on se connecte donc sur le site et utilise l’explorateur pour atteindre notre liste, Villes par exemple (via l’explorateur à gauche “All Files > Lists > Villes”) :

On remarque tout de suite la présence des fichiers qui nous intéressent. Manipulation assez simple, on ouvre chacun des fichiers (en mode Avancé : clic droit sur chaque fichier > Ouvrir en mode avancé) et on copie/colle le contenu de chacun dans un fichier (avec Notepad ou autre) le but étant de sauvegarder chacun de ces fichiers dans le répertoire de la solution, à l’intérieur du dossier concernant notre liste et bien sûr avec le nom qui va bien… :

On copie le contenu du fichier…

Dans un Notepad :

On sauvegarde dans les répertoires Windows des définitions des listes Villes et Commandes, puis on inclut les fichiers dans la solution SharePoint :

Les nouveaux fichiers sont inclus :

Il reste ensuite une dernière manipulation à faire, sur chacun de nos fichiers aspx ajoutés dans la solution, nous allons faire un clic-droit > Propriétés :

Et nous allons changer la propriété “Deployment Type” en “ElementFile” (on peut vérifier le répertoire de déploiement qui doit pointer vers le répertoire de sortie de la feature dans le répertoire 14 (SharePointRoot) :

On reproduit ceci sur chacun des fichiers aspx. Vous pouvez vérifier dans le fichier “SharePointProjectItem.spdata” (celui au niveau de la déclaration du modèle de liste) que les modifications ont bien été apportées :

Notre solution est donc enrichie avec ces nouvelles pages. Toutefois, si l’on déploie ces nouvelles pages aspx directement, l’instance déployée n’utilisera pas directement nos nouvelles pages. Pour cela, nous allons devoir modifier le fichier Schema.xml pour chacune de ces listes, au niveau du nœud “Forms” (tout à la fin du fichier) :

<Forms>
<Form Type=”DisplayForm” Url=”DispForm.aspx” SetupPath=”pages\form.aspx” WebPartZoneID=”Main” />
<Form Type=”EditForm” Url=”EditForm.aspx” SetupPath=”pages\form.aspx” WebPartZoneID=”Main” />
<Form Type=”NewForm” Url=”NewForm.aspx” SetupPath=”pages\form.aspx” WebPartZoneID=”Main” />
</Forms>

Chaque formulaire/page est associé à notre liste SharePoint par le biais d’un nœud <Form />.

Nous allons modifier chacun de ces nœuds <Form /> pour indiquer à SharePoint qu’il doit utiliser nos pages et pas celles par défaut. Nous allons donc supprimer l’attribut SetupPath pour faire pointer chacun des formulaires vers nos pages custom.

Nous allons également ajouter quelques attributs :

Path=”NewForm.aspx” => Chemin relatif vers le fichier NewForm.aspx dans notre solution
Default=”TRUE” => Page par défaut
UseDefaultListFormWebPart=”False” => Ne pas utiliser le WebPart Standard
WebPartOrder=”1″ => Le WebPart sera placé en premier dans la zone de WebParts (il n’y en aura qu’un dans la page de toute manière)

Ce qui donne :

<Form Type=”NewForm” Url=”NewForm.aspx” Path=”NewForm.aspx” WebPartZoneID=”Main” Default=”TRUE” UseDefaultListFormWebPart=”False” WebPartOrder=”1″>

</Form>

Nous allons ensuite ajouter le WebPart de type ListFormWebPart dans la page NewForm.aspx pour afficher le formulaire standard. Il existe plusieurs méthodes que vous retrouverez sur Google, Bing ou autre.

Pour ma part, je vais choisir une méthode moins traditionnelle qui consiste à placer ce WebPart directement dans la déclaration de l’association du formulaire d’ajout d’élément et notre page custom (toutes les méthodes sont possible, celle-ci n’est pas meilleure !… juste différente). Nous allons ajouter un tag <WebParts> directement dans le <Form/> précédent, qui contiendra la déclaration du WebPart de type ListFormWebPart. Certains ont déjà du croiser ce type de déclaration, très utilisé lorsqu’on déploie des pages web avec des Modules. On obtiendra :

<Forms>
…
<Form Type=”NewForm” Url=”NewForm.aspx” Path=”NewForm.aspx” WebPartZoneID=”Main” Default=”TRUE” UseDefaultListFormWebPart=”False” WebPartOrder=”1″>
<WebParts>
<AllUsersWebPart WebPartZoneID=”Main” WebPartOrder=”1″>
<![CDATA[
<WebPart xmlns="http://schemas.microsoft.com/WebPart/v2">
<Assembly>Microsoft.SharePoint, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c</Assembly>
<TypeName>Microsoft.SharePoint.WebPartPages.ListFormWebPart</TypeName>
<PageType>PAGE_NEWFORM</PageType>
</WebPart>]]>
</AllUsersWebPart>
</WebParts>
</Form>
</Forms>

On déclare ici un WebPart de type Microsoft.SharePoint.WebPartPages.ListFormWebPart dans la zone “Main”. Notez également le tag PageType qui a la valeur PAGE_NEWFORM indiquant qu’il s’agit bien de ce WebPart dans le mode de rendu “New” (nouvel élément). Vous trouverez ici les valeurs possibles pour cette énumération : http://msdn.microsoft.com/fr-fr/library/microsoft.sharepoint.pagetype(v=office.12).aspx

On reproduit cela pour chacun des formulaires, sur nos listes Villes et Commandes :

Mais me direz-vous, nous avons copié les pages NewForm, DispForm et EditForm avec SharePoint Designer et ce WebPart devrait être déjà présent dans les pages… Oui tout à fait, c’est pour cela que nous allons le supprimer !

On ouvre donc un à un chacun des fichiers NewForm.aspx, EditForm.aspx et DispForm.aspx (pour les listes Villes et Commandes) et on recherche :

<WebPartPages:ListFormWebPart runat=”server” __MarkupType=”xmlmarkup” ……… </WebPartPages:ListFormWebPart>

On sélectionne le tout et on supprime tout le contenu de cet élément (l’élément y compris) :

On sauvegarde le tout.

Pour préciser pourquoi on ne conserve pas ce WebPart dans les pages, vous avez peut être remarque qu’il possédait la propriété ListId. Malheureusement, cette propriété est valorisée avec un GUID qui représente l’identifiant unique de la liste… et qui sera différent à chaque redéploiement de notre Solution. Impossible donc de packager ce composant directement avec le bon GUID. Vous pourrez par contre utiliser l’attribut ListName valorisé avec l’url relative de la liste.

Il nous reste à compiler, déployer… Pour vérifier que les fichiers sont bien déployés et écrasent bien les fichiers natifs, il faut changer un peu le contenu de la page (le bon vieux test du TOTO dans la page )…

Pour cela, j’ai choisi le formulaire NewForm.aspx de la liste de Commandes. Dans le ContentPlaceHolder “PlaceHolderPageTitle”, j’ajoute un TOTO :

On compile avec Visual Studio et on déploie sur notre plateforme SharePoint. Une fois le tout déployé, je me dirige vers ma liste de Commandes dans le navigateur, je clique sur nouveau :

On retrouve bien le TOTO dans le titre de la fenêtre !!! (Bien sûr on supprime le TOTO et on redéploye).

Ca c’est fait.

3/ Modifier le comportement des pages

Nos pages étant maintenant déployées, nous allons modifier leur héritage natif pour les faire hériter de classes contenues dans notre propre assembly (DLL). Pour cela, nous allons créer une classe C# pour chacun des pages NewForm, DispForm & EditForm, et ce pour chacune de nos listes (donc 6 classes dans mon cas).

En général, je créé un répertoire Pages à la racine de mon projet (les pages sont compilées dans la DLL et le fichier .cs n’est pas déployé). Une fois le dossier créé, j’ajoute 6 classes :

Ensuite, nous allons faire hériter chacune de ces classes de “WebPartPage” et ajouter “using Microsoft.SharePoint.WebPartPages” :

Ensuite, dans chacune des pages aspx, nous allons :

Ajouter tout au début : <%@ Assembly Name=”$SharePoint.Project.AssemblyFullName$” %>
Modifier le Inherits pour pointer vers notre assembly :

Inherits=”Microsoft.SharePoint.WebPartPages.WebPartPage,Microsoft.SharePoint, Version=14.0.0.0,Culture=neutral,PublicKeyToken=71e9bce111e9429c”

devient

Inherits=”DEMO1.Pages.CommandesNewForm,$SharePoint.Project.AssemblyFullName$”

Où :

DEMO1.Pages.CommandesNewForm = Namespace + nom de la classe
$SharePoint.Project.AssemblyFullName$ : nom complet de l’Assembly, valorisé par Visual Studio avant le déploiement.

On recommence la manipulation sur chacune des 6 pages aspx:

On compile/déploie à nouveau le tout. Pour tester que le code-behind est bien appelé, on peut passer en debug sur la solution et vérifier que la méthode OnLoad() est bien appelée :

Et voilà !

Je me décide enfin à publier cet article…, je continuerai la suite un peu plus tard ! Au programme, personnalisation du comportement des formulaires !

Wait & see (pas trop longtemps j’espère ) !

[Kazoumoulox] – Statistiques de fin d’année 2012

Florent Cazenave — Mon, 31 Dec 2012 08:21:04 Z

La fin de l’année approche… elle est même déjà là !

Il est temps de faire une petite synthèse sur l’année 2012 :

32 posts
84 posts en 3 ans
80Mo d’images/captures d’écran
Meilleur jour : 24 juillet 2012, 93 visites dans la journée
Article le plus consulté ce jour là : SP2013–UserProfile Active Directory Import
Articles les plus consultés en 2012 :
Au total : 15 618 vues
42 commentaires
Vues par pays sur l’année 2012 :

France : 6966
Tunisie : 432
Suisse : 274
Canada : 256
Belgique : 218

Vous pouvez consulter le report annuel ici : http://kazoumoulox.wordpress.com/2012/annual-report/

Objectif pour 2013… Faire mieux !!!

Je vous souhaite de très bonnes fêtes à tous… see you next year !

[Neos-SDI] – Webcast Microsoft + K2 : le duo gagnant pour gérer tous vos processus métiers !

Florent Cazenave — Wed, 19 Dec 2012 14:37:52 Z

Bonjour à tous.

Une petite communication afin de vous informer que je participerai demain au webcast proposé par Neos-SDI, Microsoft & K2 concernant l’intégration des technologies K2 dans l’écosystème Microsoft SharePoint, principalement sur le retour d’expérience. Donc RDV demain, le 20 décembre 2012 à partir de 15h online !

Pour plus de renseignements & inscriptions : http://www.neos-sdi.com/fr/evenements/

[SP2013] – Starter MasterPages disponibles en béta

Florent Cazenave — Thu, 06 Dec 2012 08:43:34 Z

Bonjour à tous.

Comme pour chaque nouvelle version de SharePoint, les starters MasterPages sont proposées gratuitement sur CodePlex => par ici.

A quoi vont nous servir ces MasterPages ? Tout simplement elles vont nous servir de point de départ lors de l’élaboration de Design avancés pour SharePoint 2013 en l’occurrence. Elles contiennent donc tous les contrôles nécessaires au bon fonctionnement de SharePoint, rien de plus !

Mon test de la tablette Surface – partie 1.1

Guillaume Lacasa — Fri, 23 Nov 2012 20:14:14 Z

Je pensais continuer mon test en parlant de la partie OS et des applications Windows RT, mais après avoir testé le clavier Type, je viens de récupérer un clavier Touch (merci patrons ! ;). Je fais donc un ajout à l’article précédent pour parler de ce clavier.

Contrairement au clavier Type, ce clavier demande un temps d’adaptation avant de pouvoir taper efficacement. Dès le début, en voulant taper comme sur un vrai clavier, j’ai loupé beaucoup de lettres. Après quelques minutes de pratique, ça commence à aller mieux. Le petit son que fait la tablette à chaque touche, qui peut sembler énervant au premier abord, est finalement un retour auditif qui remplace très bien le retour tactile que l’on n’a pas : si on loupe une lettre, ça s’entend !

L’absence de touche physiques rend difficile la saisie sans garder les yeux sur le clavier ; et ce même si les touches ont un léger relief pour les sentir (avec les repères indispensables sur les touches F et J). Je ne l’ai pas depuis assez longtemps pour être catégorique, mais je ne pense pas, même avec de l’entrainement, pouvoir réussir à taper aussi vite avec ce clavier qu’avec le clavier Type.

Mais mis à part ces défauts, ce clavier a quand même ma préférence, pour les raisons que j’ai évoquées dans l’article précédent : Une fois replié, on a une surface lisse à l’arrière de la Surface, c’est bien plus agréable. Il est aussi plus fin et plus léger. Même si la différence n’est pas énorme, elle est suffisante pour être remarquée, et sera appréciée des grands voyageurs.

Pour résumer, on a donc 2 très bons claviers, compte tenu de leur taille. Ils ne sont certes pas au niveau d’un vrai clavier, mais ceux-là pourront être emmenés en vacances sans problème. Quand à choisir entre les deux, voici mon conseil :

Si vous êtes amenés à rédiger régulièrement des documents ou des e-mails, préférez le clavier Type, qui offre un réel confort.
Si vous utilisez principalement la Surface pour de la consultation, préférez un clavier Touch : plus léger, plus fin, et qui reste utilisable pour des besoins occasionnels (comme ce post de blog)

Voilà, cette fois c’est fini pour la partie matériel, à bientôt pour la partie 2 qui parlera certainement de l’OS fourni avec la tablette : Windows RT (à moins que d’ici là je ne trouve autre chose à raconter)

Mon test de la tablette Surface – partie 1

Guillaume Lacasa — Mon, 19 Nov 2012 20:09:05 Z

Pour changer sur ce blog, je ne parlerai pas aujourd’hui de mes applications, mais de matériel. Je me suis offert une tablette Surface, et j’ai décidé d’en faire un test. Je ne suis pas journaliste, je vais juste ici vous parler de mon sentiment en tant qu’utilisateur après une semaine d’utilisation.

Le matériel

Ma tablette est la Surface 32 Go, avec un clavier Type. Elle est équipée d’un port USB 2 et d’un lecteur de carte Micro SD, ainsi que d’une sortie HDMI.

Globalement, la tablette donne vraiment une impression de qualité. On verra sur la durée si elle est vraiment solide, mais je ne m’inquiète pas trop pour ça.

Le port USB et le lecteur de cartes sont pratiques pour pouvoir copier/stocker des fichiers, mais je n’en ai pas vraiment eu l’usage jusque là.

La tablette est vendue avec 2 types de claviers (sachant que n’importe quel clavier USB est aussi compatible). J’ai choisi de prendre le clavier Type : un clavier avec des vraies touches, contrairement au clavier Touch qui est un plan tactile. Le clavier est attaché à la tablette à l’aide d’un système d’aimant, et les « clac » qu’on voit dans les publicités ne sont pas du tout exagérés : le clavier se fixe vraiment tout seul sans problème, et tient bien : on peut suspendre la tablette par le clavier, ça ne lache pas. Et pourtant, on le déclipse sans problème dès qu’on veut l’enlever. Très bien fichu.

On peut utiliser le clavier en le posant sur une table, ou le replier derrière la tablette pour la tenir entre ses mains. Quand le clavier est replié, il est désactivé. On y pense pas forcément quand on achète, mais heureusement que Microsoft y a pensé pour nous J

Niveau utilisation, le clavier est confortable. Il faut un temps d’adaptation, dû à sa petite taille, mais on s’y fait assez vite (j’en profite pour signaler que je suis en train de rédiger ce test sur ce clavier, et je m’en sors plutôt pas mal, même si je fais encore quelques fautes de frappe).

Par contre, même si il est très bon, il n’est pas adapté à mon usage, et c’est mon plus gros regret dans cette tablette. J’ai acheté la Surface pour pouvoir aller sur facebook, twitter, lire mes mails, tout en restant au fond de mon canapé ; et dans cette position, impossible d’utiliser le clavier. Et lorsque le clavier est replié derrière la tablette, je sens les touches sous mes doigts, et c’est désagréable.
Lorsque j’ai de longs textes à taper, j’ai tendance à sortir mon Vaio, qui reste quand même plus pratique pour un usage intense.
Au final, mon clavier me sers principalement de protection d’écran quand je me ballade avec… A 120€ la protection, ça fait un peu cher.

Niveau batterie, aucun problème : j’ai rechargé 2 fois dans la semaine, en utilisant la tablette soir et matin, avec le wifi activé. Le chargeur est lui aussi magnétique, comme le clavier, par contre ça se clipse beaucoup moins bien : cette fois il faut bien mettre la prise en face du trou, sinon ça rentre pas.

J’ai fait le tour de ce que j’avais à dire sur le matériel,

SP2010-Remplacer les formulaires – Part 1 – Template de Liste

Florent Cazenave — Fri, 19 Oct 2012 12:47:03 Z

Bonjour à tous.

Cela fait maintenant quelques semaines que je n’ai pas bloggé, je profite d’une petite “accalmie” pour publier un article qui vous montrera comment déployer des formulaires NewForm.aspx; EditForm.aspx et DispForm.aspx dans SharePoint 2010 (fonctionnera également avec SharePoint 2007 & 2013).

Bien souvent, quand je me déplace chez des clients ou que je reprend des développements qui ont été réalisés, je m’aperçois que ces formulaires ont été ré-implémentés et redéployés par le biais d’une solution SharePoint, ce qui est plutôt bien. Ce qui me choque en général, c’est que ces formulaires ne viennent pas remplacer “physiquement” les existants mais s’ajoutent aux formulaires existants, avec des nouveaux noms : newform2.aspx, editform2.aspx ou encore dispform2.aspx.

Si des utilisateurs (malins) connaissent les url vers les formulaires natifs, ils pourront toujours les utiliser !!! Et ça, c’est vraiment pas bien !

Je vais donc tenter de vous expliquer comment remplacer ces formulaires (les écraser en fait) par le biais d’une solutions SharePoint… et sans utiliser du C# => Chalenge

Nous essaierons d’utiliser au maximum les API natives de SharePoint et les fichiers XML de déploiements supportés.

Dans un second temps, j’aimerai également vous montrer comment remplacer/overrider le comportement natifs des contrôles dans ces formulaires… mais ça sera pour un prochain article !

Première chose, se connecter sur une collection de sites, un site et créer une liste. Dans mon cas ce sera une liste custom… et même une seconde liste que je créée par avance pour la suite de l’article. Je vais également créer une colonne de type lookup (recherche d’éléments déjà présents sur le site) qui “reliera” mes deux listes… Et encore une troisième qui utilisera elle aussi une colonne de type lookup :

On aura donc trois listes avec leurs attributs :

Pays contiendra le nom du pays, sa surface et son nombre d’habitants
Ville contiendra le nom de la ville, le pays d’appartenance, sa surface et son nombre d’habitants
Commande contiendra le titre de la commande, le montant, le pays et la ville. Dans un premier temps on utilisera deux lookup, pointant sur chacune de listes pays & ville. On remplacera plus tard ce comportement par des listes déroulantes liées et pré-filtrées. On sélectionnera le pays et cela filtrera la liste des villes proposées. Mais tout cela dans un second temps.

1/ Commençons par créer une solution avec Visual Studio 2010

NB : il faudra travailler un maximum en utilisant les noms internes des objets (List, Site, Web, Field) afin d’éviter les problème de renommage de ces objets (display name). On utilisera donc au maximum les staticName, internalName ou encore Name lorsqu’il seront disponibles sur ces éléments.

Commençons donc par la création de notre solution SharePoint dans Visual Studio 2010 que j’appelle DEMO1, de type “Empty SharePoint Project” :

On renseigne l’url du site de déploiement (debug) et on choisit une solution de type “Farm” :

La solution est créée, elle est vide ou presque :

Nous allons ensuite faire un clic droit sur le projet et ajouter un nouvel élément (Add New Item), de type SharePoint > 2010 > List Definition et on la nomme “Pays”. Cliquer sur “Add” :

Un assistant se lance pour nous aider à créer la structure générale de ce nouvel élément. Ainsi, on renseigne le nom d’affichage de notre modèle de liste. “Pays” dans mon cas, et on choisit le modèle “Custom List” qui est basique et conviendra très bien à notre exemple. Je choisis également de créer une instance lorsque la “Feature” déployant notre solution sera activée. On clique sur “Finish” :

La structure générale de la liste est créée :

On observe tout de suite que Visual Studio n’a pas créé 1 seul fichier mais bien un ensemble. Dans le “Répertoire” Pays, on retrouve 2 fichiers XML :

Elements.xml : décrit à SharePoint comment déployer le modèle lors de l’ajout de ce modèle
Schema.xml : décrit la structure des éléments à déployer : colonnes, vues, etc.

Dans le sous dossier ListInstance1, on retrouve également un fichier XML “Elements.xml” qui décrira comment créer une instance de cette liste à partir du modèle lors de l’activation de la Feature : nom de la liste, url, visibilité, etc.

Nous allons ensuite reproduire 2 fois ces manipulations pour créer deux nouvelles listes : Ville et Commandes :

J’ai pris le soin ici de renommer correctement les instances dans l’explorateur de solutions.

2/ Modifier les modèles de liste – Elements.xml

Notre structure générale est créée. Passons maintenant à l’enrichissement de ces modèles en les personnalisant, en ajoutant de nouvelle colonnes, etc.

Pays

Pour la liste pays, nous devons :

Ajouter les colonnes Surface, NbrHabitants
Masquer le modèle dans la galerie (les utilisateurs/power users ne pourront pas créer de nouvelles instances à partir de ce modèle)
personnaliser par-ci, par-là

Commençons par le fichier Elements.xml du modèle de liste :

<ListTemplate
Name=”Pays”
Type=”10000″
BaseType=”0″
OnQuickLaunch=”TRUE”
SecurityBits=”11″
Sequence=”410″
DisplayName=”Pays”
Description=”My List Definition”
Image=”/_layouts/images/itgen.png”/>

Nous allons commencer par modifier les attributs existants :

Name=”Pays” => cela me convient
Type=”10000” (attention il ne faudra pas avoir un autre modèle sur la plateforme portant ce numéro)
BaseType=”0” => cela me convient (on aura 1 pour les bibliothèques de documents)
OnQuickLaunch=”TRUE” => Je change en FALSE, la liste n’apparaitra pas pas défaut dans la barre de navigation rapide “QuickLaunch”
SecurityBits=”11″ => OK
Sequence => aucune importance, le modèle sera masque dans la galerie des modèles de liste (ordre de tri dans cette galerie)
DisplayName=”Pays” => OK
Description=”My List Definition” => On donne une description
Image=”/_layouts/images/itgen.png”/ => Je vais changer pour fournir une image un peu plus sympa, que je déploierais grâce à la solution dans 14/TEMPLATES/IMAGES/DEMO/monimage.png

On ajoutera les attributs :

Category=”Custom Lists” => pas obligatoire
DisableAttachments=”TRUE” => on désactive les pièces jointes
FolderCreation=”FALSE” => on désactive la création de répertoires
Hidden=”TRUE” => On masque le modèle dans la galerie
VersioningEnabled=”FALSE” => on désactive le versioning

Ce qui donne :

ListTemplate
Name=”Pays”
Type=”10000″
Category=”Custom Lists”
DisableAttachments=”TRUE”
FolderCreation=”FALSE”
Hidden=”TRUE”
VersioningEnabled=”FALSE”
BaseType=”0″
OnQuickLaunch=”FALSE”
SecurityBits=”11″
Sequence=”410″
DisplayName=”Pays”
Description=”Modèle de liste pays”
Image=”/_layouts/images/demo/pays.png”/>

Notez également qu’il vous sera possible de “localiser” les noms (Name, Description par exemple) pour faire la traduction automatique suivant la langue du navigateur/UI.

Ville

Nous allons effectuer les mêmes manipulation sur le fichier Elements.xml du modèle de liste Ville :

<ListTemplate
Name=”Ville”
Type=”10001″
Category=”Custom Lists”
DisableAttachments=”TRUE”
FolderCreation=”FALSE”
Hidden=”TRUE”
VersioningEnabled=”FALSE”
BaseType=”0″
OnQuickLaunch=”FALSE”
SecurityBits=”11″
Sequence=”410″
DisplayName=”Ville”
Description=”Modèle de liste ville.”
Image=”/_layouts/images/demo/villes.png”/>

Commandes

Pour la liste commande, on reproduit les mêmes manipulations, sauf que ne masquera pas ce modèle pour pouvoir créer de multiples instances de cette liste. Nous modifierons également l’attribut OnQuickLaunch à TRUE :

<ListTemplate
Name=”Commandes”
Type=”10002″
Category=”Custom Lists”
DisableAttachments=”TRUE”
FolderCreation=”FALSE”
VersioningEnabled=”FALSE”
BaseType=”0″
OnQuickLaunch=”TRUE”
SecurityBits=”11″
Sequence=”410″
DisplayName=”Commandes”
Description=”Modèle de liste commandes.”
Image=”/_layouts/images/demo/commandes.png”/>

3/ Modifier les modèles de liste – Schema.xml

Maintenant, il nous faut modifier les 3 fichiers Schema.xml pour ajouter les nouvelles colonnes sur chacun de nos 3 modèles.

Pays

Dans notre liste pays, nous allons ajouter deux colonnes supplémentaires : Surface & NbrHabitants. Pour cela, on ouvre le fichier Schema.xml du modèle de liste Pays :

Dans cette structure XML, on distinguera 4 parties principales :

ContentTypes : déclaration des types de contenus associés à la liste, ici celui élément (Item)
Fields : métadonnées/colonnes/champs associés à ce modèle de liste
Views : Vues disponibles sur ce modèle de liste
Forms : formulaires d’ajout/modification/affichage de chaque élément de cette liste

Nous allons modifier principalement les <Fields /> pour ajouter les deux colonnes. Ici plusieurs écoles s’affrontent. Vous pouvez partir de rien, aidé par l’IntelliSense de Visual Studio ou alors créer une liste et ces colonnes dans SharePoint et utiliser SharePoint Manager 2010 pour récupérer le schéma généré par SharePoint. Pour sa facilité, je choisirai la seconde option, mais en restant vigilant sur le flot de XML généré…

J’ai donc créé une liste “pays” dans SharePoint et créé les colonnes demandées.

On prendra soin également de choisir le type de champ le plus pertinent pour nos données : texte, monnaie, nombre, recherche, etc.

Voila donc le formulaire d’ajout d’un pays :

Vous trouverez de quoi télécharger SharePoint Manager 2010 sur CodePlex : SharePoint Manager 2010.

On lance SharePoint Manager 2010, et on explore l’arborescence de nos sites jusqu’à arriver sur notre liste “Pays” :

Dans la section de droite, vous trouverez un onglet “SchemaXml” avec l’ensemble du schéma :

On repère rapidement, dans la section <Fields> que nos deux champs créés précédemment apparaissent :

<Field Type=”Number” DisplayName=”Surface” Required=”FALSE”… />
<Field Type=”Number” DisplayName=”NbrHabitants” Required=”FALSE” … />

Ce sont ces deux nœuds XML qu’il va falloir intégrer au fichier Schema.xml. On copie donc ces deux lignes et on les colle dans Schema.xml, dans le nœud <Fields></Fields> :

Petite option supplémentaire, on peut directement ajouter ces deux champs dans les différentes vues proposées par notre modèle de liste Pays. Pour cela, dans Schema.xml, on ouvre le nœud <Views>, on y trouve deux nœuds <View></View>. Une des vues sera utilisée pour les terminaux de type mobiles, et l’autre pour l’affichage par défaut dans le navigateur de cette liste “Pays”. Nous allons directement modifier la vue commençant par :

<View BaseViewID=”1″ Type=”HTML” WebPartZoneID=”Main”

Et ajouter dans le sous-noeud <ViewFields> deux nouvelles lignes (en copiant/collant 1 existante) et en modifiant l’attribut Name avec les noms de noms champs. Je supprime également le Field Attachments correspondant aux pièces jointes que j’ai désactivé dans la déclaration du Template (voir Elements.xml précédent) :

<ViewFields>
<FieldRef Name=”LinkTitle”></FieldRef>
<FieldRef Name=”Surface”></FieldRef>
<FieldRef Name=”NbrHabitants”></FieldRef>
</ViewFields>

Attention, l’ordre a son important, les premières lignes deviendront les premières colonnes dans l’affichage. On obtiendra donc :

Notez également le nœud <OrderBy> au dessous qui vous permettra d’ordonner votre liste sur les noms des pays, alphabétiquement. Je modifie donc :

<Query>
<OrderBy>
<FieldRef Name=”Title”></FieldRef>
</OrderBy>
</Query>

C’est tout pour ce modèle de liste. Passons maintenant à l’instance qui sera créé à partir de ce modèle. Pour cela, on se rend dans l’explorateur de solution et on ouvre le fichier Elements.xml de l’instance de la liste Pays :

Dans ce dernier, nous allons encore modifier la structure XML pour paramétrer l’instance de la liste Pays qui sera automatiquement créée lors de l’activation de la feature (nous y reviendrons…).

On modifie pour obtenir :

<ListInstance Title=”Pays”
OnQuickLaunch=”FALSE”
TemplateType=”10000″
Url=”Lists/Pays”
Description=”Liste des pays”>
</ListInstance>

Notez que le TemplateType est le même que celui définit dans le <ListTemplate>, c’est très important ! Sinon SharePoint ne saura pas quel modèle utiliser pour créer l’instance. Pour l’url, ma liste sera accessible à l’adresse :

http://MONSERVEURSHAREPOINT/MONSITE/Lists/pays

Ville

Nous allons reprendre les mêmes manipulations pour ce modèle de liste. Nous allons utiliser également SharePoint Manager 2010 pour récupérer les nœuds XML des colonnes.

Nous utilisons SharePoint Manager 2010, récupération des nœuds XML, copier/coller, etc.

Dans le Schema.xml, nous ajoutons donc :

<Fields>
<Field Type=”Number” DisplayName=”Surface” Required=”FALSE”…

<Field Type=”Number” DisplayName=”NbrHabitants” Required=”FALSE”…

<Field Type=”Lookup” DisplayName=”Pays” Required=”TRUE”…

</Fields>

Jusqu’ici, nous n’avions eu que des colonnes texte ou nombre. Nous venons d’ajouter un nouveau type de colonne, le type “Lookup” (Recherche d’information déjà présentes sur le site). Ces champs permettent de référencer des données qui sont stockées dans une autre liste/bibliothèque SharePoint. Si l’on regarde les différents attributs proposés, on note :

List=”{1f675688-39f5-441d-bdb7-19f7c3dce646}”
ShowField=”Title”

Ce sont ces deux attributs qui établissent la relation entre la liste Ville et la liste Pays et plus particulièrement la colonne “Title” de la liste Pays. Lorsque nous déploierons cette solution/feature, SharePoint ne saura pas faire le lien entre ces deux listes, parce que, tout simple le GUID de la liste Pays va être régénéré !!! Et oui… il va donc falloir remplacer ce premier attribut “List” par autre chose (et si possible pas de code C# qui recréera cette relation).

Après un petit tour dans le SDK de SharePoint, on s’aperçoit qu’il est possible de remplacer ce GUID par l’adresse relative de cette liste : Lists/Pays. On obtient donc :

<Field Type=”Lookup” DisplayName=”Pays” Required=”TRUE” EnforceUniqueValues=”FALSE” List=”Lists/Pays” ShowField=”Title”

Pour la vue par défaut de cette liste, nous effectuons également les modification afin que ces champs apparaissent dans la vue :

Dans ce dernier, nous allons encore modifier la structure XML pour paramétrer l’instance de la liste Ville qui sera automatiquement créée lors de l’activation de la feature (nous y reviendrons…).

On modifie pour obtenir :

<ListInstance Title=”Villes”
OnQuickLaunch=”FALSE”
TemplateType=”10001″
Url=”Lists/Villes”
Description=”Liste des villes.”>
</ListInstance>

http://MONSERVEURSHAREPOINT/MONSITE/Lists/villes

Commandes

Pour cette dernière liste, nous allons reproduire exactement les mêmes étapes mais cette fois-ci, nous aurons deux champs de type “lookup”.

Dans le schema.xml nous aurons donc :

<Fields>
<Field Type=”Currency” DisplayName=”Montant” Required=”TRUE” … />
<Field Type=”Lookup” DisplayName=”Pays” Required=”TRUE” … List=”Lists/Pays” ShowField=”Title” … />
<Field Type=”Lookup” DisplayName=”Ville” Required=”TRUE” List=”Lists/Villes” ShowField=”Title” … />

</Fields>

Dans ce dernier, nous allons encore modifier la structure XML pour paramétrer l’instance de la liste Commandes qui sera automatiquement créée lors de l’activation de la feature (nous y reviendrons…).

On modifie pour obtenir :

<ListInstance Title=”Commandes”
OnQuickLaunch=”TRUE”
TemplateType=”10002″
Url=”Lists/Commandes”
Description=”Liste de commandes.”>
</ListInstance>

http://MONSERVEURSHAREPOINT/MONSITE/Lists/Commandes

Certains diront qu’il y a des attributs qui ne seront pas utilisé dans notre structure XML (Schema.xml, Elements.xml), je vous laisse vous reporter au SDK, Technet et autre pour faire le tri….

4/ Créer le package de déploiement

Il nous reste une étape, et pas des moindres, créer la solution, la feature qui permettra de déployer nos modèles de listes. Pour cela, Visual Studio nous aide bien (et c’est tout à son honneur quand on a connu SharePoint 2003 & 2007…).

Nous allons donc nous rendre dans le répertoire Features où nous remarquons qu’une feature est déjà disponible :

On double-clique, l’assistant de configuration des features apparait :

Aucun des modèles/instances n’est ajouté à la feature. Commençons par cela, on utilise les “flèches du milieu” pour faire passer les éléments de gauche à droite :

Nous allons également renommer la feature, donner une petite description, etc. Il vous sera également possible d’ajouter une petite icone pour distinguer plus rapidement vos features.

Chose importante, je souhaiterai que mes listes Pays & Villes ne soient créées (leurs instances plus particulièrement) que sur le site à la racine de la collection (RootWeb). Pour cela, le plus simple et de changer le Scope (Etendue) en Site (Collection de sites).

Et c’est tout… Bien sûr suivant le projet et les éléments qui le composent, vous choisirez peut être d’utiliser plusieurs fonctionnalités, avec des scopes différents…

5/ Le test !

C’est parti pour le test… vous pouvez utiliser F5 (mode debug… qui ne débuggera rien ici !) ou alors le clic droit sur le projet, Build, Deploy. Ce choisis la seconde option.

Vous aurez peut être une erreur lors du déploiement vous disant que Pays et Pays se déploie dans le même emplacement. En effet en regardant les chemins (path) de déploiement on s’aperçoit que les instances se déploient dans le même répertoire que la définition. Je renomme dans les modèles de liste :

Vous obtiendrez peut être cette fenêtre de warning :

Elle vous informe tout simplement qu’une liste avec le même nom “Pays” existe deja. On coche “Do not prompt me again for these items” puis on clique sur “Resolve automatically”…

Déploiement réussi :

Il faudra également ajouter les images correspondant aux miniatures de nos listes. J’ai fait quelques petits changements dans les Elements.xml des modèles en modifiant l’attribut Image :

Image=”/_layouts/images/demo/pays16x16.png”/
Image=”/_layouts/images/demo/villes16x16.png”/
Image=”/_layouts/images/demo/commandes16x16.png”/

Voila ce que cela donne dans le menu “View all site content” :

Rendons nous sur chacune des liste afin de vérifier :

La déclaration des vues/affichages (colonnes présentes, tris)
La déclaration des colonnes créées

Coté affichage, rien à signaler. Par contre si on lance le formulaire d’ajout d’un pays/ville/commandes, le formulaire ne présente que le champ Titre !!! Effectivement, c’est un comportement particulier de SharePoint voire étrange que l’on constate ici.

Premier réflexe, ajouter les attributs :

ShowInNewForm=”TRUE” ShowInEditForm=”TRUE” ShowInDisplayForm=”TRUE”

Sur chacun des champs. Mais cela n’aura aucun effet. Nous aurons alors deux choix :

Recourir à un type de contenu SharePoint
Supprimer les types de contenu

En général, je me tourne vers la première option. Mais dans notre cas, aucun intérêt de créer des types de contenu (ContentTypes) vu qu’on ne les utilisera qu’une seule fois (pour Pays & Ville) et qu’on ne réutilisera pas non plus la structure de Commandes (si ce n’est pour créer de nouvelles listes de commandes => et pas des sous-enfants).

Voila donc comment faire fonctionner tout cela. Première opération, supprimer les sections <ContentTypes>…</ContentTypes> ou tout du moins le contenu => <ContentTypes/> dans les 3 Schema.xml :

On sauvegarde le tout et on redéploie… et là, magique :

5/ Charger des données

Une petite dernière chose, avant de passer à la suite… Les listes étant créées, elles seront supprimées, recréées à chaque déploiement depuis Visual Studio. Pour ne pas perdre trop de temps à se recréer un jeu de test, nous pouvons remplir ces listes directement depuis leur définition. C’est ce qu’on appelle les RowData.

Nous allons commencer par ajouter des données dans Pays puis Ville. Cette méthode est aussi très pratique pour remplir automatiquement des listes de paramètres stockées dans SharePoint (ici notre liste de Pays ne change pas tous les jours…). Voila comment faire.

Dans chacun des fichiers Elements.xml des instances de nos listes, nous allons ajouter un bloc de XML :

<ListInstance Title=”Pays”
OnQuickLaunch=”FALSE”
TemplateType=”10000″
Url=”Lists/Pays”
Description=”Liste des pays”>
<Data>
<Rows>
<Row>
<Field Name=”"></Field>
</Row>
</Rows>
</Data>
</ListInstance>

En résumé, les nœuds XML :

Data : ensemble des données à ajouter
Rows : collection des lignes (ensemble d’enregistrements)
Row : 1 ligne d’enregistrement
Field : champ à valoriser pour l’enregistrement courant.

Donc pour un pays, on aurait (données recueillies sur www.france.fr) :

<Data>
<Rows>
<Row>
<Field Name=”Title”>France</Field>
<Field Name=”Surface”>543965</Field>
<Field Name=”NbrHabitants”>65350000</Field>
</Row>
</Rows>
</Data>

En on recréée une structure Row pour chacun des pays. J’en ajouterai une petite dizaine pour les tests.

On remarque tout de suite que les pays sont triés sur le nom (alphabétique) alors dans le Schema.xml :

<Row>
<Field Name=”Title”>France</Field>
<Field Name=”Surface”>543965</Field>
<Field Name=”NbrHabitants”>65350000</Field>
</Row>
<Row>
<Field Name=”Title”>Espagne</Field>
<Field Name=”Surface”>505911</Field>
<Field Name=”NbrHabitants”>46754784</Field>
</Row>
<Row>
<Field Name=”Title”>Angleterre</Field>
<Field Name=”Surface”>130395</Field>
<Field Name=”NbrHabitants”>52234000</Field>
</Row>

Nous allons faire la même chose avec les Villes. Petite différence, le champ lookup qui pointe sur la liste des Pays… Et c’est donc un peu différent. En effet, les champs lookups doivent être renseigné avec ID;#Valeur :

<Row>
<Field Name=”Title”>Marseille</Field>
<Field Name=”Surface”>240</Field>
<Field Name=”NbrHabitants”>850602</Field>
<Field Name=”Pays”>1;#France</Field>
</Row>
<Row>
<Field Name=”Title”>Madrid</Field>
<Field Name=”Surface”>608</Field>
<Field Name=”NbrHabitants”>3413271</Field>
<Field Name=”Pays”>2;#Espagne</Field>
</Row>

Attention, l’ID et celui dans SharePoint (et donc dans l’ordre d’insertion qui correspond à l’ordre dans l’Element.xml de la liste Pays !)

Et voilà ! Puisque les listes sont supprimées à chaque déploiement, nous n’auront pas besoin de remplacer les ID dans les fichiers Elements.xml.

Dernière vérification, la liste de commandes est-elle bien renseignée ?? Bien sûr que oui !

Par contre on voit tout de suite que Barcelone n’est pas en Allemagne…

Et donc… prochain article… ré-implémenter le comportement de ce formulaire… et faire communiquer nos deux liste déroulantes !

StoreTrek ou la fausse bonne idée !

Wed, 17 Oct 2012 13:31:17 Z

Vous avez peut être vu hier la news concernant cette “nouvelle” façon de faire ses courses intitulée StoreTrek. La technologie est développée par KeyTree et n’est pas sans rappeler l’initiative de Tesco. Tout de suite la vidéo :

Comme vous pouvez le voir le principe est d’être chez soi, devant sa télé et son kinect pour faire ses courses. L’objectif annoncé est de proposer une expérience immersive aux consommateurs… et c’est là que pour moi l’expérience tourne au cauchemar.

Qui a envie d’une expérience immersive pour faire ses courses ? Pour moi c’est du même niveau que le frigo qui se réapprovisionne automatiquement, la solution proposée corrige un problème inexistant. En effet selon mon rapide sondage avec moi-même il y’a un trait de caractère qui définit assez clairement les gens qui fuient les supermarchés : la volonté de ne pas perdre de temps. Or ici la solution semble assez peu efficace de ce point de vue-là : la navigation est réalisée via Kinect, les produits semblent avoir la même taille (votre baril de lessive a la même taille que le flacon d’herbes de Provence), etc. Je dirais même plus que son principe sous-jacent consiste à mimer les rayons d’un supermarché, ce qui revient donc à retourner au supermarché mais avec le ridicule en plus ^^

Vous l’aurez compris je trouve cette expérience techniquement séduisante mais son utilité ainsi que sa mise en oeuvre me semble toutes relatives. Par contre j’encourage ce type d’agences et de personnes à toujours tenter de challenger le statut quo, nous en avons besoin. Ici le début d’idée intéressante est la possibilité d’avoir un rayon “ce que vous aimerez” comme Amazon mais cela reste bien pauvre…

D’autres points de vue ici et là.

En faveur de l'observation des utilisateurs

Thu, 04 Oct 2012 10:18:30 Z

Lorsque j’accompagne mes clients ou que je forme leurs équipes le plus souvent dans la démarche de Conception Centrée Utilisateur le même point leurs semble compliqué… rencontrer de véritables utilisateurs.

Or comme le nom de la démarche le rappelle nous sommes bien en train de concevoir des systèmes devant être utilisés par des personnes et non des développeurs ^^. Blague à part cela signifie qu’une rencontre est toujours intéressante et pleine d’enseignement. Prenons l’exemple d’un outil métier, nous pourrons comprendre de manière non exhaustive :

L’environnement de travail dans lequel l’utilisateur évolue. Est-il bruyant ? Est-ce un open space ou un bout de table ? La personne est-elle toujours au même bureau ou mobile ? La personne est-elle souvent interrompue ?
La méthode de travail de la personne. Prend-elle des notes papiers ? Utilise-t-elle simultanément d’autres outils informatiques ? Tire-t-elle parti de sa mémoire musculaire, positionne-t-elle des éléments ?
Le niveau de connaissance de l’utilisateur. Est-elle à l’aise avec de multiples fenêtres ? Personnalise-t-elle son interface ? Connait-elle des procédés comme le copier-coller ou les raccourcis claviers ?
Et finalement tout un tas d’autres choses que vous remarquerez une fois sur place. Et plus vous exercerez ce type d’activité plus vous deviendrez un “anthropologue du digital”.

J’aborde aussi souvent ce sujet en parlant du travail qu’a réalisé un certain Doug Dietz. Il est designer chez GE Healthcare et plus particulièrement d’IRM. Il raconte lors de son intervention TEDx comment après avoir conçu une nouvelle version il a été la voir in situ. Et là quelle ne fut pas surprise de voir l’angoisse que l’équipement si travaillé générait chez les enfants!! Son témoignage est poignant car nous ressentons très clairement la détresse dans laquelle Doug s’est retrouvée, impuissant face à ce constat trop tardif. Evidemment il a obtenu de créer une nouvelle version de l’appareil et tout ceci a commencé par des observations. Cette nouvelle opportunité a permis à GE Healthcare et Doug de concevoir les premiers IRM adaptés aux enfants, qui racontent une histoire… La première version propose ainsi à l’enfant d’explorer les fonds marins dans un sous-marin jaune (yellow submarine ^^). Regardez plutôt l’avant/après :

Le lien de la vidéo ou la vidéo ci-dessous :

En espérant que vous décidiez d’observer systématiquement vos utilisateurs :D

C’est la rentrée…

Florent Cazenave — Mon, 17 Sep 2012 20:57:30 Z

Après quelques jours de vacances, c’est la rentrée ! Et pour cette rentrée, un petit peu de changement !!! En effet, je viens d’intégrer l’équipe de Neos-SDI qui à ouvert une nouvelle agence à Toulouse en début d’année 2012. Je ne referai pas une présentation de la société mais je vous invite à visiter le site : http://www.neos-sdi.com/fr/

C’est donc une nouvelle aventure qui commence pour moi. Au programme, du SharePoint mais surtout… du SharePoint ! Mais bien sûr je continuerai à alimenter ce blog !

A bientôt !

Un peu de l'histoire derrière ModernUI

Fri, 14 Sep 2012 12:26:00 Z

Pour tous les amoureux de design et d’interfaces je vous invite à lire un morceau de l’histoire à l’origine du langage visuel “~~Metro~~” maintenant appelé “Modern UI”. Ce nouveau paradigme impactera nos vies futures tant le nombre de Windows est important…

Merci à FastCo.Design donc. “Windows 8: the boldest, biggest redesign in Microsoft’s history”.

Enfin pour revoir et apprendre à penser vos applications pour Windows 8 :

Windows 8 WinRT SQLite

Mimetis — Fri, 14 Sep 2012 08:52:49 Z

Depuis Windows 8 Preview, nous avons accès à une base de données déployable et interne, facile d’accès directement dans votre package WinRT.

On aurait pu s’attendre à voir débarquer SQL Server Compact, mais c’est bien SQLite qui sera supporté et accessible dans Windows 8.

Nous allons voir ici comment installer et travailler avec ce petit moteur de base de données extrêmement connu dans le monde du web notamment.

Installation

Cette première partie d’installation est inspirée d’un article écrit par Tim Heuer, que vous pouvez retrouver sur son blog, in english in the text

L’installation de SQLite se fait directement depuis le menu TOOLS de Visual Studio et le sous-menu Extensions And Updates.

Par ce biais, vous aurez accès plus tard directement aux mises à jour de SQLite, sans avoir à vous en préoccuper. Deuxième chose, ce package est capable de correctement cibler votre configuration, que ce soit x86, x64 ou ARM.

Faites une recherche sur SQLite, vous devriez trouver facilement l’extension, qui s’installe via VSIX :

Il ne reste plus qu’à :

Créer un projet de type Windows Store (XAML C# dans mon cas)
Référencer l’assembly SQLite
Référencer le C++ runtime. (Obligatoire si la machine cible ne le possède pas, trés rare, et qui potentiellement vous ferait échouer la validation de votre apps)

Avant d’aller plus loin, si vous lancez la compilation de votre projet, vous risquez fortement d’avoir deux erreurs, pour le moins explicite:

Autant SQLite va savoir déployer la bonne dll suivant votre configuration, autant il vous faudra quand même avoir en target la bonne version (x86, x64 ou ARM)

Exit donc la configuration si pratique ANY CPU. Dommage …

Où en sommes nous ?

Nous avons installé SQLite, tout du moins le moteur et la runtime, compatible avec WinRT.

Il nous faut maintenant un Framework d’accès à SQLite. Il en existe plusieurs et j’ai choisi pour l’instant d’utiliser un projet Github, accessible via NuGet : sqlite-net.

(Je surveille de prés aussi le projet Sytem.Data.SQlite for WinRT. Il semble en bonne voie, je vous en reparle plus tard)

L’installation de sqlite-net est simple, elle vous rajoute 2 classes SQLite.cs, et SQLiteAsync.cs

N’hésitez pas d’ailleurs à y jeter un coup d’œil, c’est une mine d’informations.

A partir de là, votre environnement de travail est prêt et vous pouvez commencer la partie la plus intéressante : votre code

Connexion

Il faut savoir qu’ouvrir une connexion à SQLite crée un lien avec votre base de données locale mais aussi, crée la dite base de données si celle ci n’existe pas !

Pour créer une base de données SQLite, il vous faut cependant bien “placer” le fichier sqlite au bon endroit, soit le Windows Local Folder du package.

Voici un code minimaliste d’ouvertur de connexion (et donc de création de la base locale)

// Open a new Connection to SQLite.
using (var connection = new SQLite.SQLiteConnection(dbPath))
{}

Note : J’ai eu quelques soucis avec cette méthode, notamment si vous avez un caractère unicode dans le chemin d’accès de votre package.

Par exemple, mon compte utilisateur contenant un accent, “Sébastien”, cette méthode d’ouverture ne fonctionne pas !

Je vous conseille donc de passer par la surcharge du constructeur, qui elle, fonctionne

// Open a new Connection to SQLite.
using (var connection = new SQLite.SQLiteConnection(dbPath, SQLite.SQLiteOpenFlags.Create | SQLite.SQLiteOpenFlags.ReadWrite))
{}

A partir de là, votre base de données est créée. Certes elle est vide pour le moment

Outil d’administration

Pour ouvrir une base de données sqlite et l’administrer, il existe une multitude de produits. Je vous conseille SQLite Spy qui est loin d’être le plus complet, mais qui est celui qui semble le plus léger et surtout qui fonctionne a peu prés correctement avec la dernière version de SQLite (si vous avez mieux, je suis preneur )

Notre base de données se trouve dans le répertoire où sont stockées les packages Windows 8. (AppData / Local / Packages / ID Package / LocalState)

Dans mon exemple, il se trouve ici :

Travailler avec des tables SQLite

Pour faire simple dans cette première présentation, nous allons via SQLite Spy, créer une table Client et tenter de la requêter depuis notre application WinRT.

Note : Nous verrons plus tard que sqlite-net contient des outils de mapping permettant de directement créer une table à partir d’une entité. Mais pour le moment, continuons avec les bases…

Requête de sélection non paramétrée

Une fois la connexion ouverte, il suffit de :

Construire une requête
Préparer la commande (qui renvoie un IntPtr que nous appelerons SQLite3Statement)
Parcourir l’ensemble des lignes retournées
Récupérer les valeurs
Finaliser la commande

List<Client> lstClients = new List<Client>();

// Open a new Connection to SQLite.
using (var connection = new SQLite.SQLiteConnection(dbPath, SQLite.SQLiteOpenFlags.Create | SQLite.SQLiteOpenFlags.ReadWrite))
{

    const string querySelect = "Select * from Client";

    Sqlite3Statement stmt = Sqlite3Statement.Zero;
    try
    {
        // Prepare command
        stmt = SQLite3.Prepare2(connection.Handle, querySelect);

        // While row is available
        while (SQLite3.Step(stmt) == SQLite3.Result.Row)
        {
            Client client = new Client();

            // Get values
            client.ClientId = SQLite3.ColumnInt(stmt, 0);
            client.FirstName = SQLite3.ColumnString(stmt, 1);
            client.LastName = SQLite3.ColumnString(stmt, 2);
            client.CreationDate = DateTime.Parse(SQLite3.ColumnString(stmt, 3));
            client.Age = SQLite3.ColumnInt(stmt, 4);

            lstClients.Add(client);

        }
    }
    catch (SQLiteException ex)
    {
        Debug.WriteLine(ex.Message);
    }
    finally
    {
        // Finalize statement
        SQLite3.Finalize(stmt);
    }
}

Requête de sélection non paramétrée

Le passage de paramètre est relativement classique avec

D’une part la construction de la requête prenant un paramètre, représenté par un point d’interrogation :

Select * from Client where LastName = ?

D’autre part un mécanisme de Bind de paramètre coté code (le paramètre étant repéré via son index, attention à ce détail)

Attention : Index de base 1 !!!!

// Bind parameter
 SQLite3.BindText(stmt, 1, lastName, -1, new IntPtr(-1));
 SQLite3.BindInt(stmt, 2, 12);
 SQLite3.BindDouble(stmt, 3, (double)12);
 SQLite3.BindNull(stmt, 4);

sqlite-net apporte une méthode globable, plus simple à utiliser et qui prend en compte tous les types de données classiques:

SQLiteCommand.BindParameter(stmt, 1, lastName, false);

Le code de récupération des clients par le nom devient du coup :

List<Client> lstClients = new List<Client>();

// Open a new Connection to SQLite.
using (var connection = new SQLite.SQLiteConnection(dbPath, SQLite.SQLiteOpenFlags.Create | SQLite.SQLiteOpenFlags.ReadWrite))
{
    const string querySelect = "Select * from Client where LastName = ?";

    Sqlite3Statement stmt = Sqlite3Statement.Zero;
    try
    {
        // Prepare command
        stmt = SQLite3.Prepare2(connection.Handle, querySelect);

        // Bind parameter
        SQLiteCommand.BindParameter(stmt, 1, lastName, connection.StoreDateTimeAsTicks);

    
        // While row is available
        while (SQLite3.Step(stmt) == SQLite3.Result.Row)
        {
            Client client = new Client();

            // Get values
            client.ClientId = SQLite3.ColumnInt(stmt, 0);
            client.FirstName = SQLite3.ColumnString(stmt, 1);
            client.LastName = SQLite3.ColumnString(stmt, 2);
            string date = SQLite3.ColumnString(stmt, 3);
            client.CreationDate = String.IsNullOrEmpty(date) ? (DateTime?)null : DateTime.Parse(date);
            client.Age = SQLite3.ColumnInt(stmt, 4);

            lstClients.Add(client);
        }
    }
    catch (SQLiteException ex)
    {
        Debug.WriteLine(ex.Message);
    }
    finally
    {
        // Finalize statement
        SQLite3.Finalize(stmt);
    }
}

Dans une prochaine partie, nous verrons plus longuement les particularités de SQLite dans WinRT, un peu de mapping OR et quelques astuces relatives aux performances

Happy coding avec SQLite et WinRT !

Utiliser le Live SDK dans une application Windows 8 “ModernUI” javascript

Fri, 24 Aug 2012 14:38:00 +0200

Microsoft fourni depuis quelques temps une API pour se connecter aux services Live, depuis tout type d’applications : Desktop, mobile, ou web. Cette API permet d’utiliser depuis vos applications les services de Skydrive, Messenger et Hotmail.

Nous allons voir dans cet article comment se connecter à Windows Live depuis une application Windows 8 Javascript pour pouvoir utiliser ces services.

Enregistrement de l’application

La première chose à faire est d’enregistrer l’application pour qu’elle ait le droit d’accéder au service. Il suffit d’aller sur le site suivant et de suivre les indications : https://manage.dev.live.com/build

Le site vous donnera un nouveau “Package name” que vous devrez mettre dans le fichier package.appxmanifest :

Ceci vous permettra d’utiliser les services Live lors du développement.

Lorsque vous voudrez publier votre application sur le Windows Store, il faudra remettre à jour cette valeur. Pour ça, vous devez créer l’application dans votre Dashboard Windows 8.
Puis dans Visual Studio, dans “Project” > “Store” > “Associate App with the Store”, vous pourrez faire l’association.

Sachez aussi que si vous utilisez ces services, vous devrez spécifier des conditions de service, et une déclaration de confidentialité : 2 liens à enregistrer dans les fonctionnalités avancées de votre application, dans le Dashboard du Windows Store.

Installation du SDK

La première chose à faire est de télécharger et d’installer le SDK Live, puis de le référencer dans le projet :

Ensuite, il faudra référencer le SDK dans vos pages :

<script src="/LiveSDKHTML/js/wl.js"></script>

Connexion

Pour pouvoir se connecter, il faut commencer par initialiser les API, à l’aide de la méthode WL.init, qu’on va définir en lui donnant le scope : les données à laquelle on veut accéder dans notre application. C’est important, car lorsque on se connectera avec le compte de l’utilisateur, une fenêtre lui demandera d’accéder à son compte live, avec la liste des données à laquelle on demande à accéder.

WL.init({
    scope: ["wl.signin"]
});

Contrairement à une application web, nous n’avons pas besoin ici de fournir d’identifiant d’application, puisqu’il est fourni automatiquement par le SDK lui même, l’application est reconnue par le package name, qu’on a défini précédemment.

On peut maintenant se connecter pour de bon à Live. Pour ça, 2 possibilités : soit l’affichage d’un bouton pour l’utilisateur, soit une connexion automatique par code.

Pour créer un bouton, on va utiliser la méthode WL.ui. On a besoin d’un conteneur dans le HTML :

<div id="signin"></div>

Et on fait l’appel à la méthode pour faire apparaitre le bouton :

WL.ui({
    name: "signin",
    element: "signin"
});

Ceci va nous donner le bouton suivant :

On peut aussi de connecter automatiquement en javascript en utilisant la méthode WL.login:

WL.login();

Dans les deux cas une fenêtre s’affichera pour demander l’autorisation à l’utilisateur d’utiliser son compte.

Utilisation de l’API

Maintenant que vous vous êtes connecté et que l’utilisateur vous a donné les droits d’accéder à son compte live, vous pouvez utiliser l’API REST.

Si par exemple on veut récupérer le nom et le prénom de l’utilisateur, ça se fera de la manière suivante :

WL.api({
    path: "me",
    method: "GET"
}).then(
    function (response) {
        // Les information sont contenues dans l'objet response :
        // response.first_name, response.last_name
    },
    function (responseFailed) {
        // En cas d'erreur
    }
);

Ici on fait un appel au chemin “me” de l’API. En fait, la requête est faite sur l’url https://apis.live.net/v5.0/me. Lorsque la réponse arrive, on traite le résultat (à l’aide de la méthode then) avec une fonction pour traiter la réponse, et une fonction appelée en cas d’erreur.

Voilà, à partir de là on a tout ce qu’il faut pour commencer à utiliser toutes les fonctionnalités de l’API live dans l’application. A bientôt (j’espère) sur ce blog pour voir plus en détail ce qu’on va pouvoir faire de ça. En attendant, rendez-vous sur msdn si vous voulez approfondir le sujet.

Rank, Pivot, CTE, EAV

Mimetis — Thu, 09 Aug 2012 15:15:30 Z

Aujourd’hui, je veux pouvoir extraire des données d’une table EAV (Entity Attribute Value), les mettre à plat, et en plus prendre la données la plus récente, chaque attribut étant historisé.

Voici la structure de la table :

Et voici un jeu de données

On note que le client 1 possède un attribut 1001 qui représente sa taille.

Il possède deux fois l’attribut 1000 qui représente le poids, mais à des dates différentes.

Le résultat qu’on souhaite obtenir est l’ensemble de nos clients, avec sur chaque ligne, le poids et la taille, de date la plus récente.

Pour notre client 1, nous devons avoir une ligne du genre :

Pour ce faire, nous allons utiliser :

La fonction RANK : elle nous permettra de ne retenir que les données de RANK 1 partitionnées sur le ClientID et sur le DateCreation

Select ClientId, AttributId,  Valeur,
       RANK() over(Partition by ClientId, AttributId Order By DateCreation Desc ) R
From Client

Grâce à ce rank, nous avons bien les données qui nous intéressent, au rang 1 pour chaque attribut de chaque client

Une Common Table Expression : Elle nous permettra de récupérer de la requête RANK uniquement les RANK = 1

With C (ClientId, AttributId, Valeur, Position) as
(
    Select    ClientId, AttributId,  Valeur, 
            RANK() over(Partition by ClientId, AttributId Order By DateCreation Desc ) 
    From Client
    Where ExpId = 1
)
Select * from C where Position = 1

Exit donc les données dont le RANK est supérieur à 1

La fonction PIVOT : Pour mettre tout ça en ligne. Petite astuce, le Pivot demandant un agrégat, on va utiliser le Max de la valeur. Celle ci étant unique, le tour est joué !

With C (ClientId, AttributId, Valeur, Position) as
(
    Select    ClientId, AttributId,  Valeur, 
            RANK() over(Partition by ClientId, AttributId Order By DateCreation Desc ) 
    From Client
)
Select ClientId, [1000] as Poids, [1001] as Taille
From C Pivot (Max(Valeur) for AttributId in ([1000], [1001])) as PV
Where PV.Position = 1

Et voilà, vous avez bien, en lignes, les données les plus récentes d’une table EAV historisée

Evidemment, vous pouvez aussi vous passer de ce genre de tables, en utilisant les Sparses Columns bien sûr !

SSAS Dimensions, Multiple Foreign Keys

Mimetis — Wed, 08 Aug 2012 09:06:12 Z

Je viens de passer une demie journée à essayer de comprendre ce que je considère comme un bug de SSAS.

Je n’ai pas réussi à résoudre mon problème, mais du moins, j’ai trouvé un contournement.

Voici d’abord le problème :

J’ai une dimension, disons DimClient. Chaque client est lié à 3 groupes, disons DimGroup.

Nous avons donc dans la table DimClient, 3 foreign keys différentes, vers la table DimGroup.

Chaque client a :

1 groupe d’origine (OriginGroupId)
1 groupe précédent (LastGroupId)
1 groupe actuel (ActualGroupId)

Voici une représentation de ma Data Source View dans le designer :

Ce que je fais maintenant n’est pas conceptuellement le plus efficace en terme de design de dimensions, mais le principe étant de mettre le focus sur le bug que j’ai rencontré.

Dans ma dimension DimClient, j’ai donc décidé de créer 3 hiérarchies, contenant chacun le groupe adéquate.

Une hiérarchie Origin
Une hiérarchie Last
Une hiérarchie Actual

Voici encore une copie d’écran de ma dimension :

Pour que chaque client sache faire le lien sur chaque catégorie, il est aussi nécessaire de créer les relations de mes hiérarchies.

C’est ce que je fais dans l’onglet adéquate, en voici la représentation :

Ok à partir de là, je lance le process de ma dimension, pour vérifier les résultats. Et là, c’est le drame !

Voici les requêtes qu’il exécute :

On remarque tout de suite qu’il y a un ENORME soucis sur la requête

J’ai essayé toutes les manipulations possibles, en passant par les incantations vaudous, le dénie, la colère et les menaces, rien y fait. Le résultat est faux et archi faux.

La solution de contournement

Et voir même la solution idéale, beaucoup plus conceptuellement adéquate.

En y regardant de plus prés, j’ai créé des hiérarchies de groupe dans une dimension client. Ce qui est possible mais pas élégant.

Pour envisager quelque chose de plus propre, on peut passer par des dimensions de type “Role Playing” qui ont pour but de se mapper à chaque groupe de mon client.

Tout d’abord je vire les hiérarchies de ma dimension client, et je ne laisse que les clés externes (que je met en visible = false au minimum)

Ensuite, il va donc falloir ajouter 3 dimensions à la structure du cube, chacune d’entre elles étant nommée correctement.

Origin Group
Last Group
Actual Group

Rajouter ensuite chacune des relations qui lie le Groupe à la table de fait par la référence Client Groupe

Voilà, vous avez un cube qui fonctionne, et qui est correctement architecturé.

Il n’en reste pas moins que SSAS ne gère pas bien les multiples clés externes dans une dimension, et que cela reste pour moi un bon vieux Bug

Bon cube !

SSAS Default Language

Mimetis — Mon, 30 Jul 2012 09:48:46 Z

Petite astuce du Jour : Comment “forcer” le langage d’une requête MDX dans un cube SSAS qui gère plusieurs langues ?

L’idée c’est d’avoir par exemple les résultats en anglais quelque soit la culture de mon poste.

Voici une requête MDX exécutée par défaut sur mon cube SSAS :

Select
{
    ( 
        [Delivery Date].[Calendar].[Calendar Year].&[2007],
        [Customer].[Customer Geography].[Country].&[Australia]
    )
    , 
    ( 
        [Delivery Date].[Calendar].[Calendar Year].&[2008],
        [Customer].[Customer Geography].[Country].&[Australia]
    ) 
    
} on 0,
{
    [Product].[Product Categories].[Category] 
} on 1
From [Adventure Works]

Le résultat est traduit en français, car mon PC, bien qu’installé avec un OS anglais, a été configuré avec une culture FR :

Vous remarquerez que les colonnes sont bien traduites en Français alors que les valeurs de mes 2 tuples composant mon set sont en $

Je veux donc avoir “tout en anglais”.

Une des solutions, sans modifier le cube, est de spécifier la localisation dans la chaine de connexion:

Si vous passez par SSMS, il vous suffit de rajouter le paramètre sur l’onglet option :

Une fois la requête ré exécutée, vous trouverez bien vos colonnes correctement traduites

Et voilà pour une méthode simple et efficace pour tester votre localisation !!

Si vous cherchez votre Locale ID (LCID) voici un tableau de récapitulation :

http://msdn.microsoft.com/en-us/goglobal/bb964664

Bon MDX !

Stored Procedure SSIS DataFlow ControlFlow

Mimetis — Thu, 26 Jul 2012 13:27:21 Z

Aujourd’hui, un petit article pour expliquer comment travailler avec une procédure stockée en entrée d’un flux SSIS.

L’idée ici est de présenter 3 façons différentes de récupérer les données renvoyées par une procédure stockée.

La première se base sur l’utilisation de cette source dans un DataFlow
La deuxième sur un le ControlFlow avec itération
La troisième sur l’utilisation d’un DataTable en mémoire qu’on va pouvoir réutiliser partout

DataFlow

Première solution, la plus simple à mon sens. Traiter la procédure stockée en tant que source de données dans un DataFlow :

Dans le DataFlow, j’utilise un composant source avec connexion Ole DB.

Attention à la configuration de votre source de données. Le passage de paramètres (pour Ole DB) se passe comme suit :

Le paramètre dans l’appel de la procédure stockée se fait à l’aide du point d’interrogation
Le mapping des paramètres s’effectue avec le nom du paramètre attendu par la procédure stockée.

Voilà, première méthode simple et efficace

ControlFlow, Execute Task SQL, Foreach Enumerator

L’idée ici est de se placer au niveau du Control Flow et de passer par une tache Execute Task SQL.

Attention, le principe est le même que l’Ole DB source du DataFlow excepté le mapping des paramètres !

Le paramètre dans l’appel de la procédure stockée se fait à l’aide du point d’interrogation
Le mapping des paramètres s’effectue avec l’indice (de base 0) du paramètre !

Tiens d’ailleurs, pour informations, voici le lien qui spécifie Comment paramétrer cette tache SUIVANT le type de CONNEXION (Ole DB, ADO, ADO.NET, ODBC) :

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

(Oui je sais, c’est très très moche, mais c’est comme ça ! )

A partir de là, on stock le résultat dans une variable Object dans l’onglet ResultSet.

Pour information, l’objet stocké est en réalité un ADODBRecordset. Ceci nous servira dans une prochaine méthode.

De là, on peut facilement itérer sur chaque ligne, via la container Foreach :

Le container Foreach est configuré via le Foreach ADO Enumerator :

Vous pouvez de là mapper chaque colonne dans une variable temporaire et traiter chaque ligne comme bon vous semble

Control Flow, Execute Task SQL, DataTable

A partir de la solution précédente, au lieu d’itérer sur chaque ligne, on peut tout simple récupérer le ADODBRecordset de notre variable objet et remplir une DataTable, déconnectée, en mémoire.

Pour se faire, il suffit de créer un script qui va remplir la DataTable :

Pour le contenu et paramétrage du Scipt SQL Task, voir la méthode précédente

Voici le contenu du script component qui lui est chargé de remplir la DataTable:

/// <summary>
/// This method is called when this script task executes in the control flow.
/// Before returning from this method, set the value of Dts.TaskResult to indicate success or failure.
/// To open Help, press F1.
/// </summary>
public void Main()
{
    // TODO: Add your code here
     DataTable dtRows = newDataTable();

OleDbDataAdapter adapt = new OleDbDataAdapter();
adapt.Fill(dtRows, Dts.Variables["User::StoredResults"].Value);

Dts.TaskResult = (int)ScriptResults.Success;
}

Simple !

Cet exemple, un peu plus complexe me permet pourtant de simplifier et d’améliorer les performances globales de mon package, dans un scénario précis : La réutilisation du jeu de résultat dans le package global.

A supposer que le résultat de cette procédure stockée soit utilisée à plusieurs endroits, j’ai rempli une Table en mémoire que je peux réutiliser partout dans mon package sans pour autant ré exécuter ma procédure stockée.

D’ailleurs voici la méthode pour utiliser votre source DataTable en mémoire dans un DataFlow :

Tout d’abord, utilisez un script component en tant que source :

Ensuite configurez à la main; les colonnes de sorties :

Et enfin dans le script, générez le flux de sortie. N’oubliez pas de bien passer votre variable globale contenant la DataTable

Voici le script de construction des lignes:

public override void CreateNewOutputRows()
 {
     DataTable dt = Variables.ProductDataTable as DataTable;
     foreach (DataRow dr in dt.Rows)
     {
Output0Buffer.AddRow();

if (dr["BOMLevel"] == System.DBNull.Value)
Output0Buffer.BOMLevel_IsNull = true;
else
Output0Buffer.BOMLevel = (short)dr["BOMLevel"];

if (dr["ComponentDesc"] == System.DBNull.Value)
Output0Buffer.ComponentDesc_IsNull = true;
else
Output0Buffer.ComponentDesc = (String)dr["ComponentDesc"];

if (dr["ComponentID"] == System.DBNull.Value)
Output0Buffer.ComponentID_IsNull = true;
else
Output0Buffer.ComponentID = (int)dr["ComponentID"];

if (dr["ListPrice"] == System.DBNull.Value)
Output0Buffer.ListPrice_IsNull = true;
else
Output0Buffer.ListPrice = (decimal)dr["ListPrice"];

if (dr["ProductAssemblyID"] == System.DBNull.Value)
Output0Buffer.ProductAssemblyID_IsNull = true;
else
Output0Buffer.ProductAssemblyID = (int)dr["ProductAssemblyID"];

if (dr["RecursionLevel"] == System.DBNull.Value)
Output0Buffer.RecursionLevel_IsNull = true;
else
Output0Buffer.RecursionLevel = (int)dr["RecursionLevel"];

if (dr["StandardCost"] == System.DBNull.Value)
Output0Buffer.StandardCost_IsNull = true;
else
Output0Buffer.StandardCost = (decimal)dr["StandardCost"];

if (dr["TotalQuantity"] == System.DBNull.Value)
Output0Buffer.TotalQuantity_IsNull = true;
else
Output0Buffer.TotalQuantity = (decimal)dr["TotalQuantity"];

}

Note pour les puristes du code, qui vont objecter qu’une forme concaténée du if aurait été plus élégante et judicieuse (ou qui trouve que vérifier une valeur True pour ensuite affecter à True une autre valeur est une hérésie )

Il est impossible d’affecter False à la propriété VAR_IsNull. Exemple sur la propriété TotalQuantity :

public bool TotalQuantity_IsNull
 {
     set
     {
         if (value)
         {
             SetNull(3);
         }
         else
         {
             throw new InvalidOperationException("IsNull property cannot be set to False. Assign a value to the column instead.");
         }
     }
 }

Voilà j’y suis pour rien, ne taper pas le messager

Bref, l’exécution du composant fonctionne et vous pouvez par la suite utiliser votre flux comme bon vous semble !

(Presque) Simple !

Les sources du projet contiennent les 3 méthodes dans un package.

Ces sources sont utilisées sur SQL SERVER SSIS 2012 et la base de données AdventureWorks.

SSIS StoredProcedure.zip

Bon traitement SSIS !!