Créer et supprimer des messages et de récupérer le flux de mise en réseau à l'aide du modèle objet de client .NET dans SharePoint

Découvrez comment créer et supprimer des publications de microblog et récupérer des flux sociaux à l'aide du modèle d'objet client .NET SharePoint.

Que sont les flux sociaux dans SharePoint ?

Dans SharePoint, un flux social est une collection de threads qui représentent des conversations, des publications de microblog uniques ou des notifications. Les threads contiennent une publication racine et une collection de publications de réponse, et elles représentent des conversations, billets de microblog unique ou les notifications. Dans le modèle objet client .NET, les flux sont représentés par des objets SocialFeed , les threads sont représentés par des objets SocialThread et les publications et les réponses sont représentées par des objets SocialPost . Pour effectuer des tâches liées au flux de base dans le modèle d'objet client .NET, vous utilisez l'objet SocialFeedManager . Dans cet article, nous allons vous montrer comment créer une application console qui utilise le modèle d'objet client .NET pour travailler avec des flux sociaux.

Pour plus d’informations sur l’utilisation de SocialFeedManager ou sur l’utilisation d’autres API pour utiliser des flux sociaux, voir Utiliser des flux sociaux dans SharePoint.

Conditions préalables à la configuration de votre environnement de développement pour qu’il fonctionne avec des flux sociaux à l’aide du modèle objet client .NET SharePoint

Pour créer une application console qui utilise le modèle d'objet client .NET pour travailler avec des flux sociaux, vous aurez besoin :

• SharePoint avec Mon site configuré, avec des sites personnels créés pour l’utilisateur actuel et un utilisateur cible, avec l’utilisateur actuel suivant l’utilisateur cible et avec quelques billets écrits par l’utilisateur cible

• Visual Studio 2012

• Autorisations d'accès Contrôle total à l'application de service de profil utilisateur pour l'utilisateur connecté

Créer une application console qui fonctionne avec les flux sociaux à l’aide du modèle objet client .NET SharePoint

1. Ouvrez Visual Studio et choisissez Fichier, Nouveau, Projet.

2. Dans la boîte de dialogue Nouveau projet, sélectionnez .NET Framework 4.5 dans la liste déroulante située en haut de la boîte de dialogue.

3. Dans la liste des modèles, choisissez fenêtres, puis choisissez le modèle Application Console.

4. Nommez le projet SocialFeedCSOM, puis cliquez sur le bouton OK.

5. Ajoutez des références aux assemblies suivants :

   • Microsoft.SharePoint.Client
   • Microsoft.SharePoint.ClientRuntime
   • Microsoft.SharePoint.Client.UserProfiles

6. Remplacez le contenu de la classe Program avec l'exemple de code à partir d'un des scénarios suivants :

   • Publier les billets et réponses au flux RSS pour la mise en réseau
   • Récupérer les flux sociaux
   • Supprimer des publications et des réponses à partir du flux sociaux

7. Pour tester l'application de console, dans la barre de menus, choisissez Déboguer, Démarrer le débogage.

Exemple de code : Publier des publications et des réponses au flux social à l’aide du modèle objet client .NET SharePoint

L'exemple de code suivant publie un billet et une réponse de l'utilisateur actuel. Il montre comment :

• Définissez valider le contenu. Cet exemple inclut un lien dans le billet de blog.

• Publiez une publication dans le flux de l’utilisateur actuel en utilisant la méthode CreatePost et en passant la valeur null comme paramètre targetId .

• Obtenez le type de fluxd’actualités de l’utilisateur actuel à l’aide de la méthode GetFeed.

• Parcourir le flux pour rechercher tous les threads qui peuvent être une réponse et pour obtenir des informations sur les threads et publications.

• Répondez à un billet en utilisant la méthode CreatePost et en transmettant l’identificateur de thread comme paramètre targetId .

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.SharePoint.Client;
using Microsoft.SharePoint.Client.Social;

namespace SocialFeedCSOM
{
    class Program
    {
        static void Main(string[] args)
        {
            // Replace the following placeholder value with the target server URL.
            const string serverUrl = "http://serverName/";

            Console.Write("Type your post text:  ");

            // Create a link to include in the post.
            SocialDataItem linkDataItem = new SocialDataItem();
            linkDataItem.ItemType = SocialDataItemType.Link;
            linkDataItem.Text = "link";
            linkDataItem.Uri = "http://bing.com";

            // Define properties for the post.
            SocialPostCreationData postCreationData = new SocialPostCreationData();
            postCreationData.ContentText = Console.ReadLine() + " Plus a {0}.";
            postCreationData.ContentItems = new SocialDataItem[1] { linkDataItem };

            // Get the client context.
            ClientContext clientContext = new ClientContext(serverUrl);

            // Get the SocialFeedManager instance.
            SocialFeedManager feedManager = new SocialFeedManager(clientContext);

            // Publish the post. This is a root post, so specify null for the
            // targetId parameter. 
            feedManager.CreatePost(null, postCreationData); 
            clientContext.ExecuteQuery();

            Console.WriteLine("\\nCurrent user's newsfeed:");

            // Set parameters for the feed content that you want to retrieve.
            SocialFeedOptions feedOptions = new SocialFeedOptions();

            // Get the target owner's feed and then run the request on the server.
            ClientResult<SocialFeed> feed = feedManager.GetFeed(SocialFeedType.News, feedOptions);
            clientContext.ExecuteQuery();

            // Create a dictionary to store the Id property of each thread. This 
            // code example stores the Id so you can select a thread to reply to.
            Dictionary<int, string> idDictionary = new Dictionary<int, string>();

            // Iterate through each thread in the feed.
            for (int i = 0; i < feed.Value.Threads.Length; i++)
            {
                SocialThread thread = feed.Value.Threads[i];

                // Keep only the threads that can be replied to.
                if (thread.Attributes.HasFlag(SocialThreadAttributes.CanReply))
                {
                    idDictionary.Add(i, thread.Id);

                    // Get properties from the root post and thread.
                    // If a thread contains more than two replies, the server returns
                    // a thread digest that contains only the two most recent replies.
                    // To get all replies, call SocialFeedManager.GetFullThread.
                    SocialPost rootPost = thread.RootPost;
                    SocialActor author = thread.Actors[rootPost.AuthorIndex];
                    Console.WriteLine(string.Format("{0}. {1} said \\"{2}\\" ({3} replies)",
                        (i + 1), author.Name, rootPost.Text, thread.TotalReplyCount));
                }
            }
            Console.Write("\\nWhich thread number do you want to reply to?  ");

            string threadToReplyTo = "";
            int threadNumber = int.Parse(Console.ReadLine()) - 1;
            idDictionary.TryGetValue(threadNumber, out threadToReplyTo);

            Console.Write("Type your reply:  ");

            // Define properties for the reply. This example reuses the 
            // SocialPostCreationData object that was used to create a post.
            postCreationData.ContentText = Console.ReadLine();

            // Publish the reply and make the changes on the server.
            ClientResult<SocialThread> result = feedManager.CreatePost(threadToReplyTo, postCreationData);
            clientContext.ExecuteQuery();

            Console.WriteLine("\\nThe reply was published. The thread now has {0} replies.", result.Value.TotalReplyCount);
            Console.ReadLine();
         }
    }
}

Exemple de code : Récupérer des flux sociaux à l’aide du modèle objet client .NET SharePoint

L'exemple de code suivant récupère un flux pour l'utilisateur actuel et un utilisateur cible. Il montre comment :

• Obtenez les types de fluxPersonnel, Actualités et Chronologie pour l’utilisateur actuel à l’aide de la méthode GetFeed.

• Obtenez le type de fluxPersonnel pour un utilisateur cible à l’aide de la méthode GetFeedFor.

• Itération dans les flux pour rechercher tous les threads non référence et pour obtenir des informations sur les threads et publications. Threads de référence représentent des notifications qui contiennent des informations sur un autre thread. Par exemple, si un utilisateur mentionne une personne dans un billet de blog, le serveur génère un MentionReference-tapez thread qui contient le lien vers le billet d'origine et autres métadonnées relatives à la publication.

Pour plus d’informations sur les types de flux, consultez Vue d’ensemble des types de flux. Pour plus d’informations sur les threads de référence, voir Threads de référence et threads de synthèse dans les flux sociaux SharePoint.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.SharePoint.Client;
using Microsoft.SharePoint.Client.Social;

namespace SocialFeedCSOM
{
    class Program
    {
        static string owner;
        static void Main(string[] args)
        {

            // Replace the following placeholder values with the target
            // server URL and target thread owner.
            const string serverUrl = "http://serverName/";
            const string targetUser = "domainName\\\\userName";

            // Get the client context.
            ClientContext clientContext = new ClientContext(serverUrl);

            // Get the SocialFeedManager instance. 
            // Load the instance to get the Owner property.
            SocialFeedManager feedManager = new SocialFeedManager(clientContext);
            clientContext.Load(feedManager, f => f.Owner);

            // Set parameters for the feed content that you want to retrieve.
            SocialFeedOptions feedOptions = new SocialFeedOptions();
            feedOptions.MaxThreadCount = 10; // default is 20

            // Get all feed types for current user and get the Personal feed
            // for the target user.
            ClientResult<SocialFeed> personalFeed = feedManager.GetFeed(SocialFeedType.Personal, feedOptions);
            ClientResult<SocialFeed> newsFeed = feedManager.GetFeed(SocialFeedType.News, feedOptions);
            ClientResult<SocialFeed> targetUserFeed = feedManager.GetFeedFor(targetUser, feedOptions);

            // Change the sort order to optimize the Timeline feed results.
            feedOptions.SortOrder = SocialFeedSortOrder.ByCreatedTime;
            ClientResult<SocialFeed> timelineFeed = feedManager.GetFeed(SocialFeedType.Timeline, feedOptions);

            // Run the request on the server.
            clientContext.ExecuteQuery();

            // Get the name of the current user within this instance.
            owner = feedManager.Owner.Name;

            // Iterate through the feeds and write the content.
            IterateThroughFeed(personalFeed.Value, SocialFeedType.Personal, true);
            IterateThroughFeed(newsFeed.Value, SocialFeedType.News, true);
            IterateThroughFeed(timelineFeed.Value, SocialFeedType.Timeline, true);
            IterateThroughFeed(targetUserFeed.Value, SocialFeedType.Personal, false);

            Console.ReadKey(false);
        }

        // Iterate through the feed and write to the console window.
        static void IterateThroughFeed(SocialFeed feed, SocialFeedType feedType, bool isCurrentUserOwner)
        {
            SocialThread[] threads = feed.Threads;

            // If this is the target user's feed, get the user's name.
            // A user is the owner of all threads in his or her Personal feed.
            if (!isCurrentUserOwner)
            {
                SocialThread firstThread = threads[0];
                owner = firstThread.Actors[firstThread.OwnerIndex].Name;
            }
            Console.WriteLine(string.Format("\\n{0} feed type for {1}:", feedType.ToString(), owner));

            // Iterate through each thread in the feed.
            foreach (SocialThread thread in threads)
            {

                // Ignore reference thread types.
                if (thread.ThreadType == SocialThreadType.Normal)
                {

                    // Get properties from the root post and thread. 
                    // If a thread contains more than two replies, the server returns
                    // a thread digest that contains only the two most recent replies.
                    // To get all replies, call SocialFeedManager.GetFullThread.
                    SocialPost rootPost = thread.RootPost;
                    SocialActor author = thread.Actors[rootPost.AuthorIndex];
                    Console.WriteLine(string.Format("  - {0} posted \\"{1}\\" on {2}. This thread has {3} replies.",
                        author.Name, rootPost.Text, rootPost.CreatedTime.ToShortDateString(), thread.TotalReplyCount));
                }
            }
        }
    }
}

Exemple de code : Supprimer des publications et des réponses du flux social à l’aide du modèle objet client .NET SharePoint

L'exemple de code suivant supprime une publication ou une réponse de flux de personnel de l'utilisateur actuel. Il montre comment :

• Obtenez le type de fluxPersonnel de l’utilisateur actuel à l’aide de la méthode GetFeed.

• Itérer les threads dans le flux pour obtenir des informations sur la publication de la racine et les réponses.

• Supprimez un billet, une réponse ou un thread racine à l’aide de la méthode DeletePost (la suppression d’un billet racine supprime le thread entier).

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.SharePoint.Client;
using Microsoft.SharePoint.Client.Social;

namespace SocialFeedCSOM
{
    class Program
    {
        static void Main(string[] args)
        {

            // Replace the following placeholder value with the target SharePoint server.
            const string serverUrl = "http://serverName/";

            // Get the client context.
            ClientContext clientContext = new ClientContext(serverUrl);

            // Get the SocialFeedManager instance.
            SocialFeedManager feedManager = new SocialFeedManager(clientContext);

            Console.WriteLine("\\nCurrent user's personal feed:");

            // Set the parameters for the feed content that you want to retrieve.
            SocialFeedOptions feedOptions = new SocialFeedOptions();

            // Get the target owner's feed (posts and activities) and
            // then run the request on the server.
            ClientResult<SocialFeed> feed = feedManager.GetFeed(SocialFeedType.Personal, feedOptions);
            clientContext.ExecuteQuery();

            // Create a dictionary to store the Id property of each post and
            // reply. This code example stores the Id so you can select a post
            // or a reply to delete.
            Dictionary<int, string> idDictionary = new Dictionary<int, string>();

            // Iterate through each thread in the feed.
            for (int i = 0; i < feed.Value.Threads.Length; i++)
            {
                SocialThread thread = feed.Value.Threads[i];
                SocialPost rootPost = thread.RootPost;

                // Only keep posts that can be deleted.
                if (rootPost.Attributes.HasFlag(SocialPostAttributes.CanDelete)) 
                {
                    idDictionary.Add(i, rootPost.Id);

                    Console.WriteLine(string.Format("{0}. \\"{1}\\" has {2} replies.",
                        (i + 1), rootPost.Text, thread.TotalReplyCount));

                    // Get the replies.
                    // If a thread contains more than two replies, the server returns
                    // a thread digest that contains only the two most recent replies.
                    // To get all replies, call SocialFeedManager.GetFullThread.
                    if (thread.TotalReplyCount > 0)
                    {
                        foreach (SocialPost reply in thread.Replies)
                        {

                            // Only keep replies that can be deleted.
                            if (reply.Attributes.HasFlag(SocialPostAttributes.CanDelete)) 
                            {
                                i++;
                                idDictionary.Add(i, reply.Id);

                                SocialActor author = thread.Actors[reply.AuthorIndex];
                                Console.WriteLine(string.Format("\\t{0}. {1} replied \\"{2}\\"",
                                    (i + 1), author.Name, reply.Text));
                            }
                        }
                    }
                }
            }
            Console.Write("\\nEnter the number of the post or reply to delete. "
                + "(If you choose a root post, the whole thread is deleted.)");
            string postToDelete = "";
            int postNumber = int.Parse(Console.ReadLine()) - 1;
            idDictionary.TryGetValue(postNumber, out postToDelete);

            // Delete the reply and make the changes on the server.
            ClientResult<SocialThread> result = feedManager.DeletePost(postToDelete);
            clientContext.ExecuteQuery();

            // DeletePost returns digest thread if the deleted post is not the
            // root post. If it is the root post, the whole thread is deleted
            // and DeletePost returns null.
            if (result.Value != null)
            {
                SocialThread threadResult = result.Value;
                Console.WriteLine("\\nThe reply was deleted. The thread now has {0} replies.", threadResult.TotalReplyCount);
            }
            else
            {
                Console.WriteLine("\\nThe post and thread were deleted.");
            }
            Console.ReadKey(false);
        }
    }
}

Étapes suivantes

Comment inclure des mentions, des balises et des liens vers des sites et des documents dans des publications dans SharePoint

Voir aussi

• Utiliser des flux sociaux dans SharePoint

• Comment : créer et supprimer des publications et récupérer le flux social en utilisant le modèle d'objet JavaScript dans SharePoint

• Comment : en savoir plus lire et écrire dans le flux social en utilisant le service reste dans SharePoint

• Threads de référence et threads de synthèse dans les flux sociaux SharePoint