Après plusieurs recherches, j’ai pu trouver une explication assez vague : Le service JavaScript de SharePoint override l’action par defaut du formulaire afin de pouvoir gérer certains types d’URL, qui peuvent contenir des caractères sur deux octets, pour des scénarios de rappels asynchrones.

La solution est donc de désactiver cette solution par le biais d’un script simple :

<script type="text/javascript">
    _spOriginalFormAction = document.forms[0].action;
    _spSuppressFormOnSubmitWrapper = true;
</script>

Ce qui résoudra votre problème de second postback.

"ErrorMessage":"The method \"GetItems\" of the type \"List\" with id \"{xxxxxxx-xxxxxxx-xxx-xxx}\" is blocked by the administrator on the server."

Pour désactiver cette restriction, il faut aller voir du coté de SPClientCallableSettings.AnonymousRestrictedTypes.

Cette propriété référence toutes les méthodes qui sont restreintes dans le cas d’un accès par un utilisateur anonyme.

Nous pouvons voir, en y accédant en PowerShell, que la méthode “GetItems” est bien présente dans les méthodes restreintes.

Afin de permettre la récupération des éléments d’un liste avec les utilisateurs anonymes, vous pouvez appeler ce code dans un script PowerShell :

   1: $wa = Get-SPWebApplication -Identity $WebAppName

   2: $wa.ClientCallableSettings.AnonymousRestrictedTypes.Remove([Microsoft.SharePoint.SPList], "GetItems") 

   3: $wa.Update()

Et voilà, vous pouvez maintenant y accéder sans problème..

• ImageFieldValue
• TaxonomyFieldValue & TaxonomyFieldValueCollection
• HtmlField

Ces méthodes, à rajouter dans votre fichier généré sont très utiles et faciles à instancier.

Cependant, dans le cas où vous devez rajouter plusieurs fois des listes ou des types de contenu. A chaque regénération, vous devez remettre ces méthodes au bon endroit dans la classe, et je peux vous dire, pour l’avoir fait, que ça prend pas mal de temps et que c’est très répétitif !

Une solution efficace et d’utiliser le Custom Mapping. Il va nous permettre, pour n’importe qu’elle liste ou type de contenu, de rajouter les fonctions nécessaires pour récupérer ce type de colonnes, et cela, une seule et unique fois.

Pour l’exemple, je vais vous montrer un dernier type non pris en charge, qui est:  Type fichiers attachés. En mode Custom Mapping bien sûr.

Il s’agit des SPAttachmentCollection de l’assembly Microsoft.SharePoint.

Il s’agit donc ici d’étendre la classe généré par SPMetal et de rajouter nos propres champs en plus, pour cela, la classe custom mapping prévoit 3 fonctions : MapTo, MapFrom et Resolve.

• MapFrom pour la lecture (READ). => GET
• MapTo pour l’écriture (WRITE). => SET
• Resolve pour la mise à jour (UPDATE).

public partial class Contact : Item, ICustomMapping
{
    private const string CONTENT_FIELD = "Attachments";
    private SPAttachmentCollection _contentAttachments;
    public SPAttachmentCollection ContentAttachments
    {
    }

    [CustomMapping(Columns = new string[] { CONTENT_FIELD})]
    public void MapFrom(object listItem)
    {
    }

    public void MapTo(object listItem)
    {
    }

    public void Resolve(RefreshMode mode, object originalListItem, object databaseListItem)
    {
    }
}

Comme les différents types précédents, on commence par instancier l’entité SPAttachmentCollection.

private SPAttachmentCollection _contentAttachments;
       public SPAttachmentCollection ContentAttachments
       {
           get { return _contentAttachments;}
           set
           {
               if (value != _contentAttachments)
               {
                   this.OnPropertyChanging(CONTENT_FIELD, _contentAttachments);
                   _contentAttachments = value;
                   this.OnPropertyChanged(CONTENT_FIELD);
               }
           }
       }

On nomme la variable CONTENT_FIELD du nom de la colonne en question.

Passons à la fonction de lecture:

[CustomMapping(Columns = new string[] { CONTENT_FIELD})]
public void MapFrom(object listItem)
{
           SPListItem item = (SPListItem) listItem;
           if((bool)item[CONTENT_FIELD] != false)
           {
               this.ContentAttachments = (SPAttachmentCollection) item.Attachments;
           }
}

Cette fonction va simplement vérifier qu’un champ du nom en question existe puis le caster au bon format.

Fonction d’écriture :

public void MapTo(object listItem)
{
            SPListItem item = listItem as SPListItem;
            if(this.ContentAttachments != null)
            {
                item[CONTENT_FIELD] = ContentAttachments;
            }
}

Il s’agit du setter, on va donc écrire la valeur de fichiers dans le bon champ de colonne

Fonction de mise à jour :

Il y a plusieurs type d’update à prendre en compte, en fonction de ce que l’on choisit :

• KeepCurrentValues
  
  Force la méthode Refresh à permuter les valeurs d’origine avec les valeurs récupérées. Aucune valeur actuelle n’est modifiée.
• KeepChanges
  
  Force la méthode Refresh à conserver la valeur actuelle qui a été modifiée, mais met à jour les autres valeurs.
• OverwriteCurrentValues
  
  Force la méthode Refresh à substituer toutes les valeurs actuelles par les valeurs de la base de données.

public void Resolve(RefreshMode mode, object originalListItem, object databaseListItem)
 {
     SPListItem originalItem = originalListItem as SPListItem ;
     SPListItem databaseItem = databaseListItem as SPListItem ;

     SPAttachmentCollection originalValue = originalListItem[CONTENT_FIELD] as SPAttachmentCollection ;
     SPAttachmentCollection databaseValue = databaseItem[CONTENT_FIELD] as SPAttachmentCollection ;

     switch (mode)
     {
         case RefreshMode.OverwriteCurrentValues:
             this.ContentAttachments = databaseValue;
             break;
         case RefreshMode.KeepCurrentValues:
             databaseItem[CONTENT_FIELD] = this.ContentAttachments;
             break;
         case RefreshMode.KeepChanges:
             if (this.ContentAttachments != originalValue)
                 databaseItem[CONTENT_FIELD] = this.ContentAttachments;
             else if (this.ContentAttachments == originalValue && this.ContentAttachments != databaseValue)
                 this.ContentAttachments = databaseValue;
             break;
     }
 }

Et voilà, vous gérez chaque fonctions possible, ce qui vous donne pour l’utilisation avec Linq :

Vous avez alors accès aux fichiers attachés directement, ici pour la lecture puisque l’objet “item” correspond à la liste “contact” à laquelle nous avons ajouté des fichiers sans rien avoir à faire de plus, les méthodes “mapTo,mapFrom et resolve” se font automatiquement lors de l’appel de la classe généré par SPMetal.

Il faut bien comprendre par cette méthode qu’il faut prendre les listes/types de contenu UNE par UNE afin de rajouter les champs nécessaires, c’est mieux que de les rajouter directement dans le fichier généré puisque par cette méthode, nous le faisons qu’une seule fois.

A vous de choisir votre meilleur solution maintenant.

Utilisé par les RichTextBox ,il faut pouvoir récupérer les valeurs, les couleurs/polices/images que l’on peut avoir dans ce type de champ.

Comme pour les champs taxonomiques, et les images, il faut juste utiliser une classe spécifique: Microsoft.SharePoint.Publishing.Fields.HtmlFiel dans votre fichier généré par SPMetal.

[Microsoft.SharePoint.Linq.ColumnAttribute(Name="col_PublishingHtml", Storage="_publishinghtml", FieldType="Html")]
public Microsoft.SharePoint.Publishing.Fields.HtmlField PublishingHtml {
       get {
        return this._publishinghtml;
       }
       set {
          if ((value != this._publishinghtml)) {
             this.OnPropertyChanging("PublishingHtml", this._publishinghtml);
             this._publishinghtml= value;
             this.OnPropertyChanged("PublishingHtml");
          }
        }
}

Et voilà, vous pouvez utiliser ce type de colonne sans problèmes.

En effet, les champs de ce type peuvent être multi-values. Leur résolution est donc différente.

La dessus, même en forçant la génération de la colonne dans le fichier XML pour paramétrer SPMetal, ça ne vous aidera pas.

Il faut donc utiliser l’assembly : Microsoft.SharePoint.Taxonomy.TaxonomyFieldValue pour les champs taxonomiques simple et Microsoft.SharePoint.Taxonomy.TaxonomyFieldValueCollection pour les multi-values qui n’est autre qu’une List<TaxonomyFieldValue>.

Ces classes permettent de récupérer le label, donc le texte, le “termGuid” pour le Guid du term, la “validatedString” qui est une représentation dite sérialisée de l’objet taxonomique ainsi que le WssId nécessaire pour le lookup de champs, pour plus d’information: ici.

Ainsi si le champ est simple :

[Microsoft.SharePoint.Linq.ColumnAttribute(Name="col_Keyword", Storage="_keyword", FieldType="Taxonomy")]
public TaxonomyFieldValue Keyword {
       get {
          return this._keyword;
       }
       set {
          if ((value != this._keyword)) {
             this.OnPropertyChanging("Keyword ", this._keyword);
             this._keyword= value;
             this.OnPropertyChanged("Keyword");
          }
       }
}

Pour les multi-values:

[Microsoft.SharePoint.Linq.ColumnAttribute(Name="col_Keywords", Storage="_keywords", FieldType="Taxonomy")]
public TaxonomyFieldValueCollection Keywords{
       get {
           return this._keywords;
       }
       set {
           if ((value != this._keywords)) {
              this.OnPropertyChanging("Keywords", this._keywords);
              this._keywords= value;
              this.OnPropertyChanged("Keywords");
           }
       }
}

Bien sûr, avec ce type de classe, ne pas oublier de faire une petite boucle pour afficher vos labels avec un “;” entre chaque TaxonomyFieldValue par exemple.

Et voilà, encore un type de champ complété.

Pour cela, rien de plus simple, une fois que vous avez repéré quels sont vos champs qui ne passeront pas, il suffit de compléter le fichier SPMetal généré.

Les champs de ce type dans SharePoint permettent d’avoir accès à différents attributs, ce n’est donc pas une simple URL de type string qui est stocké.

Pour l’instancier, il faut donc utiliser :  Microsoft.SharePoint.Publishing.Fields.ImageFieldValue, vous pouvez retrouver les propriétés sur msdn ici.

Il reste maintenant à remplacer:

[Microsoft.SharePoint.Linq.ColumnAttribute(Name="col_Thumbnail", Storage="_thumbnail", FieldType="Invalid")]
public virtual object Thumbnail {
   get {
     return this._thumbnail;
   }
   set {
     if ((value != this._thumbnail)) {
         this.OnPropertyChanging("Thumbnail", this._thumbnail);
         this._thumbnail = value;
         this.OnPropertyChanged("Thumbnail");
     }
  }
}

Qui devient :

[Microsoft.SharePoint.Linq.ColumnAttribute(Name="col_Thumbnail", Storage="_thumbnail", FieldType="Image")]
public Microsoft.SharePoint.Publishing.Fields.ImageFieldValue Thumbnail {
   get {
     return this._thumbnail;
   }
   set {
     if ((value != this._thumbnail)) {
         this.OnPropertyChanging("Thumbnail", this._thumbnail);
         this._thumbnail = value;
         this.OnPropertyChanged("Thumbnail");
     }
   }
}

Sans oublier de remplacer :

private object Thumbnail   (situé en haut de la classe)  par:

private Microsoft.SharePoint.Publishing.Fields.ImageFieldValue Thumbnail.

Et le tour est joué, vous aurez alors accès à toutes les propriétés du champ (l’url bien sûr, le texte alternatif, hyperlien, la description…).

C’est un gain de temps considérable, très facile à mettre en place pour générer les entités.

Cependant, vous vous rendrez très vite compte qu’en cas d’utilisation plus avancées, qu’il y a certaines limites à l’utilisation de cette méthode.

En effet,  si vous avez des colonnes avec des images, des métadonnées ou encore des champs html, ils seront complètement absents de votre fichier généré.

Le but de cet article est de vous montrer comment repérer les colonnes qui ne passeront pas lors de la génération.

Il y a certaines commandes SPMetal que nous pouvons spécifier dans un fichier XML, c’est ce fichier qui permet d’interagir sur la création des classes. Une de ses particularités est de pouvoir spécifier une “Column element”, c’est à dire de pouvoir forcer la génération d’une colonne de liste ou de type de contenu même si elles seraient invisibles lors d’une génération normale. La génération est telle que si certaines colonnes ne sont pas prises en compte, la génération les supprimes directement du fichier.

Voici un exemple pour forcer une colonne de type ImageFieldValue, qui n’est pas pris en compte lors d’une génération classique.

<?xml version="1.0" encoding="utf-8"?>
<Web xmlns="http://schemas.microsoft.com/SharePoint/2010/spmetal">
<ContentType Name="Contact">
<Column Name="col_Thumbnail" />
</ContentType></Web>

Et le résultat ainsi obtenu :

[Microsoft.SharePoint.Linq.ColumnAttribute(Name="col_Thumbnail", Storage="_thumbnail", FieldType="Invalid")]
public virtual object Thumbnail {
   get {
      return this._thumbnail;
   }
   set {
      if ((value != this._thumbnail)) {
            this.OnPropertyChanging("Thumbnail", this._thumbnail);
            this._thumbnail = value;
            this.OnPropertyChanged("Thumbnail");
      }
   }
}

Vous pouvez ainsi voir que le type n’est pas pris en compte.

Il vous suffira alors de changer les différents paramètres, le “FieldType”, le type de retour “object” afin de rendre la colonne fonctionnelle pour votre propre utilisation.

Nous verrons d’ailleurs par la suite, les différentes manières pour corriger ces limites de SPMetal pour chaque type de champ

Si vous lancez des requêtes sur des listes ou sur des bases de données par exemple, les temps de réponse peuvent être très longs, ce qui ralentira toute la page. Les temps de chargement seront de plus en plus longs pour l’utilisateur, puisqu’il faudra attendre la fin de tous les calculs pour que l’affichage apparaisse.

Si la WebPart n’est pas une des plus importantes, il y a une manière simple de la rendre asynchrone est ainsi nous pourrons charger la page très vite et avec un système de loading, faire apparaitre les données d’une WebPart plus gourmande quelques secondes après. L’utilisateur pourra alors parcourir la page tout en attendant que le dernier module se charge.

Il faut cependant savoir que le résultat de la callback, donc de l’événement, sera sous forme d’un “string”. Il faudra donc générer nous même le html afin de pouvoir afficher correctement des données. C’est le prix à payer pour pouvoir rentre votre WebPart asynchrone

Avec un peu plus de temps, nous pouvons réussir à réaliser ce que l’on souhaite.

Pour commencer, dans le code behind de votre WebPart, il faut override le Render afin d’afficher une image de chargement, le temps que la requête se fasse.

protected override void Render(HtmlTextWriter writer)
{
    // TODO: add custom rendering code here.
    this.datadiv = this.ClientID + "content";    writer.Write("<div id=\"" + this.datadiv + "\"><img src=\"_layouts/progressbar.GIF\" width\"300\"></div>");
}

Nous définissons là une nouveau div que nous allons créer, avec un nom unique pour éviter toutes confusions. Le plus simple est d’ajouter ensuite un GIF contenant une animation de chargement. Vous pouvez trouver votre bonheur ici : http://weblogs.asp.net/wkriebel/archive/2010/01/26/animated-gifs-in-sharepoint-2007-for-ajax-progress-indicators.aspx

Ce site vous invite également à aller voir dans votre dossier image de SharePoint pour aller récupérer l’animation qui vous convient le mieux

Une fois votre animation mise en place, il faut maintenant faire hériter votre WebPart avec :

public partial class VisualWebPart1UserControl : UserControl, ICallbackEventHandler

En effet l’interface de ICallbackEventHandler vous permet de rendre asynchrone la communication avec le serveur.

Il vous donne accès à 2 fonctions à implémenter :

public void RaiseCallbackEvent(string eventArgs)
{

    StringBuilder sb = new StringBuilder();
    SPSite mySite = SPContext.Current.Site;

    SPWebCollection subSites = mySite.AllWebs;
    this.data = mySite.Url.ToString() + "<BR>";
    for (int i = 0; i < subSites.Count; i++)
    {
        SPListCollection lists = subSites[i].Lists;

        for (int j = 0; j < lists.Count; j++)
        {
            sb.Append(subSites[i].Title + "--" + lists[j].Title + "<BR>");
            this.data = sb.ToString();
        }
    }
}

C’est votre fonction “lente” à exécuter, dans cette exemple. Je charge la liste de toutes les listes du site SharePoint, et je les affiche les unes à la suite des autres grâce au “<br>”

Un fois le calcul exécuté, la fonction :

public string GetCallbackResult()
{
    return this.data;
}

Vous renvoie le résultat.

Efficace et rapide à mettre en place.

Pour les plus curieux d’entre vous, les GridViews, DetailView… possèdent également une propriété ICallbackEventHandler. A vous d’aller plus loin pour l’utiliser avec ce genre de composant, une indice. Allez voir du côté d’IAsynResult !

A vous de jouer

Et vu que vous êtes bien sûr en mode debug (CutomError = off…) , vous avez un bel écran jaune comme on les aime !

La solution?

Facile, il suffit d’ajouter à votre adresse .aspx :  contents=1 en querystring.

Vous avez alors accès à un menu où vous pouvez enlever n’importe qu’elle webpart dans votre page.

C’est gagné !

C’est d’ailleurs tout simplement le menu que vous propose SharePoint dans la pop-up quand vous n’êtes pas en mode débug !

C’est à vous de jouer