Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

L’accès à des champs personnalisés d’entreprise Project Online

Office 2013 et versions ultérieures

Projet Online est un service Office 365 que les entreprises peuvent étendre pour répondre aux besoins de l’entreprise. Une zone d’extension est des champs personnalisés d’entreprise (ECFs). ECFs sont des champs de valeur typée qui peuvent être ajoutés à des projets, des ressources et des tâches. Le tableau suivant répertorie les ECFs qui s’associent à des projets, des ressources et des tâches et fournit un exemple d’une valeur d’une instance de ce ECF :

ECF nom

ECF Type

Association

Exemple de valeur

Justification

TEXT

Project

Un utilisateur final peut enregistrer des données de santé, avec des résultats qui incluent une évaluation d’intégrité et d’une action personnalisée et de statistiques essentielles plan vers une meilleure santé.

Niveau de risque

TEXT

Project

Low

RETOUR SUR INVESTISSEMENT

NUMÉRO DE

Project

2.10

Coût total

COÛT

Project

$1,031,514

Équipe de lancement

TEXT

Ressources

Oui

Rôle de position

TEXT

Ressources

Testeur

État de l’indicateur

INDICATEUR

Tâche

Non

Santé

TEXT

Tâche

Non spécifié

ECFs sont définis dans l’instance de projet Web Application (PWA), externe à partir de n’importe quel projet, une ressource ou une tâche. Pourtant, ils peuvent devenir associés à une tâche, une ressource ou un projet. Cet article présente une introduction à des champs personnalisés à l’aide d’un exemple d’application et met l’accent sur la récupération des valeurs ECF.

Vous pouvez télécharger l’exemple complet à https://github.com/OfficeDev/Project-CSOM-Read-Enterprise-CustomFields.

En outre, Project Online prend en charge les champs personnalisés locaux comme en lecture seule des entités spécifiques pour le projet spécifique, une ressource ou une tâche. Pour plus d’informations sur les champs personnalisés locaux, consultez l’exemple https://github.com/OfficeDev/Project-CSOM-Read-Local-CustomFields \.

Un article précédent, Développement d’une application de projet en ligne en utilisant le modèle d’objet côté client, fournit l’arrière-plan et l’orientation initiale pour le développement d’applications à l’aide de CSOM. Reportez-vous à cet article pour les éléments suivants :

  • Informations générales sur le projet, éditions autonomes et basé sur le nuage

  • Environnement de développement (éditions de Visual Studio et les bibliothèques de logiciels)

  • Programme d’installation de Visual Studio projet pour une application .NET à l’aide de la bibliothèque CSOM

  • Connexion au service en ligne de projet

La classe de cette application définit deux éléments de données : le contexte du projet et le dictionnaire pwaECF.

L’objet de contexte de projet fait partie de la CSOM de projet et connecte l’application et l’instance de PWA. Toutes les demandes au service utilisent le contexte de projet.

private static ProjectContext projContext = 
     new ProjectContext("https://Contoso216.sharepoint.com/sites/pwa");

Le contexte nécessite que le point de terminaison de connexion pour créer une instance d’une application. Le point de terminaison de connexion est l’URL de votre instance de PWA.

Le dictionnaire pwaECF stocke le projet ECFs définis au niveau de PWA. Le dictionnaire utilise l’ECF. InternalName en tant que la clé et de l’objet CustomField comme valeur. Le dictionnaire est rempli dans la méthode ListPWACustomFields et ensuite utilisé comme référence dans la méthode Main.

    //Dictionary of ECFs
        static Dictionary<String, CustomField> pwaECF = new Dictionary<string, CustomField>();

La méthode Main gère le flux de l’application. Comme avec d’autres applications qui utilisent la CSOM en ligne projet, principal initialise le contexte du projet.

  1. Extraire et les ECFs dans l’instance de PWA en ligne projet de la liste.

    Cette fonctionnalité est implémentée dans la méthode ListPWACustomFields.

  2. Récupérer les projets avec des champs personnalisés et non personnalisés.

    Lors de la récupération des projets avec ECFs, la requête au service en ligne de projet doit inclure les éléments suivants :

    • IncludeCustomFields : Cet élément demande le service pour renvoyer une collection de PublishedProjects où chaque projet publié contient une extension qui prend en charge les champs personnalisés. Sauf si cet élément est spécifié, Project Online retourne des objets PublishedProject qui n’incluent pas de données de champ personnalisé.

    • IncludeCustomFields.CustomFields : Cet élément demande le service pour remplir les objets PublishedProject avec les données CustomFields.

    La requête suivante spécifie l’Id de projet et nom, ainsi que l’extension de l’objet pour les champs personnalisés et les valeurs de champ personnalisé.

        var projBlk = projContext.LoadQuery(
        projContext.Projects.Include(
            p => p.Id, 
            p => p.Name,
            p => p.IncludeCustomFields,
            p => p.IncludeCustomFields.CustomFields
        ));
    
    
  3. Examinez chaque projet.

    Les objets du projet utilisés dans cette application sont le type PublishedProject, car les valeurs sont récupérées et affichées.

    Si vous devez mettre à jour les valeurs de données dans un ou plusieurs projets, le projet en cours de la mise à jour doit être extrait, puis l’application utiliserait un objet DraftProject pour récupérer les valeurs et mettre à jour le projet.

  4. Les entrées ECF pour un projet de l’accès à

    Chaque instance ECF sépare la valeur du champ à partir du reste des informations ECF. La valeur du champ est stockée en tant que partie d’une paire clé/valeur. Le reste des informations est stocké dans un objet CustomField.

    Accès aux valeurs ECF dans un projet se compose de deux parties :

    • Parcourir la collection CustomFields

    • L’accès à l’entrée appropriée à l’aide de deux constructions.

    Chaque projet stocke les entrées ECF associées à deux endroits, CustomFields collection énumérable et et les valeurs de champ en tant que partie de paires clé/valeur. Dans les paires clé/valeur, internalName est la clé et la valeur du champ est la valeur. Utiliser un dictionnaire pour stocker et accéder aux valeurs de champ.

    Les propriétés ECF, autres que les valeurs de champ sont stockées dans des objets CustomField, un seul objet par projet. Utilisez la collection CustomFields pour accéder aux ECFs associés à un projet individuel.

  5. Chaque projet stocke les ECFs associés à une collection dans laquelle chaque entrée ECF se compose d’une clé, le nom interne de l’ECF--et un objet qui conserve la valeur de l’ECF. Transfert de la collection à un dictionnaire pour accéder aux entrées individuelles. La déclaration est la suivante.

    Dictionary<string, object> projDict = pubProj.IncludeCustomFields.FieldValues;
    
    

    La valeur dans une entrée de dictionnaire correspond au type de données de l’ECF. L’objet de chaque ECF correspond à l’un des divers types de. La plupart des ECFs utilisent les types simples qui s’intègrent aux variables standard. Le fragment suivant montre que le traitement minimal est impliqué pour plusieurs types :

    switch (cf.FieldType)
    {
        case CustomFieldType.COST:
            decimal costValue = (decimal)oVal;
            Console.WriteLine("\tFieldType:\t{0}\n\tValue:\t{1}", cf.FieldType, 
                costValue.ToString("C"));
            break;
        case CustomFieldType.DATE:
            Console.WriteLine("\tFieldType:\t{0}\n\tValue:\t{1}", cf.FieldType, 
                oVal.ToString());
            break;
        case CustomFieldType.FINISHDATE:
            Console.WriteLine("\tFieldType:\t{0}\n\tValue:\t{1}", cf.FieldType, 
                oVal.ToString());
            break;
        case CustomFieldType.DURATION:
            Console.WriteLine("\tFieldType:\t{0}\n\tValue:\t{1}", cf.FieldType, 
                oVal.ToString());
            break;
        case CustomFieldType.FLAG:
            Console.WriteLine("\tFieldType:\t{0}\n\tValue:\t{1}", cf.FieldType, 
                oVal.ToString());
            break;
        case CustomFieldType.NUMBER:
            Console.WriteLine("\tFieldType:\t{0}\n\tValue:\t{1}", cf.FieldType, 
                oVal.ToString());
            break;
    
    

    La table de choix de valeurs de TEXTE, toutefois, requiert un traitement supplémentaire. L’application extrait de la table de choix approprié à partir du service et renvoie l’instance ECF (avec des valeurs simples ou multiples) en parcourant la table de choix. Le fragment de code suivant illustre le traitement de TEXTE ECFs, y compris ceux avec des valeurs simples et celles utilisant des tables de recherche :

    case CustomFieldType.TEXT:
        if (!cf.LookupTable.ServerObjectIsNull.HasValue ||
            (cf.LookupTable.ServerObjectIsNull.HasValue && 
             cf.LookupTable.ServerObjectIsNull.Value))
        { //No lookup table
    
            Console.WriteLine("\tFieldType:\t{0}\n\tText:\t{1}", cf.FieldType, 
                oVal.ToString());
        }
        else
        { //Lookup table
    
            Console.WriteLine("\tFieldType:\t{0} - using Lookup Table", cf.FieldType);
            String[] entries = (String[])oVal;
    
            foreach (String entry in entries)
            {
                var luEntry = projContext.LoadQuery(cf.LookupTable.Entries
                    .Where(e => e.InternalName == entry));
                projContext.ExecuteQuery();
    
                Console.WriteLine("\tLookup Value:\t{0}", luEntry.First().FullValue);  
            }
        }
        break;
    
    

    Cette application renvoie simplement la valeur (s) ; Toutefois, il est possible d’obtenir davantage de signification de la valeur (s) de données.

La méthode ListPWACustomFields récupère et répertorie les ECFs associés aux projets. Cette méthode répertorie les ECFs inscrits sur l’instance de PWA qui peut être associé à des projets individuels. Le point d’entrée permettant d’accéder à l’ECFs utilise l’élément CustomFields du contexte du projet, comme dans la requête suivante :

// Project ECFs
    var allECFields = 
            projContext.LoadQuery(projContext.CustomFields.Include(
            qp => qp.InternalName,
            qp => qp.Name
        ));
    projContext.ExecuteQuery();

La méthode ne vérifie pas si un projet utilise un ECF spécifique.

Afficher: