Créer des applications mobiles pour d’autres plateformes avec SharePoint

Découvrez comment utiliser le style REST (Representational State Transfer) pour créer une application mobile SharePoint pour n’importe quelle plateforme.

Les appareils mobiles sont devenues aujourd'hui plus puissants et faciles à utiliser. Les ordinateurs portables, netbooks, tablet PC et téléphones mobiles fournissent des travailleurs de l'accès aux informations et aux applications dont ils ont besoin pour effectuer leurs tâches. Et développement d'applications pour les appareils mobiles est désormais plus facile que jamais. Par conséquent, plusieurs et plusieurs scénarios d'entreprise exigent des applications clientes intégrés à leurs processus métier. Cet article décrit l’intégration des applications clientes mobiles à SharePoint. Vous pouvez créer une application mobile pour parcourir le contenu SharePoint à partir de n’importe quel emplacement et vous connecter à des listes et bibliothèques SharePoint pour accéder à des données.

Pour développer une application mobile qui interagit avec SharePoint, vous pouvez utiliser les services courants accessibles à l’aide des protocoles ouverts. SharePoint Foundation 2010 introduit les modèles d'objet client, qui a permis aux développeurs d'effectuer une communication à distance avec SharePoint à l'aide de la technologie de leur choix de programmation pour le web : .NET Framework, Microsoft Silverlight ou JavaScript. SharePoint inclut un service REST (Representational State Transfer) comparable aux modèles objet client. Dans SharePoint, presque toutes les API dans les modèles objet client auront un point de terminaison REST correspondant. Désormais, les développeurs peuvent interagir à distance avec le modèle d'objet SharePoint à l'aide de toute technologie prenant en charge les requêtes web REST. REST pouvant être consommé par n'importe quel langage de programmation que vous souhaitez utiliser pour votre développement d'applications mobiles. Vous pouvez effectuer des opérations CRUD (création, lecture, mise à jour et suppression) de base à l’aide de l’interface REST fournie par SharePoint. REST expose toutes les entités et opérations SharePoint disponibles dans les autres API du client SharePoint. L’un des avantages de REST est que vous n’avez pas à ajouter de références à des assemblys de client ou des bibliothèques SharePoint. Vous envoyez des requêtes HTTP aux points de terminaison appropriés afin de récupérer ou de mettre à jour des entités SharePoint, telles que les sites web, les listes et les éléments de liste. Pour consulter une présentation détaillée de l’interface REST de SharePoint et de son architecture, voir Utiliser les opérations de requête OData dans les demandes REST SharePoint.

Points de terminaison REST dans SharePoint

Pour utiliser les fonctionnalités REST intégrées à SharePoint, vous pouvez élaborer une requête HTTP RESTful à l'aide du protocole OData standard qui correspond à l'API du modèle objet client souhaitée. Le service web client.svc traite la requête HTTP et fournit la réponse appropriée, au format Atom ou JavaScript Object Notation (JSON). L'application cliente doit ensuite analyser cette réponse. La figure 1 présente une vue d'ensemble de l'architecture REST SharePoint.

La figure 1. Architecture REST SharePoint

Architecture REST SharePoint

Les points de terminaison dans le service REST SharePoint correspondent aux types et membres dans les modèles d'objet client SharePoint. À l'aide de requêtes HTTP, vous pouvez utiliser ces points de terminaison REST pour effectuer des opérations CRUD standard par rapport à des artefacts de SharePoint, tels que des listes et des sites.

En général :

  • Mapper les points de terminaison qui représentent des opérations de lecture pour des commandes HTTP GET.

  • Points de terminaison qui représentent la carte des opérations de mise à jour pour des commandes HTTP POST.

  • Points de terminaison qui représentent la mise à jour ou insérer la carte des opérations pour les commandes HTTP PUT.

Lors du choix d'une demande HTTP à utiliser, vous devez également tenir compte des suivantes :

  • POST permet de créer des artefacts de listes et des sites. Le service REST SharePoint prend en charge l’envoi de commandes POST qui incluent les définitions d’objet vers les points de terminaison qui représentent des collections.

  • Pour les opérations de POST, toutes les propriétés qui ne sont pas requises sont définies à leurs valeurs par défaut. Si vous tentez de définir une propriété en lecture seule dans le cadre d'une opération de POST, le service renvoie une exception.

  • Utilisez les opérations PUT, PATCH et MERGE pour mettre à jour des objets SharePoint existants. N'importe quel point de terminaison de service qui représente une opération de set de propriété objet prend en charge les demandes de PUT et MERGE. Pour les demandes de MERGE, la définition de propriétés est facultative ; toutes les propriétés que vous ne définissez pas explicitement conservent leur valeur en cours. Mais pour les commandes de PUT, les propriétés que vous ne définissez pas explicitement sont définies avec leurs propriétés par défaut. En outre, si vous ne spécifiez pas de toutes les propriétés définies dans les mises à jour de l'objet lorsque vous utilisez les commandes HTTP PUT, le service REST renvoie une exception.

  • Utilisez la commande HTTP DELETE sur l'URL spécifique du point de terminaison pour supprimer l'objet SharePoint représenté par ce point de terminaison. Pour les objets recyclables, tels que des listes, des fichiers et des éléments de liste, cela entraîne une opération Recycle. Pour plus d’informations, voir Découverte du service REST SharePoint.

Authentifier les utilisateurs auprès de SharePoint

Pour authentifier votre application mobile avec SharePoint, vous pouvez utiliser le protocole MS-OFBA. Pour plus d'informations, consultez la rubrique [MS-OFBA]: spécification du protocole d'authentification basé formulaires Office. Le client de protocole est configuré pour stocker et transmettre des cookies. Le client de protocole s'appuie sur le serveur de protocole distant pour définir l'identité de l'utilisateur en tant qu'un ou plusieurs des cookies HTTP. Une fois l'identité de l'utilisateur est établie, le client envoie ensuite chaque cookie avec chaque demande HHT ultérieur.

Lorsqu’un utilisateur se connecte à SharePoint, son jeton est validé, puis utilisé pour le connecter à SharePoint. Ce jeton de sécurité est émis par un fournisseur d’identité. SharePoint prend en charge différents types d’authentification. Pour plus d’informations, voir Authentification, autorisation et sécurité dans SharePoint. Pour authentifier un utilisateur, vous pouvez utiliser l’interface REST. Le processus d’autorisation vérifie qu’un sujet authentifié (application ou utilisateur au nom duquel l’application agit) est autorisé à effectuer certaines opérations ou à accéder à des ressources spécifiques (par exemple, liste ou dossier de documents SharePoint).

OData vous permet d'accéder à une source de données, par exemple une base de données, en accédant à une URL spécialement créée. Cela permet une approche simplifiée de la connexion à et l'utilisation de sources de données qui sont hébergés au sein d'une organisation. OData est un protocole qui utilise HTTP, Atom et JavaScript Object Notation (JSON) pour permettre aux développeurs d'écrire des applications qui communiquent avec un nombre croissant de sources de données. Microsoft prend en charge la création de ce standard comme moyen pour permettre l'échange de données entre les applications et les magasins de données qui sont accessibles à partir du site web. Le nouveau connecteur OData permet de communiquer avec des fournisseurs OData de SharePoint. Pour plus d'informations, voir Open Data Protocol.

Le code suivant montre comment authentifier votre application auprès de SharePoint à l’aide de points de terminaison REST pour l’authentification de base ou basée sur les formulaires. L'exemple de code suivant est écrit en c#, mais n'importe quel autre langage de programmation peut être utilisé pour créer la demande Http, conformément à la spécification de la plateforme.


string SharePointUrl = "https://Target SharePoint site";

private void AuthenticateToSharePoint(object sender, RoutedEventArgs e)
{
    ODataAuthenticator odataAt = new ODataAuthenticator("<Username>", "<password>");
    odataAt.CookieCachingEnabled = true;
    odataAt.AuthenticationCompleted += new EventHandler<AuthenticationCompletedEventArgs>(odataAt_AuthenticationCompleted);
    odataAt.Authenticate(new Uri(SharePointUrl, UriKind.Absolute));
}

void odataAt_AuthenticationCompleted(object sender, AuthenticationCompletedEventArgs e)
{
    HttpWebRequest endpointRequest = (HttpWebRequest)HttpWebRequest.Create(SharePointUrl.ToString() + "/_api/web/lists");
    endpointRequest.Method = "GET";
    endpointRequest.Accept = "application/json;odata=verbose";
          endpointRequest.CookieContainer = (sender as ODataAuthenticator).CookieContainer;

    endpointRequest.BeginGetResponse(new AsyncCallback((IAsyncResult res) =>
    {
        HttpWebRequest webReq = res.AsyncState as HttpWebRequest;
        WebResponse response = webReq.EndGetResponse(res);

        HttpWebResponse httpResponse = response as HttpWebResponse;
        HttpStatusCode code = httpResponse.StatusCode;
        this.Dispatcher.BeginInvoke(() =>
        {
            MessageBox.Show(code.ToString());
        });
    }), endpointRequest);
}

Pour authentifier une HttpWebrequest au point de terminaison, vous devez d'abord s'authentifier sur SharePoint avec la classe ODataAuthenticator. Avant d'appeler la méthode Authenticate, enregistrez l'objet ODataAuthenticator à l'événement AuthenticationCompleted.

Une fois que l'authentification est effectuée à l'intérieur de l'événement OnAuthenticationCompleted, vous pouvez utiliser la propriété CookieContainer sur l'objet ODataAuthenticator, qui peut être associée à l'objet HttpWebRequest pour authentifier les appels REST pour SharePoint.

Utiliser des éléments de liste SharePoint avec REST

L’exemple suivant montre comment récupérer tous les éléments d’une liste.


url: http://site url/_api/web/lists/GetByTitle('Test')/items
method: GET
headers:
// MS-OFBA protocol returns a cookie.
  Cookie: cookie


    accept: "application/json;odata=verbose" or "application/atom+xml"

L’exemple suivant montre comment récupérer un élément de liste spécifique.


url: http://site url/_api/web/lists/GetByTitle('Test')/items(item id)
method: GET
headers:

// MS-OFBA protocol return a cookie.
  Cookie: cookie
    accept: "application/json;odata=verbose" or "application/atom+xml"

Le code XML ci-après donne un exemple des propriétés d’élément de liste qui sont renvoyées lorsque vous demandez le type de contenu XML.


<content type="application/xml">
        <m:properties>
        <d:FileSystemObjectType m:type="Edm.Int32">0</d:FileSystemObjectType>
        <d:Id m:type="Edm.Int32">1</d:Id>
        <d:ID m:type="Edm.Int32">1</d:ID>
        <d:ContentTypeId>0x010049564F321A0F0543BA8C6303316C8C0F</d:ContentTypeId>
        <d:Title>an item</d:Title>
        <d:Modified m:type="Edm.DateTime">2012-07-24T22:47:26Z</d:Modified>
        <d:Created m:type="Edm.DateTime">2012-07-24T22:47:26Z</d:Created>
        <d:AuthorId m:type="Edm.Int32">11</d:AuthorId>
        <d:EditorId m:type="Edm.Int32">11</d:EditorId>
        <d:OData__UIVersionString>1.0</d:OData__UIVersionString>
        <d:Attachments m:type="Edm.Boolean">false</d:Attachments>
        <d:GUID m:type="Edm.Guid">eb6850c5-9a30-4636-b282-234eda8b1057</d:GUID>
    </m:properties>
</content>

L'exemple ci-après montre comment créer un élément de liste.

Notes

Pour effectuer cette opération, vous devez connaître la propriété ListItemEntityTypeFullName de la liste et la transmettre comme valeur de type dans le corps de la requête HTTP.


url: http://site url/_api/web/lists/GetByTitle('Test')/items
method: POST
body: { '__metadata': { 'type': 'SP.Data.TestListItem' }, 'Title': 'Test'}
headers:

// MS-OFBA protocol returns a cookie.
  Cookie: cookie
     X-RequestDigest = form digest value
    accept: "application/json;odata=verbose"
    content-type: "application/json;odata=verbose"
    content-length:length of post body

L'exemple ci-après montre comment mettre à jour un élément de liste.

Notes

Pour effectuer cette opération, vous devez connaître la propriété ListItemEntityTypeFullName de la liste et la transmettre comme valeur de type dans le corps de la requête HTTP.


url: http://site url/_api/web/lists/GetByTitle('Test')/items(item id)
method: POST
body: { '__metadata': { 'type': 'SP.Data.TestListItem' }, 'Title': 'TestUpdated'}
headers:
// MS-OFBA protocol returns a cookie.
  Cookie: cookie
     X-RequestDigest = form digest value
    "IF-MATCH": etag or "*"
    "X-HTTP-Method":"MERGE",
    accept: "application/json;odata=verbose"
    content-type: "application/json;odata=verbose"
    content-length:length of post body

L’exemple suivant montre comment supprimer un élément de liste.


url: http://site url/_api/web/lists/GetByTitle('Test')/items(item id)
method: POST
headers:
// MS-OFBA protocol returns a cookie.
  Cookie: cookie
     X-RequestDigest = form digest value
    "IF-MATCH": etag or "*"
    "X-HTTP-Method":"DELETE"

Pour plus d’informations, voir Effectuer des opérations de base à l’aide de points de terminaison REST SharePoint.

Voir aussi