Blog de Philippe Vialatte » API

[Sharepoint] Gérer les formules d’une liste

Philippe Vialatte — Fri, 05 Jun 2009 07:17:00 +0000

Que se passe-t’il quand, alors que 150 sites ont été déployés a partir d’un Template, on se rends compte qu’une formule ne fonctionne pas correctement ?

(Ne pas répondre: t’avais qu’a utiliser des types de contenu, pour un ensemble de raisons, c’était exclus… )

Parce grosso modo, c’était mon petit truc rigolo de la semaine…

Donc, comme d’habitude, je passe une petite heure dans la msdn, jusqu’a trouver *the* solution, dans les champs de la classe SPFieldCalculated.

Pour ceux qui seraient intéressés par ce genre de manip, cela se fait simplement comme cela :

    SPList list = web.Lists[« Liste1″];
    SPFieldCalculated calc = list.Fields[« Column3″] as SPFieldCalculated;
    calc.Formula = « =IF(Column1=Column2, \ »OK\ », \ »Not OK\ ») »;
    calc.Update();

Il faut convertir le champ en SPFieldCalculated, car Fields renvoie une collection de SPField, lesquels n’ont pas la colonne Formula.

Créer des sites et des collections de sites avec l’API Sharepoint

Philippe Vialatte — Tue, 19 May 2009 08:41:00 +0000

(Si une personne suit, oui, je suis en train de me taper un petit outil pour automatiser la création de mes sites…et ca commence a bien marcher)

Dans mes aventures avec l’API, encore un gros arrachage de cheveux en vue

Cela fait déjà quelques mois que j’ai un système a peu prés stable pour créer automatiquement des webs, leur appliquer un modèle, des customisations de listes et Co.

Récemment, les exigences on t changes, il faut maintenant créer des collections de sites.

Première réaction, ok, facile, il suffit de trouver la « bonne ligne de commande ©T »

…en fait, c’est loin d’être aussi simple.

Premièrement, la ou on doit simplement ajouter notre site a la liste des modèles de sites pour créer un modèle de site, pour les modèles de collection de site, il faut aussi ajouter le modèle aux modèles disponibles. Pour cela, ca se passe cote serveur, avec stsadm…

Il faut donc:

Créer le modèle de site (dans les actions du site, sauver en tant que modèle)
Copier le modèle sur le serveur physique hébergeant l’application web (admettons, sur c:\montemplate.stp)
Lancer un coup de stsadm
stsadm -o addtemplate -filename « C:\montemplate.stp » -title « mon site projet » -description « mon modèle de site projet »
Vérifier que le modèle a bien été ajouté, avec stsadm
stsadm -o enumtemplates
-> « mon site projet » – Language: 1033 – Site Template: _GLOBAL_#0 – Template Id: 1

(Note, pour revenir sur mes exemples avec la base de contenu, si le modèle est bien ajouté, ou le retrouvera aussi dans la base de Configuration, dans la table CustomTemplates )

Ok, maintenant, mon modèle est au bon endroit…ne reste qu’a l’exploiter …

Pour créer une nouvelle collection de sites, je vais simplement remonter au niveau de ma web application, récupérer la liste des Sites (Sites étant une collection de site, et pas des webs…), et ajouter un nouveau SPSite.

using (SPSite parentSite = new SPSite(« http://monserveur »)) {
SPSiteCollection allSites = parentSite.WebApplication.Sites;

    SPSite newSite = allSites.Add(« sites/nouveau site », « nom du site »,
        « description du site », 1033, templateID, « MonDomaine\\MonUser »,
        « mon nom a moi », « philippe.vialatte@monserveuremail.com »);
}

…sauf que ce n’est pas si simple…En effet, la ou, pour les SPWeb, on passe directement un template, comme ca :

using (SPSite parentSite = new SPSite(siteUrl)) {

    SPWeb parentWeb = parentSite.OpenWeb();
    SPWebTemplateCollection templates = parentSite.GetCustomWebTemplates(_localeU);
    SPWebTemplate siteTemplate = templates[siteTemplateName];

return parentWeb.Webs.Add(webName, webName, « », _localeU, siteTemplate, false, false);
}

Pour les SPSite, il faut l’ID interne du modèle, qui est généré directement par Sharepoint (je vous laisse imaginer le bonheur si il faut maintenir un ID genre _GLOBAL_#1)

Une solution, si on connait le nom du fichier STP, ou si on se base sur le titre du modèle, est de passer par la collection des modèles

string templateID = null;

foreach (SPWebTemplate template in parentSite.GetWebTemplates(1033)) {
   if (template.Title.ToLowerInvariant().Equals(« mon site projet »)) {
      templateID = template.Name; // _GLOBAL_#0
   }
}

Attention, il faut bien préciser le bon ID pour la locale, sinon, pas moyen de retrouver le modèle.

Si ca intéresse du monde, je rajouterais un projet un peu plus complet, pour montrer le procédé plus en détail

Petites finesses de l’API Sharepoint

Philippe Vialatte — Mon, 18 May 2009 09:10:00 +0000

Ca faisait un moment que je n’avais plus fait de développement avec Sharepoint, et en m’y remettant, j’avais oublie deux petites finesses, qui peuvent éventuellement provoquer l’apparition spontanée de cheveux blancs, alors…pour ne plus les oublier

1. BreakRoleInheritance et AllowUnsafeUpdates

Lorsque l’on appelle BreakRoleInheritance, la référence au SPWeb courant est invalidée, ce qui provoque un reset de AllowUnsafeUpdates a false. Ce sera aussi le cas lorsque l’on changera le nom ou l’URL du site (après avoir appelé Update), ou lorsque l’on appellera BreakInheritance(),ResetRoleInheritance(). Par conséquent, a chaque appel a BreakRoleInheritance, il faut penser a sauvegarder préalablement la valeur de dans un booléen, et le remettre a sa valeur d’origine après.

bool updateRights = _web.AllowUnsafeUpdates;
_web.BreakRoleInheritance(false);
_web.AllowUnsafeUpdates = updateRights;

2. RunWithElevatedPrivileges et le site courant

RunWithElevatedPrivileges est super utile comme fonction lorsque l’on doit exécuter une portion de code avec des privilèges admin. Le seul petit piège de cette fonction, qui va exécuter une portion de code comme si elle tournait avec l’identifiant du pool d’application, est que, si on essaye de manipuler une référence a un site, a un web ou a une liste récupérée depuis l’extérieur de la zone de privilèges élevés, cette référence aura toujours les droits qu’avaient l’utilisateur AVANT RunWithElevatedPrivileges.

Donc, pour que cela fonctionne correctement, il faudra recharger les sites, web, listes et compagnie depuis l’intérieur de la zone impersonnée…

SPSecurity.RunWithElevatedPrivileges(delegate {
   using (SPSite site = new SPSite(siteUrl)) {
      using (SPWeb tmpWeb = site.OpenWeb(« / »)) {
         SPList MaListe = tmpWeb.Lists[« MaListe »]);
      }
   }
});

ou sinon, si on préfère :

Guid currentWebId = web.ID;
Guid currentSiteId = web.Site.ID;

SPSecurity.RunWithElevatedPrivileges(delegate {
   using (SPSite site = new SPSite(currentSiteId)) {
      using (SPWeb tmpWeb = site.OpenWeb(currentWebId)) {
         SPList MaListe = tmpWeb.Lists[« MaListe »]);
      }
   }
});

Voila, avec un peu de chance, j’y penserais tout de suite la prochaine fois (mais bien sur…)

[Sharepoint]Gérer les pièces jointes d’un SPListItem

Philippe Vialatte — Mon, 04 May 2009 11:29:00 +0000

Comme la question avait été posée sur le forum, une petite fonction pour gérer les pièces jointes a un Item.

Avec Sharepoint, les objets de type SPListItem ont une propriété en lecture seule Attachments, qui retourne un objet de type SPAttachmentCollection

public SPAttachmentCollection Attachments { get; }

Ajouter ou supprimer une nouvelle pièce jointe se fait assez simplement, du moment que l’on a un tableau de byte, soit :

    SPListItem item;
    byte[] content;
    string name;

    item.Attachments.AddNow(name, content);
    // utiliser AddNow permets de ne pas avoir à appeler item.Update();
    item.Attachments.DeleteNow(name);
    // utiliser DeleteNow permets de ne pas avoir à appeler item.Update();

Attacher le contenu d’un fichier venant du site Sharepoint se fait aussi assez simplement :

   SPFile file = myWeb.Folders(« monDossier »).Files(« Monfichier »);
   string fileName = file.Name;
   byte[] fileContent = file.OpenBinary();

La ou cela devient beaucoup plus rigolo, c’est lorsque l’on veut lister les attachments…

En effet, si on fais un foreach sur les attachements, on ne vas pas retourner des objets SPAttachment (par exemple), ni même SPFile, mais…le nom du fichier :-\

Apres un peu de recherche, ces items sont stockés dans un sous-répertoire de la liste, nommé Attachments, les fichiers étant exactement stockes dans un répertoire identifié par l’ID de l’item de la liste concerné. On peut donc y accéder ainsi :

    SPFolder folder = site.Folders(« Lists »).
        SubFolders(listItem.ParentList.Title).
        SubFolders(« Attachments »).
        SubFolders(listItem.ID.ToString());

    foreach (SPFile file in folder.Files) {
        // manipulations diverses et variées sur les fichiers
    }

(NB. : Ca a l’air trivial comme ca, mais à l’époque, ca m’a couté pas mal de cheveux )

[Sharepoint] Enumérer les répertoires d’une liste documentaire

Philippe Vialatte — Mon, 30 Mar 2009 09:22:00 +0000

Je me suis récemment un peu pris la tête sur un problème, en apparence simple, mais pour lequel l’API m’a enduit d’erreur.

Mon problème de base était simple, je voulais juste lister les répertoires d’une liste de documents (pour supprimer des droits, si vous voulez tout savoir ).

Pour cela, je jettes un oeil a l’API, je vois un joli list.Folders…sauf que List.Folders renvoie une liste…d’items :-\.

Après quelques essais, la bonne propriété est donc la propriété SubFolders du RootFolder de notre liste, pour un résultat final ressemblant a cela:

foreach (SPList list in SPContext.Current.Web.Lists) {
    if (list.BaseType == SPBaseType.DocumentLibrary) {
        if (list.Title == reportsLib || list.Title == importLib) {
            foreach (SPFolder folder in list.RootFolder.SubFolders) {
                try {
                    RemoveFolderPermissionsForGroup(siteAddress, folder, groupName);
                } catch (Exception ex) {
                    LogFactory.LogError(« Could not remove «  + groupName +  » from folder », ex);
                }
            }
        }
    }
}

[Sharepoint] mise a jour des droits des utilisateurs sur n sites

Philippe Vialatte — Wed, 11 Feb 2009 12:41:00 +0000

Mon petit problème de la semaine en SharePoint a été le suivant…

A 9h du matin, le lundi, un ensemble d’utilisateurs a…change de groupe AD…

Attention, leur groupe AD n’a pas été renommé, mais pour des raisons d’organisation, ces utilisateurs ont été bougés d’un groupe AD a l’autre. Or, ce groupe AD avait la responsabilité d’administrer n sites Sharepoint…joie

Ma mission, que je n’avais pas d’autre choix que d’accepter, a donc été de supprimer le groupe précédent du groupe défini comme owner des sites, et de le remplacer par un autre groupe…sur une cinquantaine de sites…

Ma matinée de Lundi a donc été consacrée a gribouiller ce petit script, si cela peut aider quelqu’un, un jour

L’idée est la suivante, dans un premier temps, on ouvre le Web correspondant au Site principal (et avec un using, SVP…), et on cherche le SPUser correspondant au groupe (que l’on passe par ligne de commande, réusabilité oblige…)

using (SPWeb parentWeb = new SPSite(args[0]).OpenWeb()) {

SPUser userToRemove = FindUserFromLogin(args[1], parentWeb);
SPUser userToAdd = FindUserFromLogin(args[2], parentWeb);

Le FindUserFromLogin est une petite routine maison, pour retrouver un SPUser depuis un login…ca coute pas cher

private static SPUser FindUserFromLogin(string userLogin, SPWeb web) {

foreach (SPUser user in web.SiteUsers) {

      if (user.LoginName.Equals(userLogin, StringComparison.InvariantCultureIgnoreCase)) {
         return user;
      }
   }
   return null;
}

Et après, pour chaque web dans le site, on va chercher le groupe des propriétaires du site, que l’on trouvera dans la propriété vti_associateownergroup

foreach (SPWeb web in parentWeb.Webs) {

int groupId;

if (int.TryParse(web.Properties[« vti_associateownergroup »], out groupId)) {

On notera le TryParse (on sait jamais )

Une fois qu’on a le groupe, on regarde si l’utilisateur à supprimer existe :

SPUser test = null;

try {
    test = group.Users.GetByID(userToRemove.ID);
} catch {
    Console.WriteLine(« user : «  + userToRemove.Name
        +  » was not found in web : » + web.Name);
}

Berkk…pas trouvé de méthode plus propre, en dehors d’itérer sur tous les utilisateurs, ce qui ne me plaisait pas non plus…

Et enfin, il n’y a plus qu’à ajouter le nouvel utilisateur, à enlever le vieux, et à mettre le groupe a jour.

if (test != null) {

    Console.WriteLine(« Adding user »);
    if (userToAdd != null) {
        group.AddUser(userToAdd);
    } else {
        group.AddUser(args[2], «  », «  », «  »);
    }

    Console.WriteLine(« Removing user »);
    group.RemoveUser(userToRemove);
    group.Update();
    Console.WriteLine(« user : «  + userToRemove.Name
        +  » was replaced by user : «  + userToAdd.Name +  » in web : » + web.Name);
}

comme quoi, le bonheur, c’est simple comme un coup d’API

Si il y’avait une meilleure solution (oui, je sais, on aurait du avoir un groupe d’administration décorrélé de l’active directory…), n’hésitez pas a m’en faire part, j’aime bien avoir tort, ca permets de progresser