CaliberRM SDK Programmer's Guide

CaliberRM™

Guide du programmeur SDK

Les applications mentionnées dans ce manuel sont brevetées par Borland Software Corporation ouen attente de brevet. Ce document ne donne aucun droit sur ces brevets.

Copyright © 1997–2008 Borland Software Corporation et/ou ses filiales. Tous les noms de marqueset de produits Borland sont des marques de fabrique ou des marques déposées de BorlandSoftware Corporation aux Etats-Unis et dans d’autres pays. Toutes les autres marquesappartiennent à leurs propriétaires respectifs.

CRM06-SDKPG

Février 2008

i

Table des matières

Chapitre 1Introduction 1

Chapitre 2Utilisation de Visual Basic pour écrire des applications SDK 3

Introduction . . . . . . . . . . . . . . . . . . . . . . 3Configuration de votre EDI . . . . . . . . . . . . . . 3Initialisation de la bibliothèque CaliberRM . . . . . . 4Connexion à un serveur CaliberRM. . . . . . . . . . 5Utilisation de sessions . . . . . . . . . . . . . . . . 6Création d’objets CaliberRM . . . . . . . . . . . . . 7Modification d’objets CaliberRM . . . . . . . . . . . 7Suppression d’objets CaliberRM . . . . . . . . . . . 8Exigences . . . . . . . . . . . . . . . . . . . . . . . 8

Création d’exigences . . . . . . . . . . . . . . . 8Attributs et valeurs d’attributs . . . . . . . . . . . 9Valeurs d’attributs de listes . . . . . . . . . . . . 11Définition de valeurs d’attributs . . . . . . . . . . 13Descriptions des exigences . . . . . . . . . . . . 14Références de document . . . . . . . . . . . . . 15Responsabilités . . . . . . . . . . . . . . . . . . 16Historique . . . . . . . . . . . . . . . . . . . . . 17Discussions . . . . . . . . . . . . . . . . . . . . 19Arborescences d’exigences . . . . . . . . . . . . 20

Traçabilité . . . . . . . . . . . . . . . . . . . . . . . 23Obtention des traces. . . . . . . . . . . . . . . . 24Création de traces entre exigences . . . . . . . . 25Création de traces vers des artefacts logiciels

qui ne sont pas des exigences . . . . . . . . . . 25Suppression de traces . . . . . . . . . . . . . . . 26

Chapitre 3Utilisation de Java pour écrire des applications SDK 27

Introduction . . . . . . . . . . . . . . . . . . . . . . 27Création d’un CaliberServer . . . . . . . . . . . . . 27Utilisation de sessions . . . . . . . . . . . . . . . . 29Conventions du SDK Java CaliberRM . . . . . . . . 29Création d’objets CaliberRM . . . . . . . . . . . . . 30Modification d’objets CaliberRM . . . . . . . . . . . 30Suppression d’objets CaliberRM . . . . . . . . . . . 31Exigences . . . . . . . . . . . . . . . . . . . . . . . 31

Arborescences d’exigences . . . . . . . . . . . . 31Création d’exigences . . . . . . . . . . . . . . . 35Attributs d’exigences. . . . . . . . . . . . . . . . 36Historique des exigences . . . . . . . . . . . . . 37

Traçabilité . . . . . . . . . . . . . . . . . . . . . . . 38Obtention des traces. . . . . . . . . . . . . . . . 39Création de traces entre exigences . . . . . . . . 39Création de traces vers des artefacts logiciels

qui ne sont pas des exigences . . . . . . . . . . 40

Chapitre 4Création d’un complément de traçabilité pour CaliberRM 41

Introduction . . . . . . . . . . . . . . . . . . . . . 41Utilisation de l’exemple Visual Basic.NET . . . . . . 41Interface du complément de traçabilité . . . . . . . 42

VendorSession . . . . . . . . . . . . . . . . . . 42VendorView. . . . . . . . . . . . . . . . . . . . 44VendorObject . . . . . . . . . . . . . . . . . . . 44

Enregistrement et activation de votre complément de traçabilité . . . . . . . . . . . . . . . . . . . . 45

Annexe AModèle d’objets CaliberRM 47Modèle d’objets CaliberRM . . . . . . . . . . . . . 48

Chapi t re 1 : In troduct ion 1

C h a p i t r e

1Chapitre 1Introduction

Le kit de développement (SDK) CaliberRM et l’API du complément de traçabilité favorise les possibilités d’extension de CaliberRM.

CaliberRM SDKA l’aide du SDK CaliberRM, vous pouvez créer, modifier et supprimer des informations CaliberRM, telles que projets, baselines, exigences, utilisateurs et groupes. Le SDK CaliberRM vous donne accès à toutes les données d’exigences de CaliberRM, au moyen de programmes écrits en Java ou dans tout autre langage prenant en charge .NET ou COM.

Ce document apporte aux programmeurs Visual Basic et Java les informations dont ils ont besoin pour démarrer dans les API de CaliberRM.

Remarque : Consultez la documentation détaillée pour les programmeurs, au format Javadoc, à l’adresse Program Files\Borland\CaliberRM SDK <version>\api\index.html, ou bien contactez le support de Borland, pour de plus amples informations.

Important : Si votre application SDK existante doit se connecter à un serveur qui n’a pas encore été mis au niveau de cette version, ne recompilez pas votre application avec le SDK inclus dans cette version. En général, quand vous écrivez des applications SDK, utilisez la même version du SDK que celle du plus ancien serveur auquel doit se connecter l’application. Vous devez recompiler vos applications .NET/COM SDK pour utiliser les nouvelles fonctionnalités du SDK (créer et affecter des profils de sécurité, obtenir/définir un DN utilisateur LDAP) fournies dans cette version ; l’application recompilée sera compatible avec cette version du serveur.

Pour de plus amples informations sur la création d’applications SDK, reportez-vous aux sections Utilisation de Visual Basic pour écrire des applications SDK et Utilisation de Java pour écrire des applications SDK, dans ce manuel.

2 Guide du programmeur SDK Cal iberRM

Technologie de traçabilité complémentaireCaliberRM fournit un moyen unique d’étendre vos informations de traçabilité par des outils tiers, grâce à sa technologie de traçabilité complémentaire. Vous pouvez créer un module de traçabilité complémentaire afin d’offrir la fonction de traçabilité à une application externe. Par exemple, la création d’un complément de traçabilité pour Microsoft Project, vous permet de définir et de gérer facilement des traces en temps réel, à partir d’exigences CaliberRM et à destination de tâches MS Project. Une fois la trace créée, vous pouvez la voir dans la Matrice de traçabilité et dans le Diagramme de traçabilité, ou créer un rapport sur elle avec Document Factory.

Pour de plus amples informations sur la création d’un complément de traçabilité, reportez-vous à la section Création d’un complément de traçabilité pour CaliberRM, dans ce manuel.

Informations supplémentairesSi vous souhaitez obtenir de l’aide sur le SDK CaliberRM, envoyez votre demande au groupe de discussion du SDK CaliberRM, à l’adresse news://newsgroups.borland.com/borland.public.caliber-rm.sdk.

Pour signaler un problème dans le SDK CaliberRM, contactez le support à l’adressehttp://support.borland.com/.

Chapit re 2 : Ut i l isat ion de Visual Basic pour écr i re des appl icat ions SDK 3

C h a p i t r e

2Chapitre2Utilisation de Visual Basic

pour écrire des applications SDK

IntroductionCe chapitre présente le kit de développement (SDK) CaliberRM pour les programmeurs Visual Basic. Voici son contenu :

� description des étapes nécessaires pour configurer votre EDI de façon à utiliser le SDK CaliberRM ;

� utilisation du SDK pour se connecter à un serveur CaliberRM ;

� création, modification et suppression d’informations CaliberRM ;

� utilisation des arborescences, des attributs et de l’historique des exigences ;

� présentation des discussions CaliberRM ;

� utilisation du SDK pour afficher, créer et supprimer des relations de traçabilité.

Configuration de votre EDIPour utiliser le SDK CaliberRM dans votre projet, vous devez définir dans votre EDI une référence à la bibliothèque d’objets du SDK.

Visual Studio 6.01 Cliquez sur Projet > Référence dans le menu principal.Si le SDK CaliberRM a été

correctement installé, la référence CaliberRM library doit figurer dans la liste des références disponibles.

2 Sélectionnez CaliberRM library et cliquez sur OK pour enregistrer les modifications.

3 Si vous ne voyez pas de référence nommée CaliberRM library dans la liste des références, cliquez sur Parcourir et cherchez le fichier CaliberRMSDK DLL sur votre disque dur.


(La bibliothèque est généralement située dans le dossier Program Files\Borland\CaliberRM SDK <version>\api\lib et le nom du fichier bibliothèque est CaliberRMSDK<version>.dll.)

4 Cliquez sur OK dans la boîte de dialogue Références.

Visual Studio .NET 20031 Cliquez sur Projet > Ajouter une référence dans le menu principal.

2 Cliquez sur le bouton Parcourir dans la boîte de dialogue Ajouter une référence.

3 Localisez la bibliothèque CaliberRM SDK sur votre disque dur et cliquez sur Ouvrir.

(La bibliothèque est généralement située dans le dossier Program Files\Borland\CaliberRM SDK <version>\api\lib et le nom du fichier bibliothèque est CaliberRMSDK<version>.NET.dll.)

4 Cliquez sur OK dans la boîte de dialogue Ajouter une référence.

Visual Studio 20051 Cliquez sur Projet > Ajouter une référence dans le menu principal.

2 Cliquez sur l’onglet Parcourir dans la boîte de dialogue Ajouter une référence.

3 Localisez la bibliothèque CaliberRM SDK sur votre disque dur et cliquez sur OK.

(La bibliothèque est généralement située dans le dossier Program Files\Borland\CaliberRM SDK <version>\api\lib et le nom du fichier bibliothèque est CaliberRMSDK<version>.NET.dll.)

4 Cliquez sur OK dans la boîte de dialogue Ajouter une référence.

Pour vérifier si la référence au SDK CaliberRM est correctement définie, effectuez les opérations suivantes :

1 Cliquez sur Projet > Tester les propriétés VBNET dans le menu principal.

2 Cliquez sur l’onglet Références. Vous devriez voir CaliberRMSDK<version>.NET dans le volet Références.

Vous pouvez alors utiliser la bibliothèque CaliberRMSDK dans votre code. Assurez-vous d’importer les classes du SDK CaliberRM dans votre code comme ceci :

Initialisation de la bibliothèque CaliberRMChaque fois que vous lancez le SDK COM, celui-ci lance une machine virtuelle (VM) Java. Le code de cette section doit être appelé avant tout autre appel au SDK car, une fois la VM chargée, ces options ne peuvent plus être définies.

Imports Starbase.CaliberRM.Interop


Les applications COM peuvent utiliser les objets Initializer et IStJavaVMInfo du SDK, par exemple :

Remarque : Par défaut, la plupart des VM utilisent au maximum 64 Mo de mémoire. Cette limite peut être redéfinie à l’aide de l’indicateur de mémoire maximale de la VM (Xmx).

Spécifiez la taille maximale, en octets, du pool d’allocation mémoire. Cette valeur doit être un multiple de 1024 supérieur à 2 Mo. Ajoutez la lettre k ou K pour indiquer des kilo-octets, ou bien m ou M pour indiquer des méga-octets. La valeur par défaut est 64 Mo. Par exemple :

� -Xmx83886080

� -Xmx81920k

� -Xmx80m

Si l’application ne peut pas démarrer la VM Java et que vous obtenez l’erreur Espace insuffisant pour le tas de l’objet, diminuez la taille du tas de la JVM. Généralement, vous devez spécifier la taille mémoire de la VM Java en fonction de la mémoire disponible de votre ordinateur.

Connexion à un serveur CaliberRMLa première étape pour utiliser le SDK CaliberRM consiste à créer une connexion à un serveur CaliberRM. Pour établir une connexion, vous devez créer une référence à un objet CaliberServer. Un objet CaliberServer sert à établir et à maintenir une connexion avec un serveur CaliberRM pour le compte d’un utilisateur CaliberRM.

’ L’objet Initializer est responsable du chargement de la VM Java. Dim objInitializer As New Initializer ’IStJavaVMInfo décrit une VM Java. Dim objStJavaVMInfo As IStJavaVMInfo ’ Accès à la VM en cours depuis l’objet Initializer... Set objStJavaVMInfo = objInitializer.JavaConfiguration.CurrentJavaVM ’ Définition de l’indicateur de mémoire max à 1000 Mo...

objStJavaVMInfo.Options = "-Xmx1000M"


Le code suivant est une application Visual Basic simple qui établit la connexion à un serveur CaliberRM :

Dans l’exemple ci-dessus, remarquez que la création d’une référence à un serveur CaliberRM se fait en deux étapes. En premier lieu, il faut créer une factory de serveur CaliberRM :

Ensuite, vous utilisez la factory de serveur pour créer une nouvelle référence de serveur :

Utilisation de sessionsUn objet Session représente la vue d’un utilisateur de CaliberRM et fournit ainsi un point d’entrée dans le modèle d’objets CaliberRM. L’exemple précédent crée une session en effectuant une connexion à un objet CaliberRM. Dans le code suivant, cette session est utilisée pour afficher les noms de tous les projets auxquels l’utilisateur a accès.

’ Déclaration de variables objet pour les objets Caliber ’ factory de serveur, serveur et session. Dim objServerFact As CaliberServerFactory Dim objServer As CaliberServer Dim objSession As Session ’ Affectation de références d’objets aux variables serveur ’ et factory de serveur. Set objServerFact = New CaliberServerFactory Set objServer = objServerFact.Create(“localhost”)

’ Affectation d’une référence d’objet à la variable session ’ par une connexion au serveur Caliber. Set objSession = objServer.login("admin", "admin")

Set objSrvrFctry = New CaliberServerFactory

Set objServer = objSrvrFctry.Create(“localhost”)

’ Déclaration d’une variable objet pour un projet Caliber Dim objProject As Project

’ Itération sur tous les projets de la session. For Each objProject In objSession.Projects Debug.Print objProject.Name Next objProject


Création d’objets CaliberRMAvec le SDK CaliberRM, vous pouvez créer, modifier et supprimer les objets suivants :

� Projets

� Baselines

� Utilisateurs

� Groupes

� Services

� Exigences

� Types d’exigences

� Profils de sécurité

� Glossaires

� Termes de glossaire

� Intégrations

Pour créer la plupart des informations CaliberRM, suivez ces étapes :

1 Créez une factory qui produira le nouvel objet.

2 Appelez la méthode Create de la factory.

3 Appelez la méthode Save du nouvel objet.

L’exemple suivant exécute ces étapes pour créer un nouvel objet User.

Modification d’objets CaliberRMPour modifier un objet CaliberRM, suivez ces étapes :

1 Obtenez une instance d’un objet CaliberRM.

2 Appelez la méthode Lock de l’objet.

3 Définissez une ou plusieurs propriétés de l’objet.

4 Appelez la méthode Save de l’objet.

Reportez-vous à l’exemple ci-après.

’ Création d’une factory qui sera utilisée pour produire ’ des nouveaux objets User. Set objUserFactory = New UserFactory

’ Création d’un nouvel objet User. Set objNewUser = objUserFactory.Create("jdoe", objSession)

’ Définition des propriétés du nouvel objet User. objNewUser.FirstName = "John" objNewUser.LastName = "Doe" ’ Enregistrement de l’objet User. objNewUser.save


Suppression d’objets CaliberRMVous pouvez supprimer un objet CaliberRM en appelant sa méthode Remove. Par exemple :

Remarquez que la méthode Remove supprime une exigence uniquement à partir de la baseline actuelle. L’exigence n’est pas supprimée des baselines précédentes.

ExigencesCette section détaille la création, la modification et la suppression d’exigences.

Création d’exigences

Le SDK offre deux méthodes permettant de créer de nouvelles exigences. La première méthode permet de créer des exigences au niveau supérieur de l’arborescence des exigences d’un projet. La deuxième sert à créer des enfants d’une exigence existante.

’ Accès à un objet Group. Set objGroup = objSession.Groups.Item(2) ’ Verrouillage du groupe. objGroup.lock ’ Modification des propriétés du groupe. objGroup.Name = "Nouveau nom" objGroup.EmailAddress = "Nouvelle adresse email" objGroup.Description = "Nouvelle description" ’ Enregistrement du groupe modifié. objGroup.save

Dim objRequirement As RequirementSet objRequirement = objSession.getRequirement(1)objRequirement.remove


Dans l’exemple suivant, la première méthode create (Create1) crée une nouvelle exigence.

Dans l’exemple précédent, remarquez que le 4ème paramètre transmis à Create1 est un zéro. Il indique, dans l’arborescence des exigences du projet, le niveau où insérer la nouvelle exigence.

L’exemple suivant montre comment la deuxième méthode create (Create2) crée une exigence enfant d’une exigence existante.

Attributs et valeurs d’attributs

CaliberRM permet de définir des exigences ayant n’importe quel nombre d’attributs définis par l’utilisateur (UDA). En outre, toutes les exigences contiennent les attributs système Etat et Priorité. De même, dans le SDK CaliberRM, un objet Requirement (exigence) dispose des propriétés Status, Priority et AttributeValues qui, respectivement, renvoient son état, sa priorité et les valeurs de ses UDA.

Dans le SDK CaliberRM, les objets Attribute représentent un type d’attribut CaliberRM alors que les objets AttributeValue représentent une instance d’un type.

’ Accès au premier projet dans la collection de la session. Set objProject = objSession.Projects.Item(0) ’ Accès au premier type d’exigences dans le projet. Set objType = objProject.CurrentBaseline.RequirementTypes.Item(0) ’ Création d’une factory d’objets Requirement. Set reqFactory = New RequirementFactory ’ Création d’une nouvelle exigence. Set newRequirement = reqFactory.Create1( _

"Nouvelle exigence", _ objProject, _ objType, _ 0, _ objSession) newRequirement.save ""

’ Création d’une factory d’objets Requirement. Set reqFactory = New RequirementFactory

’ Accès à une exigence qui sera le parent de la nouvelle exigence. Set parentReq = objSession.getRequirement(1) ’ Création d’une nouvelle exigence enfant de parentReq. Set newChildRequirement = reqFactory.Create2( _

"Nouvelle exigence enfant", _ parentReq, _ 4, _ objSession)


Le tableau suivant décrit les relations entre les attributs CaliberRM et les objets Attribute et AttributeValue du SDK.

Le code suivant montre comment obtenir des objets Attribute à partir d’un type d’exigences :

De même, vous pouvez obtenir des objets AttributeValue à partir d’une exigence. L’exemple suivant affiche la même liste que l’exemple précédent en y ajoutant les valeurs :

Attributs CaliberRM Attribute du SDKAttributeValue

du SDK

Ligne de texte isolée

Texte multiligne

UDAText UDATextValue

Entier long UDAInteger UDAIntegerValue

Durée UDADuration UDADurationValue

Flottant UDAFloat UDAFloatValue

Date UDADate UDADateValue

Booléen UDABoolean UDABooleanValue

Liste à choix multiple

Liste à choix unique

Liste de sélection de plusieurs groupes Liste de sélection de groupe isolé Liste de sélection de plusieurs utilisateurs Liste de sélection d’utilisateur isolé

UDAList UDAListValue

’ Accès au premier type d’exigences dans la session.Set objRequirementType = objSession.RequirementTypes.Item(0)

’ Accès au premier onglet personnalisé dans le type d’exigences.Set objCustomTab = objRequirementType.CustomTabs.Item(0)

’ Impression du nom des attributs affectés à l’onglet personnalisé.Dim objAttribute As CaliberRM.AttributeFor Each objAttribute In objCustomTab.attributes Debug.Print vbTab & vbTab & objAttribute.NameNext objAttribute

Dim objAttribValue As AttributeValue

’ Boucle sur toutes les valeurs d’attributs.For Each objAttribValue In objRequirement.AttributeValues ’ Impression du nom et de la valeur de l’attribut Debug.Print _

objAttribValue.Attribute.Name _& “ = “ _

& objAttribValue.ValueNext objAttribValue

Chapit re 2 : Ut i l isat ion de Visual Basic pour écri re des appl icat ions SDK 11

Dans cet exemple, remarquez l’utilisation de la propriété Attribute de AttributeValue pour obtenir le nom :

Vous pouvez utiliser cette propriété chaque fois que vous avez besoin d’obtenir le type d’un AttributeValue. L’exemple ci-après illustre la manipulation d’un certain type de Attribute et AttributeValue.

Valeurs d’attributs de listes

Comme nous l’avons déjà précisé, un objet UDAListValue englobe toutes les valeurs d’attributs de listes qu’une exigence peut recevoir. Cette section contient des exemples pratiques montrant l’utilisation d’un objet UDAListValue pour afficher des listes à choix unique et à choix multiple.

objAttribValue.Attribute.Name

’ Boucle sur toutes les valeurs d’attributs. For Each objAttribValue In objRequirement.AttributeValues

’ Recherche d’un UDATextValue. If TypeOf objAttribValue Is UDATextValue Then

’ Conversion de l’AttributeValue en UDATextValue. Dim textValue As UDATextValue Set textValue = objAttribValue

’ Conversion de Attribute en UDAText. Dim textAttribute As UDAText Set textAttribute = objAttribValue.Attribute

’ Impression d’informations spécifiques à la valeur. Debug.Print _ "La valeur de UDATextValue est : “ _ & textValue.Value

’ Impression d’informations spécifiques au type de valeur. Debug.Print _ "La longueur maximale de cette valeur est : “_ & textAttribute.MaximumLength

Debug.Print _ "La longueur minimale de cette valeur est : “_ & textAttribute.MinimumLength End If

Next objAttribValue


L’exemple ci-après affiche les entrées de la liste d’états d’une exigence et la valeur sélectionnée.

Ce code peut être modifié pour afficher une liste de sélection d’utilisateur isolé :

Private Sub Form_Load() ... Dim objRequirement As Requirement Set objRequirement = objSession.getRequirement(1) PrintList objRequirement.StatusEnd Sub

Private Sub PrintList(objListValue As UDAListValue) ’ Impression des entrées de la liste Debug.Print "Entrée(s) de la liste :" Dim listEntry As UDAListEntry For Each listEntry In objListValue.ListEntries Debug.Print listEntry.Object Next listEntry ’ Impression de la valeur sélectionnée Debug.Print "Valeur sélectionnée = " & objListValue.selectedValueEnd Sub

Private Sub PrintSSUserList(objReq As Requirement) Dim objAttribValue As CaliberRM.AttributeValue ’ Itération sur tous les attributs associés à ’ l’exigence fournie. For Each objAttribValue In objReq.AttributeValues ’ Imprimer uniquement les attributs d’une Liste de sélection

’ d’utilisateur isolé. Set objAttribute = objAttribValue.Attribute If objAttribute.UITypeName = objAttribute.UI_NAME_SSUL Then ’ Impression des entrées de la liste d’utilisateurs Debug.Print "Entrée(s) de la liste d’utilisateurs :"

Dim listEntry As UDAListEntry For Each listEntry In objAttribValue.ListEntries Debug.Print listEntry.Object.Name Next listEntry Debug.Print "Valeur sélectionnée : “ & _ objAttribValue.SelectedValue.Name End If Next objAttribValue End Sub


Dans l’exemple ci-dessus, remarquez que la liste de sélection d’utilisateur isolé est extraite de façon unique à partir d’une collection d’attributs en comparant la propriété UITypeName de son attribut à la constante UI_NAME_SSL :

Cependant, vous pouvez sélectionner un attribut de la collection par son nom. Par exemple :

L’objet UDAListValue peut représenter aussi des valeurs de listes à choix multiple. Par exemple, le code suivant imprime la propriété Name et Selected de chaque élément d’une liste de sélection de plusieurs groupes :

Définition de valeurs d’attributs

Pour modifier les valeurs des attributs d’une exigence, suivez ces étapes :

1 Obtenez une exigence.

2 Appelez la méthode Lock de l’exigence.

3 Déterminez les types des valeurs d’attributs (c’est-à-dire UDATextValue, UDAListValue) que l’exigence contient.

4 Modifiez les objets AttributeValue de l’exigence selon leur type.

5 Mettez l’exigence à jour en donnant la nouvelle valeur à sa propriété AttributeValue.

6 Appelez la méthode Save de l’exigence.

Reportez-vous à l’exemple ci-après.

If objAttribute.UITypeName = objAttribute.UI_NAME_SSUL Then

If objAttribute.Name = "Mon attribut SSUL" Then

Dim listEntry As UDAListEntry For Each listEntry In objAttribValue.ListEntries ’ Utilisation de la propriété ’Selected’ de l’entrée de la liste ’ pour déterminer si le groupe est sélectionné If listEntry.Selected Then Debug.Print listEntry.Object.Name & " *** Selected ***"" Else Debug.Print listEntry.Object.Name End If Next listEntry


Descriptions des exigences

Dans CaliberRM, une description d’exigence peut être une chaîne de texte ou un participant dans une relation de description mappée/partagée. Une description d’exigence partagée est utilisée par plusieurs exigences. A l’inverse, une description d’exigence est mappée quand elle est basée sur celle d’une autre exigence.

Le SDK CaliberRM fournit trois classes qui représentent les états possibles d’une description d’exigence : RequirementDescription, RequirementDescriptionMapped et RequirementDescriptionShared. Tous ces objets de description ont une propriété Text qui permet d’obtenir le texte d’une description. Ainsi, le snippet de code suivant fonctionne avec toutes les exigences :

Set objRequirement = objSession.getRequirement(1) objRequirement.lock ’ Boucle sur toutes les valeurs d’attributs de l’exigence.Dim objAttribValue As AttributeValueFor Each objAttribValue In objRequirement.AttributeValues

If TypeOf objAttribValue Is UDABooleanValue Then’ S’il s’agit d’une valeur UDA booléenne,’ inversez sa valeur.

objAttribValue.Value = Not objAttribValue.Value

ElseIf TypeOf objAttribValue Is UDATextValue Then’ S’il s’agit d’une valeur UDA texte, donnez-lui’ l’heure actuelle.objAttribValue.Value = Time

ElseIf TypeOf objAttribValue Is UDAIntegerValue Then’ S’il s’agit d’une valeur UDA entière,’ ajoutez-lui 1.objAttribValue.Value = objAttribValue.Value + 1

ElseIf TypeOf objAttribValue Is UDAListValue ThenIf objAttribValue.MaximumSelections = 1 Then’ S’il s’agit d’une valeur de liste à sélection unique,’ incrémentez de 1 l’index sélectionné.objAttribValue.SelectedIndex = _

objAttribValue.SelectedIndex + 1End If

End If’ Mise à jour de l’objet exigence avec la nouvelle valeur.objRequirement.AttributeValue = objAttribValue

Next objAttribValue ’ Enregistrement de l’exigence modifiée.objRequirement.save "Modification de valeurs UDA"

Debug.Print req.Description.Text


Pour modifier la description d’une exigence, affectez un nouvel objet RequirementDescription ou RequirementDescriptionMapped à la propriété Description de l’exigence. Par exemple, le code suivant crée une description en texte simple (les appels des méthodes Lock et Save ont été supprimés pour des raisons de clarté) :

L’exemple suivant crée une description HTML simple de l’exigence.

Dans l’exemple suivant, la description de Requirement n°1 est mappée sur Requirement n°2.

Références de document

Le SDK CaliberRM fournit trois types d’objets de référence de document : FileReference, TextReference et WebReference. Vous pouvez créer tous ces objets de référence et les ajouter à la propriété DocumentReferences d’une exigence. L’exemple ci-après crée une instance de chacun de ces objets, puis les utilise pour modifier une exigence.

’ Création d’une factory qui produira des descriptions. Dim descriptionFactory As New RequirementDescriptionFactory ’ Création et utilisation d’un nouvel objet description pour définir la’ propriété Description de Requirement 1.req.Description = descriptionFactory.Create("Une nouvelle description.")

’ Création d’une factory qui produira des descriptions.Dim descriptionFactory As New RequirementDescriptionFactory’ Création et utilisation d’un nouvel objet description pour définir la’ propriété Description de Requirement 1.req.Description = descriptionFactory.Create("<html><body>A new <i><b>formatted description.</b></i></body></html>")

Set req1 = objSession.getRequirement(1)Set req2 = objSession.getRequirement(2)’ Création d’une factory qui produira des descriptions mappées. Dim mapDescriptionFactory As New RequirementDescriptionMappedFactory’ Création et utilisation d’une nouvelle description mappée pour définir ’ la propriété Description de Requirement 1. req1.Description = mapDescriptionFactory.Create(req2, objSession)


Remarquez que l’exemple ci-dessus commence par créer une nouvelle collection à l’aide de la méthode CreateByIStCollection de CollectionFactory. C’est obligatoire, car la propriété DocumentReferences d’une exigence est une collection en lecture seule et ne peut pas être modifiée.

Responsabilités

Généralement, dans CaliberRM, chaque exigence a plusieurs utilisateurs responsables. Vous pouvez obtenir ces utilisateurs et leurs groupes au moyen de la propriété Responsibilities de l’exigence, qui représente une collection d’objets GroupMemberAssignment.

’ En premier, il faut copier la collection existante des références’ de l’exigence dans une collection pouvant être modifiée.Dim colFactory As New CollectionFactorySet docRefs = colFactory.CreateByIStCollection(req.DocumentReferences) ’ Création et ajout d’une référence de texte à la collection docRefs.Dim textRefFactory As New TextReferenceFactorydocRefs.Add textRefFactory.Create("Référence de texte") ’ Création et ajout d’une référence web à la collection docRefs.Dim webRefFactory As New WebReferenceFactorydocRefs.Add webRefFactory.Create("www.microsoft.com") ’ Création et ajout d’une référence de fichier à la collection docRefs.Dim fileRefFactory As New FileReferenceFactorydocRefs.Add fileRefFactory.Create("C:\foo.txt") ’ Définition des références et enregistrement.req.lockreq.DocumentReferences = docRefsreq.save ""


Le code suivant désaffecte tous les utilisateurs responsables d’une exigence.

Historique

Le SDK CaliberRM permet un accès complet aux enregistrements historiques des exigences. La propriété History d’un objet Requirement permet d’obtenir un historique de l’exigence. Le code suivant montre comment utiliser ces objets pour afficher l’historique des révisions :

Nous pouvons maintenant développer cet exemple pour inclure des informations concernant les modifications individuelles de ces révisions. Le code suivant effectue une itération sur tous les objets HistoryChange d’un HistoryRevision, imprime le nom du champ d’exigence ayant changé, le type de modification, l’ancienne valeur et la nouvelle valeur :

’ Accès à la collection d’objets GroupMemberAssignment ’ qui contient les responsabilités de l’exigence. Dim gmaCollection As CaliberRM.Collection Set gmaCollection = req.responsibilities ’ Itération sur tous les objets GroupMemberAssignment ’ de la collection. Dim gma As GroupMemberAssignment For Each gma In gmaCollection ’ Itération sur tous les membres affectés... Dim assignedMember As User For Each assignedMember In gma.AssignedMembers ’ ... et désaffecte chacun d’eux. gma.removeAssignedMember assignedMember Next assignedMember Next gma ’ Verrouillage de l’exigence, définition de ses responsabilités ’ et enregistrement. req.lock req.responsibilities = gmaCollection req.save ""

Dim revision As HistoryRevision For Each revision In objReq.History.Revisions Debug.Print "Ver major : " & revision.Version.MajorVersion Debug.Print "Ver minor : " & revision.Version.MinorVersion Debug.Print "Date : " & Format(revision.OLEDate, "d-mmm") Debug.Print "Nom utilisateur : " & revision.UserName Debug.Print "Commentaire : " & revision.Comment Next revision


Les propriétés OldValue et NewValue d’un objet Change représentent la valeur d’un champ d’exigence avant et après une modification. Pour utiliser ces objets, vous devez les répartir par type. Considérez qu’un objet de valeur de modification appartient à un des trois types suivants :

� String (Chaîne) : représente les modifications apportées à des champs texte non UDA tels qu’un nom ou une description d’exigence.

� Attribute (Attribut) : représente les modifications apportées à tous les attributs système et définis par l’utilisateur.

� User: représente les modifications apportées au champ propriétaire de l’exigence.

La procédure suivante (appelée deux fois dans l’exemple précédent) répartit ces objets OldValue et NewValue en String, Attribute et User.

Dim objChange As HistoryChange For Each objChange In revision.Changes Debug.Print "Nom de champ : " & objChange.FieldName Debug.Print "Type: " & ChangeTypeToString(objChange.changeType) Debug.Print "Ancienne valeur : " & VariantToString(objChange.OldValue) Debug.Print "Nouvelle valeur : " & VariantToString(objChange.NewValue) Next objChange

’ Convertit en chaîne le variant spécifié.Private Function VariantToString(ByVal vntValue As Object) As String

’ Exclusion des modifications "null" (inexistante). If IsNull(vntValue) Then VariantToString = "[NULL]"

’ Si c’est déjà une chaîne, la renvoyer seulement. ElseIf VarType(vntValue) = vbString Then VariantToString = vntValue

Else ’ "Réduction" de la valeur variante en un objet. Dim objValue As Object objValue = vntValue

’ Si l’objet est un CaliberObject, renvoyer son ’ attribut nom... If TypeOf objValue Is CaliberObject Then VariantToString = objValue.Name

’ Impression des modifications apportées aux attributs système ’ et définis par l’utilisateur.

ElseIf TypeOf objValue Is AttributeValue Then VariantToString = UDAValueToString(objValue)

Else VariantToString = "" End If

End IfEnd Function


Remarquez que le code commence par vérifier que la valeur variante transmise à cette procédure n’est pas “null”. Généralement, une modification “null” se produit quand un UDA a été ajouté à un type d’exigences ou en a été supprimé.

Notez aussi que le gestionnaire des objets AttributeValue appelle la fonction UDAValueToString :

Cette fonction de conversion (listée ci-après) illustre comment différents types d’objets AttributeValue peuvent être gérés de manière générique.

Discussions

Avec la fonctionnalité de discussion de groupe de CaliberRM, les équipes de projets peuvent échanger des informations concernant les exigences et les projets. De même, avec le SDK CaliberRM, les programmeurs peuvent consulter les discussions relatives aux exigences et aux projets.

La procédure suivante prend un CaliberObject et affiche des informations concernant ses messages de discussion. Pour cela, elle utilise la propriété Discussion du CaliberObject spécifié.

ElseIf TypeOf objValue Is AttributeValue Then VariantToString = UDAValueToString(objValue)

’ Convertit une AttributeValue (également appelée valeur UDA) en chaîne.Function UDAValueToString(ByVal objValue As AttributeValue) As String

’ D’abord, gère tous les objets AttributeValue dont ’ l’attribut "Value" se convertit facilement en une chaîne... If TypeOf objValue Is UDABooleanValue _ Or TypeOf objValue Is UDAFloatValue _ Or TypeOf objValue Is UDAIntegerValue _ Or TypeOf objValue Is UDATextValue Then UDAValueToString = objValue.Value

ElseIf TypeOf objValue Is UDADateValue Then UDAValueToString = Format(objValue.OLEDate, "d-mmm")

ElseIf TypeOf objValue Is UDADurationValue Then UDAValueToString = objValue.Value _ & objValue.Attribute.GranularityTextElseIf TypeOf objValue Is UDAListValue Then UDAValueToString = "Entrées de liste sélectionnées : “ For Each objListEntry In objValue.ListEntries If objListEntry.Selected = True Then UDAValueToString = UDAValueToString & _ VariantToString(objListEntry.Object) & _ “,” End If Next objListEntry End If

End Function


Remarquez que cette procédure s’arrête si le CaliberObject n’est pas un Requirement ou un Project, puisque seuls les exigences et les projets peuvent avoir des discussions.

Avec le SDK CaliberRM, vous pouvez envoyer des messages de discussion au moyen de la méthode postMessage de l’objet Discussion. De même, vous pouvez répondre à des messages de discussion en utilisant la méthode postReply de DiscussionMessage. L’exemple suivant illustre l’utilisation de ces deux méthodes.

Arborescences d’exigences

Généralement, une baseline CaliberRM contient des ensembles d’exigences reliés par des relations hiérarchiques. Une fois réunies, ces exigences constituent une arborescence. Les objets RequirementTree et RequirementTreeNode fournissent des options précieuses pour utiliser ces arborescences.

Pour naviguer parmi les nœuds d’une arborescence d’exigences :

1 Obtenez un objet RequirementTree à partir d’une baseline ;

2 Accédez à la propriété Root du RequirementTree pour obtenir le RequirementTreeNode racine ;

3 Appelez récursivement la propriété Children du RequirementTreeNode.

Private Sub PrintDiscussion(objCaliberObj As CaliberObject) ’ Seuls les objets Project et Requirement peuvent avoir

’ des discussions. If Not TypeOf objCaliberObj Is Project _ And Not TypeOf objCaliberObj Is Requirement Then Exit Sub End If Dim objDiscussion As Discussion Set objDiscussion = objCaliberObj.Discussion Dim objMessage As DiscussionMessage For Each objMessage In objDiscussion.Messages intTab = objMessage.Depth * 5 Debug.Print Tab(intTab); "Sujet : " & objMessage.Subject Debug.Print Tab(intTab); "Est lu : " & objMessage.Read Debug.Print Tab(intTabDepth); "Date : “ & _ Format(objMessage.OLEDate, "d-mmm") Next objMessage End Sub

’ Accès à une discussion d’exigence. Set objDiscussion = req.Discussion ’ Envoi d’un message à la discussion. Set objMessage = objDiscussion.postMessage("Mon sujet", "Mon message") ’ Envoi d’une réponse au nouveau message. objMessage.postReply "Re: Mon sujet", "Ma réponse"


Le code ci-après suit ces étapes pour imprimer des informations individuelles sur tous les nœuds d’une arborescence d’exigences.

Dans une arborescence d’exigences, un RequirementTreeNode peut représenter un projet, un type d’exigences ou un nœud d’exigence. Un objet RequirementTreeNode contient les données minimales nécessaires à la représentation de l’objet CaliberRM qui lui est associé. Par exemple, si un nœud est associé à un objet Project, vous pouvez obtenir le nom du projet et son numéro d’identification via RequirementTreeNode ; mais vous ne pouvez pas obtenir directement la description du projet ni ses baselines.

... ’ Obtention de l’arborescence d’exigences de la baseline... Dim objRequirementTree As RequirementTree Set objRequirementTree = objBaseline.RequirementTree

’ Navigation dans l’arborescence en commençant par le nœud racine... TraverseTree objRequirementTree.Root End Sub

’ Navigue dans la sous-arborescence dont la racine se trouve au premier ’ niveau du nœud spécifié et affiche des informations sur chaque nœud. Private Sub TraverseTree(ByVal parent As RequirementTreeNode)

’ Impression d’informations sur le nœud parent... Debug.Print _ String(parent.Level, vbTab) _ & parent.HierarchyNumber _ & “ “ _ & parent.Name _ & “ “ _ & parent.SerialNumberTag

’ Appel récursif de cette fonction pour ’ chaque enfant du parent... Dim child As RequirementTreeNode For Each child In parent.Children TraverseTree(child) Next child

End Sub


Pour obtenir l’intégralité de l’objet associé à un RequirementTreeNode, vous devez utiliser la propriété AssociatedObjectID du RequirementTreeNode. Par exemple :

Pour modifier une arborescence d’exigences, vous pouvez utiliser les méthodes addChild et insertChild de RequirementTreeNode. L’exemple suivant utilise la méthode addChild pour ajouter un deuxième nœud d’exigence au premier nœud d’une arborescence d’exigences.

Pour naviguer dans les arborescences d’exigences, vous pouvez utiliser aussi la collection Requirements d’une baseline conjointement à la collection ChildRequirements de chaque exigence. Cependant, remarquez que cette méthode de navigation consomme plus de ressources que l’utilisation de RequirementTree et RequirementTreeNode, puisque vous émettez une requête sur tous les objets exigence dans le serveur CaliberRM à distance.

L’exemple suivant utilise ces collections pour afficher les deux premiers niveaux d’une arborescence d’exigences.

’ Obtention de l’ID du CaliberObject représenté par le nœud. Dim id As CaliberObjectID Set id = objRequirementTreeNode.AssociatedObjectID

’ Obtention du CaliberObject représenté par le nœud Dim co As CaliberObject Set co = objSession.get(id) ’ Impression d’un attribut spécifique au sous-type CaliberObject... If TypeOf co Is Project Then ’ Impression de la description du projet Debug.Print co.Description

ElseIf TypeOf co Is RequirementType Then ’ Impression de la balise du type Debug.Print co.Tag

ElseIf TypeOf co Is Requirement Then ’ Impression de la description de l’exigence Debug.Print co.Description.Text End If

... ’ Obtention du nœud du projet. C’est toujours le nœud racine. Set objProjectNode = objRequirementTree.Root

’ Obtention du premier nœud de type d’exigences sous le nœud du projet. Set objTypeNode = objProjectNode.Children.Item(0) ’ Obtention de la première et de la seconde exigences sous le type’ d’exigences. Set firstRequirementNode = objTypeNode.Children.Item(0) Set secondRequirementNode = objTypeNode.Children.Item(1)

’ Ajout de la seconde exigence à la première. firstRequirementNode.addChild secondRequirementNode

’ Enregistrement des modifications dans l’arborescence. objRequirementTree.save


Vous pouvez aussi passer de l’enfant au parent en utilisant la propriété ParentRequirement d’un objet Requirement. Par exemple, la procédure suivante imprime le chemin entre une exigence donnée et l’exigence racine de l’arborescence.

Traditionnellement, les applications CaliberRM affichaient toutes les exigences du niveau supérieur regroupées et triées par type ; en conséquence, la propriété Requirements d’un objet Baseline renvoie toujours les exigences triées et regroupées de cette façon.

Remarque : Les propriétés Project, Baseline et Requirement Type permettent respectivement de déterminer le projet, la baseline et le type d’une exigence.

TraçabilitéDans CaliberRM, une relation de traçabilité peut exister entre deux exigences ou entre une exigence et un objet externe au système CaliberRM. De façon similaire, le SDK CaliberRM permet de créer, supprimer et modifier des traces entre exigences CaliberRM et artefacts logiciels qui ne sont pas des exigences.

’ Déclaration de variables objet Project et Baseline. Dim firstProject As Project Dim curBaseline As Baseline ’ Définition de la variable Project pour référencer le premier ’ projet dans la collection de projets de la session. Set firstProject = objSession.Projects.Item(0) ’ Définition de la variable Baseline pour référencer la ’ baseline "actuelle" du premier projet. Set curBaseline = firstProject.CurrentBaseline

’ Déclaration d’une variable qui contiendra temporairement ’ le premier niveau d’exigences dans l’arborescence. Dim parentReq As Requirement’ Itération sur le premier niveau d’exigences. For Each parentReq In curBaseline.Requirements Debug.Print parentReq.Name Dim childReq As Requirement ’ Itération sur tous les enfants de ’ l’exigence parent actuelle. For Each childReq In parentReq.ChildRequirements log vbTab & childReq.Name Next childReq

Next parentReq

Private Sub PrintPathToRoot(ByVal objRequirement As Requirement) Do While Not objRequirement Is Nothing Debug.Print objRequirement.Name Set objRequirement = objRequirement.ParentRequirement LoopEnd Sub


Les objets relatifs aux traces contiennent, en particulier, les objets suivants :

� Trace : représente une relation de traçabilité entre deux objets CaliberRM. Il peut s’agir d’exigences ou d’objets résidant à l’extérieur de CaliberRM.

� TraceManager : fournit la fonctionnalité nécessaire pour créer, modifier et supprimer des traces.

� XGenericObjectManager : fournit la fonctionnalité nécessaire pour créer des traces entre des exigences et des artefacts logiciels qui ne sont pas des exigences.

� VendorAddIn : représente une référence à un objet qui réside dans le domaine d’une autre application. Les vendeurs de logiciels dont les applications implémentent le module de traçabilité complémentaire de CaliberRM fournissent ces objets.

Obtention des traces

Le SDK CaliberRM permet l’extraction des traces à de nombreux niveaux du modèle d’objets CaliberRM. Par exemple, l’objet Session dispose d’une propriété Traces qui renvoie toutes les traces entre tous les objets CaliberRM dont vous disposez. De plus, la propriété Traces d’un objet Project renvoie toutes les traces à destination ou provenant des exigences qu’il contient. Finalement, l’objet Requirement fournit deux propriétés pour obtenir des traces : TracesFrom et TracesTo.

L’exemple suivant utilise ces propriétés TracesTo et TracesFrom pour imprimer les noms des objets effectuant une trace vers ou depuis une exigence.

Private Sub PrintTraces(objRequirement As Requirement) Dim objTrace As CaliberRM.Trace Debug.Print "Trace depuis objets " & objRequirement.Name For Each objTrace In objRequirement.TracesFrom ’ La trace suivante est établie vers notre exigence ’ DEPUIS un autre objet. Debug.Print objTrace.FromObject.Name _ & vbTab _ & objTrace.Suspect Next objTrace Debug.Print "Trace vers objets " & objRequirement.Name For Each objTrace In objRequirement.TracesTo ’ La trace suivante est établie depuis notre exigence ’ VERS un autre objet. Debug.Print objTrace.ToObject.Name _ & vbTab _ & objTrace.Suspect Next objTrace End Sub


Création de traces entre exigences

L’objet TraceManager permet de créer et de modifier des relations de traçabilité. Pour créer une trace, la première étape consiste à obtenir une référence de cet objet.

Après avoir obtenu un TraceManager, vous pouvez l’utiliser pour créer des traces. L’exemple suivant crée une relation de traçabilité entre deux exigences.

Création de traces vers des artefacts logiciels qui ne sont pas des exigences

L’exemple précédent montrait comment créer une relation de traçabilité entre deux objets (deux exigences) situés dans CaliberRM. L’exemple suivant utilise l’objet XGenericObjectManager pour créer une trace entre une exigence et un objet qui réside en dehors de CaliberRM.

Le XGenericObjectManager fournit aussi une fonction permettant de créer des traces entre deux objets VendorAddIn externes.

Dim objTraceManager As TraceManager Set objTraceManager = objSession.TraceManager

Dim req1 As Requirement Set req1 = objSession.getRequirement(1) Dim req2 As Requirement Set req2 = objSession.getRequirement(2)

objTraceManager.createTrace3 req1, req2, False

... Dim req1 As Requirement Set req1 = objSession.getRequirement(1) Dim objIntegrationMgr As IntegrationManager Set objIntegrationMgr = objSession.IntegrationManager ’ Création d’une trace depuis req1 vers l’objet ABCObject fourni ’ par ABCCorp. objIntegrationMgr. createTrace2 _ req1, _ True, _ "ABCCorp", _ "ABCObjectID" ...

objIntegrationMgr. createTrace1 _ "ABCCorp", _ "ABCObjectID", _ "XYZCorp", _ "XYZObjectID"


Suppression de traces

Pour supprimer une trace, utilisez la méthode deleteTrace de l’objet TraceManager. Par exemple, la procédure suivante supprime toutes les traces établies depuis une exigence donnée :

Voir l’“Annexe A : Modèles d’objets CaliberRM” qui contient des illustrations permettant de localiser l’objet avec lequel vous voulez travailler et de comprendre comment cet objet s’insère dans le modèle d’objets global de CaliberRM.

Private Sub DeleteTraces(objRequirement As Requirement) Dim objTraceManager As TraceManager Set objTraceManager = objSession.TraceManager Dim objTrace As Trace For Each objTrace In objRequirement.TracesFrom objTraceManager.deleteTrace objTrace Next objTrace End Sub

Chapi t re 3 : Ut i l isat ion de Java pour écri re des appl icat ions SDK 27

C h a p i t r e

3Chapitre 3Utilisation de Java pour écrire

des applications SDK

IntroductionCe chapitre constitue une introduction au SDK CaliberRM pour les développeurs Java. Voici son contenu :

� utilisation du SDK pour se connecter à un serveur CaliberRM ;

� description des conventions utilisées par le SDK ;

� utilisation des arborescences, des attributs et de l’historique des exigences ;

� utilisation du SDK pour afficher et créer des relations de traçabilité.

Création d’un CaliberServerToutes les applications qui utilisent le SDK CaliberRM doivent commencer par créer une connexion à un serveur CaliberRM. Pour cela, il faut créer une nouvelle instance de la classe CaliberServer. Une classe CaliberServer sert à établir et à maintenir une connexion avec un serveur CaliberRM pour le compte d’un utilisateur CaliberRM.


Le code suivant est une application Java simple qui établit la connexion à un serveur CaliberRM :

Ce code illustre les étapes de base que toute application CaliberRM doit suivre :

� importation des packages CaliberRM nécessaires,

� création d’un serveur CaliberRM,

� connexion au serveur CaliberRM.

La première ligne importe le package CaliberRM principal :

Il contient la classe Session. Pour de plus amples informations sur la classe Session, voir “Utilisation de sessions”, page 29.

La deuxième ligne importe le package du serveur CaliberRM :

Il contient toutes les classes concernées par les connexions au serveur, les transactions et les exceptions. La classe CaliberServer fait partie de ce package.

Le code suivant crée une instance de CaliberServer utilisée pour communiquer avec le serveur CaliberRM situé sur l’hôte “foo” :

Enfin, la connexion au CaliberServer crée un objet Session :

import com.starbase.caliber.*;import com.starbase.caliber.server.*;

public class ConnectionCreator { public static void main(String[] args) { CaliberServer server = new CaliberServer("foo");try { Session session = server.login("admin", "admin");

} catch(RemoteServerException rse) { rse.printStackTrace();

} } }

import com.starbase.caliber.*;

import com.starbase.caliber.server.*;

CaliberServer server = new CaliberServer("foo");

try { Session session = server.login("jdoe", "1234ABC");

} catch(RemoteServerException rse) { rse.printStackTrace();}


Dans l’exemple ci-dessus, si un client n’arrive pas à se connecter à un serveur CaliberRM à distance, la méthode login déclenche une exception RemoteServerException. Généralement, une connexion échoue si la méthode login reçoit un ID utilisateur ou un mot de passe erroné. Pour de plus amples informations sur RemoteServerException, voir “Conventions du SDK Java CaliberRM”, ci-après.

Remarque : Chaque fois que vous lancez le SDK Java, celui-ci lance une machine virtuelle (VM) Java. Par défaut, la plupart des VM utilisent au maximum 64 Mo de mémoire. Cette limite peut être redéfinie à l’aide de l’indicateur de mémoire maximale de la VM (Xmx).

Pour les applications SDK Java, cet indicateur peut être défini sur la ligne de commande, par exemple :

Ce code doit être appelé avant tout autre appel au SDK car, une fois la VM chargée, ces options ne peuvent plus être définies.

Utilisation de sessionsUne Session représente la vue utilisateur d’un serveur CaliberRM et fournit ainsi un point d’entrée dans le modèle d’objets CaliberRM. Le code suivant utilise la session créée dans l’exemple précédent pour afficher les noms de tous les projets CaliberRM auxquels l’utilisateur a accès.

Conventions du SDK Java CaliberRMLes deux exemples précédents illustrent diverses conventions du SDK CaliberRM. En premier lieu, chaque fois qu’une méthode SDK dépend d’un serveur CaliberRM pour effectuer une opération, elle est déclarée comme déclenchant une RemoteServerException. Généralement, une RemoteServerException “enveloppe” une exception déclenchée par le serveur à distance. Vous pouvez obtenir un message détaillé décrivant l’exception enveloppée en appelant sa méthode getMessage.

Ensuite, toutes les méthodes qui renvoient plusieurs objets le font dans des tableaux.

Enfin, le SDK CaliberRM respecte les normes de noms établies par les API Java intégrées.

java -Xmx1000M com.company.SDKApp

try { Project[] arrayOfProjects = session.getProjects();

for(int i = 0; i < arrayOfProjects.length; i++) { System.out.println(arrayOfProjects[i].getName());

}} catch(RemoteServerException) {

rse.printStackTrace();}


Le tableau suivant illustre ces règles.

Création d’objets CaliberRMAvec le SDK CaliberRM, vous pouvez créer, modifier et supprimer les objets suivants :

� Projets

� Baselines

� Utilisateurs

� Groupes

� Départements

� Exigences

� Types d’exigences

� Profils de sécurité

� Glossaires

� Termes de glossaire

� Intégrations

Le code exemple suivant montre la façon habituelle de créer des objets CaliberRM :

Modification d’objets CaliberRMPour modifier un objet CaliberRM, suivez ces étapes :

1 Obtenez une instance d’un objet CaliberRM.

2 Appelez la méthode Lock de l’objet.

3 Définissez une ou plusieurs propriétés de l’objet.

4 Appelez la méthode Save de l’objet.

Groupe Règles Exemples

Méthodes Getter/Setter getXxxxsetXxxx getName() setName()

Méthodes booléennes isXxxx isEstablished()

isKeyReference()

Interfaces d’écouteur d’événement XxxxListener ServerConnectionListener

ServerTransactionListener

Recensement d’écouteur d’événement addXxxxListener addServerConnectionListener

addServerTransactionListener

Méthodes de gestionnaire d’événement onXxxx onConnectionEstablished

onServerTransaction

Classes d’événement XxxxEvent ServerTransactionEvent

ServerConnectionEvent

User newUser = new User("Un nouvel utilisateur", session);newUser.save();


L’exemple ci-après suit ces étapes pour modifier un objet Group :

Suppression d’objets CaliberRMVous pouvez supprimer un objet CaliberRM en appelant sa méthode Remove. Par exemple :

Remarquez que la méthode remove supprime une exigence uniquement à partir de la baseline actuelle. L’exigence n’est pas supprimée des baselines précédentes.

ExigencesCette section décrit l’utilisation de base des objets Requirement (exigence).

Arborescences d’exigences

Généralement, une baseline CaliberRM contient des ensembles d’exigences reliés par des relations hiérarchiques. Une fois réunies, ces exigences constituent une arborescence. Les classes RequirementTree et RequirementTreeNode fournissent des options précieuses pour utiliser ces arborescences.

Pour naviguer parmi les nœuds d’une exigence :

� obtenez un objet RequirementTree à partir d’une baseline ;

� appelez la méthode getRoot du RequirementTree pour obtenir le RequirementTreeNode racine ;

� appelez récursivement la méthode getChildren du RequirementTreeNode.

Group group = session.getGroups()[2];group.lock();group.setDescription("Une nouvelle description");group.setEmailAddress("[email protected]");group.save();

Requirement requirement = session.getRequirement(77);requirement.remove();


Le code ci-après suit ces étapes pour imprimer des informations individuelles sur tous les nœuds d’une arborescence d’exigences.

Ce code donne un résultat qui ressemble à ceci :

... // Obtention de l’arborescence de la baseline actuelle. RequirementTree tree = currentBaseline.getRequirementTree(); // Obtention du nœud racine de l’arborescence. RequirementTreeNode root = tree.getRoot(); TraverseTree(root);}

public void TraverseTree(RequirementTreeNode parentNode) {

// Impression d’informations concernant le nœud actuel. PrintTreeNode(parentNode);

// Itération sur la collection d’enfants du parent. RequirementTreeNode[] children = parentNode.getChildren(); for ( int i = 0; i < children.length; i++ ) { TraverseTree(children[i]);}}private void PrintTreeNode(RequirementTreeNode node) { StringBuffer sb = new StringBuffer(); for(int i = 0; i < node.getLevel(); i++) { sb.append(" "); } sb.append(node.getHierarchyNumber()); sb.append(" "); sb.append(node.getName()); sb.append(" "); sb.append(node.getSerialNumberTag()); System.out.println(sb);}

X100 Droid 2016412 Business Requirements BR2016416 1 Operating Environment BR1 1.1 Temperature BR2 1.2 Humidity BR3 1.3 Radiation BR4 2 Continuous operation BR5 2.1 Recharge Time BR73 3 Startup time BR6


Pour naviguer dans une arborescence d’exigences, vous pouvez utiliser aussi les méthodes getDepthFirstEnumeration et getBreadthFirstEnumeration de RequirementTreeNode. Pour illustrer ce point, le code suivant représente une partie du code ci-dessus de façon à utiliser la méthode getDepthFirstEnumeration :

Dans une arborescence d’exigences, un RequirementTreeNode peut représenter un projet, un type d’exigences ou une exigence. Pour obtenir l’ID du CaliberObject associé à un RequirementTreeNode, vous pouvez utiliser sa méthode getAssociatedObjectID. Par exemple :

// Obtention de l’arborescence de la baseline actuelle.RequirementTree tree = currentBaseline.getRequirementTree();

// Obtention du nœud racine de l’arborescence.RequirementTreeNode root = tree.getRoot();

// Obtention d’une énumération de tous les nœuds issus de la// racine.Enumeration nodes = root.getDepthFirstEnumeration();

// Itération sur tous les nœuds...while(nodes.hasMoreElements()) { RequirementTreeNode node = (RequirementTreeNode)nodes.nextElement(); PrintTreeNode(node); }

// Obtention de l’ID du CaliberObject associé au nœud.CaliberObjectID coid = node.getAssociatedObjectID();

// Obtention du CaliberObject en utilisant le CaliberObjectID.CaliberObject co = session.get(coid);if(co instanceof Project) { // Impression d’informations spécifiques au projet. Project p = (Project)co; System.out.println(p.getDescription());

} else if(co instanceof RequirementType) { // Impression d’informations spécifiques au type. RequirementType rt = (RequirementType)co; System.out.println(rt.getTag());

} else { // Impression d’informations spécifiques à l’exigence. Requirement r = (Requirement)co; System.out.println(r.getStatus().getSelectedValue());}


Pour modifier une arborescence d’exigences, vous pouvez utiliser les méthodes addChild et insertChild de RequirementTreeNode. L’exemple suivant utilise la méthode addChild pour ajouter un deuxième nœud d’exigence au premier nœud d’une arborescence d’exigences.

Pour naviguer dans les arborescences d’exigences, vous pouvez utiliser aussi la méthode getRequirements de Baseline conjointement avec la méthode getChildRequirements de Requirement. Cependant, remarquez que cette méthode de navigation consomme plus de ressources que l’utilisation de RequirementTree et RequirementTreeNode, puisque vous émettez une requête sur tous les objets exigence dans le serveur CaliberRM à distance.

L’exemple suivant utilise ces méthodes pour afficher les deux premiers niveaux d’une arborescence d’exigences.

RequirementTree tree = currentBaseline.getRequirementTree();

// Obtention du nœud du projet. C’est toujours le nœud racine.RequirementTreeNode projectNode = tree.getRoot();

// Obtention du premier nœud de type d’exigences sous le nœud du projet.RequirementTreeNode typeNode = projectNode.getChildAt(0);

// Obtention des 1ère et 2ème exigences sous le type d’exigences.RequirementTreeNode requirementNode1 = typeNode.getChildAt(0);RequirementTreeNode requirementNode2 = typeNode.getChildAt(1);

// Modification de l’arborescence par ajout d’un deuxième nœud au premier.requirementNode1.addChild(requirementNode2);

// Validation des modifications.tree.save();

try { // Obtention de la baseline par défaut/en cours. Baseline defaultBaseline = project.getDefaultBaseline();

// Obtention du premier niveau d’exigences dans l’arborescence // d’exigences // de la baseline. Requirement[] topLvlReqs = defaultBaseline.getRequirements(); // Itération sur le premier niveau d’exigences.

for(int i; i < topLvlReqs.length; i++) { Requirement req = topLvlReqs [i];

System.out.println(req.getName());

// Obtention de l’"enfant" de l’exigence en cours. Requirement[] childReqs = req.getChildRequirements();// Itération sur les enfants. for(int j; j < childReqs.length; j++) { Requirement childReq = childReqs[j];

System.out.println("\t" + childReq.getName()); } }}


Vous pouvez aussi passer d’un enfant à son exigence parent en appelant sa méthode getParentRequirement. Par exemple, le code suivant imprime le chemin entre une exigence et l’exigence racine de l’arborescence.

Traditionnellement, les applications CaliberRM affichent toutes les exigences du niveau supérieur de l’arborescence regroupées et triées par type d’exigences. De ce fait, la méthode getRequirements d’un objet Baseline renvoie toujours les exigences regroupées et triées de cette façon.

Remarque : Les méthodes getProject, getBaseline et getRequirementType permettent respectivement de déterminer le projet, la baseline et le type d’une exigence.

Création d’exigences

Le SDK CaliberRM fournit deux constructeurs des objets Requirement (exigence). Le premier constructeur vous permet de créer des exigences au niveau supérieur de l’arborescences des exigences d’un projet, le second sert à créer les enfants d’une exigence existante. L’exemple suivant illustre l’utilisation du premier constructeur pour créer une nouvelle exigence.

try { // Obtention de la dernière version de l’exigence ayant l’ID // numéro 10. Requirement req = session.getRequirement( 10 );

while(req != null) { System.out.println(req.getName());

req = req.getParent(); }

} catch(RemoteServerException) { rse.printStackTrace();

}

// Obtention du premier projet de la session. Project project = session.getProjects()[0];

// Obtention de la baseline en cours pour le projet. Baseline currentBaseline = project.getCurrentBaseline();

// Obtention du premier type d’exigences de la baseline. RequirementType type = currentBaseline.getRequirementTypes()[0];

// Construction de la nouvelle exigence. Requirement newRequirement = new Requirement( "Nouvelle exigence", project, type, 0, session); // Enregistrement de la nouvelle exigence. newRequirement.save();


L’exemple suivant montre comment le second constructeur sert à créer l’exigence enfant d’une exigence existante. La nouvelle exigence sera appelée Exigence enfant et sera le quatrième enfant dans la hiérarchie des enfants du parent.

Attributs d’exigences

CaliberRM permet de définir des exigences en utilisant un nombre quelconque d’attributs définis par l’utilisateur (UDA). En outre, les exigences contiennent toujours les attributs système Etat et Priorité.

Dans le SDK CaliberRM, un objet Requirement fournit la méthode getAttributeValues pour obtenir les valeurs de ses UDA et les méthodes getStatus et getPriority pour obtenir les valeurs de ses attributs système. Par exemple, le code suivant imprime la valeur sélectionnée d’un état d’exigence, qui est une instance de la sous-classe AttributeValue de UDAListValue :

Avec la méthode getAttributeType( ), vous pouvez également obtenir la valeur par défaut d’un attribut. Par exemple :

N’oubliez pas que chaque sous-classe AttributeValue est associée à une sous-classe Attribute unique. En conséquence, la méthode getAttributeType de UDABooleanValue renvoie une instance de UDABoolean et la méthode getAttributeValue de UDATextValue renvoie une instance de UDAText.

// Obtention d’une exigence qui deviendra le parent de la nouvelle// exigence.

Requirement parentReq = session.getRequirement(125);

// Construction de la nouvelle exigence utilisant // l’exigence parent.

Requirement newRequirement = new Requirement( "Exigence enfant", parentReq, 3, session);

// Enregistrement de la nouvelle exigence. newRequirement.save();

UDAListValue status = requirement.getStatus();Object selectedValue = status.getSelectedValue();System.out.print("Valeur sélectionnée : " + selectedValue);

// Obtention du type d’attribut correspondant. UDAList attributeType = status.getAttributeType();

// Obtention de la valeur par défaut pour le type d’attribut.UDAListValue defaultValue = attributeType.getDefaultValue();

// Obtention de la valeur sélectionnée à partir de l’UDAListValue par défaut.Object selectedDefaultValue = defaultValue.getSelectedValue();

System.out.print("Valeur par défaut : " + selectedDefaultValue);


Le tableau ci-après illustre les relations entre les classes AttributeValue et Attribute du SDK et les types d’attributs de CaliberRM.

Historique des exigences

Le SDK CaliberRM permet un accès complet aux enregistrements historiques des exigences. Pour obtenir l’historique d’une exigence, vous pouvez appeler la méthode getHistory sur n’importe quelle instance d’exigence.

Le schéma de classes suivant illustre les relations entre les classes Requirement, History, HistoryRevision et HistoryChange.

Sous-classes AttributeValue

Sous-classes Attribute Types d’attributs de l’application

UDATextValue UDAText Ligne de texte isolée

Texte multiligne

UDAIntegerValue UDAInteger Entier long

UDADurationValue UDADuration Durée

UDAFloatValue UDAFloat Flottant

UDADateValue UDADate Date

UDABooleanValue UDABoolean Booléen

UDAListValue UDAList Liste à choix multiple

Liste à choix unique

Liste de sélection de plusieurs groupes

Liste de sélection de groupe isolé

Liste de sélection de plusieurs utilisateurs

Liste de sélection d’utilisateur isolé


L’exemple ci-après montre comment utiliser ces classes pour afficher des informations historiques :

TraçabilitéDans CaliberRM, une relation de traçabilité peut exister entre deux exigences ou entre une exigence et un objet externe à CaliberRM. De même, le SDK CaliberRM permet de créer, supprimer et modifier des traces entre exigences CaliberRM et artefacts logiciels qui ne sont pas des exigences.

Les objets relatifs aux traces contiennent, en particulier, les classes suivantes :

� Trace : représente une relation de traçabilité entre une exigence et un autre objet CaliberRM quelconque. Cet objet CaliberRM peut être une exigence ou un objet externe à CaliberRM.

� TraceManager : fournit la fonctionnalité nécessaire pour créer, modifier et supprimer des traces.

� ExternalObject : une classe de base abstraite qui représente tous les objets externes à CaliberRM.

� File : représente un objet du système de fichiers.

� SCMFile : représente un objet géré par un outil de gestion de configuration du code source. File et SCMFile se trouvent toutes les deux dans le fichier com.starbase.caliber.external.

� XGenericObjectManager : fournit la fonctionnalité nécessaire pour créer des traces entre des exigences et des artefacts logiciels qui ne sont pas des exigences.

� VendorAddIn : représente une référence à un objet qui réside dans le domaine d’une autre application.

// Obtention de l’historique d’un objet Requirement.History history = req.getHistory();

// Obtention des révisions qui constituent l’historique.HistoryRevision[] revisions = history.getRevisions();

for(int i = 0; i < revisions.length; i++) { Revision revision = revisions[i]; System.out.println("Révision : " + revision.getVersion()); System.out.println("Date : " + revision.getDate()); System.out.println("Utilisateur : " + revision.getUserName()); System.out.println("Commentaire : " + revision.getComment()); // Obtention des modifications qui constituent la révision. HistoryChange[] changes = revision.getChanges(); For(int j = 0; j < changes.length; j++) { Change change = changes[j];

System.out.println("\tField: “ + change.getFieldName()); System.out.println("\tOld Value: “ + change.getOldValue());System.out.println("\tNew Value: “ + change.getNewValue()); }}


Obtention des traces

Les traces peuvent être extraites à de nombreux niveaux de la hiérarchie d’objets CaliberRM. La méthode getTraces de la classe Session renvoie toutes les traces disponibles pour la session. De façon semblable, la méthode getTraces de la classe Project renvoie toutes les traces établies vers ou depuis les exigences d’un projet.

La classe Requirement fournit deux méthodes d’obtention des traces : getTracesFrom et getTracesTo. L’exemple ci-après utilise ces méthodes pour imprimer les noms des objets effectuant une trace vers ou depuis une exigence.

Création de traces entre exigences

La classe TraceManager permet de créer et de modifier des relations de traçabilité. Pour obtenir une instance de TraceManager, appelez la méthode getManager de Session. L’exemple suivant montre comment obtenir une instance de TraceManager :

try {

// La ligne suivante obtient la dernière version // d’une exigence ayant l’ID numéro 1. Requirement requirement = session.getRequirement(1);

Trace[] tracesTo = requirement.getTracesTo(); for(int i = 0; i < tracesTo.length; i++) {

// La trace suivante est établie DEPUIS notre exigence

// vers un autre objet. Trace trace = tracesTo[i]; CaliberObject obj = trace.getToObject();

System.out.println(obj.getName()); }

Trace[] tracesFrom = requirement.getTracesFrom(); for(int i = 0; i < tracesFrom.length; i++) {

// La trace suivante est établie VERS notre exigence // depuis un autre objet.

Trace trace = tracesFrom[i]; CaliberObject obj = trace.getFromObject();

System.out.println(obj.getName()); }

} catch(RemoteServerException) { rse.printStackTrace();

}

TraceManager traceMgr;traceMgr = (TraceManager)session.getManager(Trace.class);


Après avoir obtenu un TraceManager, vous pouvez l’utiliser pour créer des traces. L’exemple suivant crée une trace entre deux exigences.

Création de traces vers des artefacts logiciels qui ne sont pas des exigences

L’exemple précédent a créé une relation de traçabilité entre deux objets (des exigences) situés à l’intérieur des frontières de CaliberRM. L’exemple suivant montre comment créer une trace vers un objet situé à l’extérieur de CaliberRM.

Pour créer une référence à un objet externe, il faut d’abord obtenir une référence au gestionnaire d’objet approprié. Comme nous l’avons déjà dit, vous pouvez appeler la méthode getManager d’un objet Session pour obtenir une instance de CaliberObjectManager. Dans l’exemple ci-dessus, nous obtenons une instance de com.starbase.caliber.xgeneric.XGenericObjectManager (qui gère la plupart des objets externes à CaliberRM).

Remarquez que le premier paramètre de la méthode createFileTrace est une référence à une exigence.

En effet, une référence à un objet externe ne peut exister à l’intérieur de CaliberRM que tant que cet objet participe à une relation de traçabilité avec une exigence. Une fois la trace détruite, la référence est supprimée. Les objets Mercury TestDirector et Select Enterprise, qui peuvent être ajoutés et supprimés de CaliberRM sans être liés à une exigence, constituent les seules exceptions à cette règle.

Requirement req1 = session.getRequirement(1);Requirement req2 = session.getRequirement(2);// La ligne suivante crée une trace depuis req1 vers req2.TraceMgr.createTrace(req1, req2, false);

Class clazz = File.class;XGenericObjectManager extGenObjMgr =

(XGenericObjectManager)session.getManager(clazz);

Requirement req1 = session.getRequirement(1);

// La ligne suivante crée un objet File dans le système// Caliber ainsi qu’une trace depuis req1 vers le nouvel objet File.File f = extGenObjMgr.createFileTrace(

Req1, true, "foo.txt", "C:\\temp\\");

Class clazz = File.class;FileManager fileMgr = (FileManager)session.getManager(clazz);

File f = fileMgr.createFileTrace( Req1, ...

Chapit re 4 : Créat ion d ’un complément de traçabi l i té pour Cal iberRM 41

C h a p i t r e

4Chapitre4Création d’un complément

de traçabilité pour CaliberRM

IntroductionLe développement et la distribution d’un complément de traçabilité est le moyen le plus simple de proposer à vos utilisateurs une solution CaliberRM personnalisée. Un complément fournit un ensemble d’objets à CaliberRM. Ces objets sont affichés dans l’interface utilisateur de CaliberRM, ce qui permet aux développeurs de créer des relations de traçabilité avec des exigences. Par exemple, un complément peut afficher des tâches de Microsoft Project, ou bien des objets d’un outil de conception ou d’un outil de test.

Ce document montre comment utiliser un exemple de projet Microsoft Visual Basic.NET pour créer un complément de traçabilité destiné à CaliberRM. Les fichiers de l’exemple sont fournis dans Program Files\Borland\CaliberRM\Samples\Addins\.

Utilisation de l’exemple Visual Basic.NETL’installation de CaliberRM contient un ensemble de fichiers exemple qui peuvent être utilisés pour créer un complément de traçabilité dans Visual Basic.NET.

Remarque : Vous devez changer tous les GUID dans les fichiers du complément de traçabilité et dans Assembly.Info.vb.

Par défaut, le projet exemple est situé dans Program Files\Borland\CaliberRM\Samples\Addins\HelloWorld2 VB.NET. Vous y trouverez les fichiers suivants :

� AssemblyInfo.vb

� HelloWorld2_VBNet.sln

� HelloWorld2_VBNet.vbproj

� HelloWorld2_VBNet.vbproj.user

� Icon1.ico

� Icon2.ico


� Icon3.ico

� Icon4.ico

� Icon5.ico

� VendorObject.vb

� VendorSession.vb

� VendorView.vb

Pour créer un nouveau complément de traçabilité, exécutez les étapes suivantes :

1 Créez un nouveau projet Visual Basic en utilisant le modèle “Class Library”.

2 Copiez les fichiers VendorSession.vb, VendorView.vb et VendorObject.vb dans le répertoire de votre nouveau projet VB. Ajoutez ensuite les fichiers au projet, en utilisant “Ajouter un élément existant”.

3 Changez les valeurs de tous les GUID COM dans les fichiers que vous venez d’ajouter en utilisant l’outil CreateGUID (menu : Outils->CreateGUID) de VS.NET.

4 Construisez ensuite votre nouveau projet. VS.NET enregistrera la DLL que vous venez de construire à la fin. Vous pouvez enregistrer la DLL sur d’autres ordinateurs en utilisant regasm (Outil Assembly Registration .NET) sur une ligne de commande.

5 Votre complément de traçabilité est maintenant prêt à l’emploi. Vous pouvez désormais implémenter les propriétés et les méthodes qui sont nécessaires dans l’interface.

Interface du complément de traçabilitéPour créer un complément, il faut renseigner les propriétés et les fonctions de trois classes : VendorSession, VendorView et VendorObject. La suite de cette section décrit en détail ces classes et leurs procédures.

VendorSession

La classe VendorSession fournit un contexte dans lequel des clients CaliberRM peuvent interagir avec votre complément. Par la suite, VendorSession est la seule classe qui doit pouvoir être créée publiquement.

Public ReadOnly Property SupportsViewBuilding() As BooleanSi votre complément permet aux utilisateurs de construire des vues de façon dynamique, cette propriété doit être définie par “true”. Par exemple, si vous construisez une intégration avec une base de données, vous pouvez souhaiter présenter plusieurs vues des données basées sur des requêtes. A l’inverse, si vous créez un complément qui ne prend en charge que les vues par défaut, cette propriété doit être définie par “false”.

Voir “GetVendorViews”, page 43, pour de plus amples informations.

Public WriteOnly Property ConfigFilePath() As StringLa propriété ConfigFilePath est définie par CaliberRM pour indiquer le chemin d’accès à un fichier de configuration utilisé par votre complément. Ce fichier de configuration est spécifié quand vous enregistrez un complément dans CaliberRM Administrator. Voir “Enregistrement et activation de votre complément de traçabilité”, page 45, pour de plus amples informations sur l’activation d’un nouveau complément de traçabilité.


Une fois ce fichier de configuration défini, il est géré par CaliberRM et transmis à l’intégration (à l’aide de la propriété ConfigFilePath) immédiatement après l’initialisation de la classe VendorSession.

Public Property SilentMode() As BooleanCette propriété est définie par CaliberRM pour signaler qu’un complément doit s’exécuter en silence. Dans cet état, votre complément NE DOIT afficher aucune boîte de dialogue nécessitant une intervention de l’utilisateur.

Quand CaliberRM reçoit cette propriété, cela indique que le complément fonctionne en silence.

Remarque : Le mode silencieux permet de planifier les rapports Datamart pour qu’ils soient générés aux heures creuses. Lorsque votre serveur CaliberRM contient des projets dans lesquels vous établissez des traces vers votre complément de traçabilité, Datamart recherche les informations d’identification pour exécuter ces tâches et, si le complément s’exécute en mode silencieux, aucune boîte de dialogue ne s’affiche. Il est recommandé de stocker les informations d’ authentification dans un fichier ou dans le registre de votre complément afin de rassembler ces informations sans avoir besoin d’afficher une boîte de dialogue de connexion.

Public ReadOnly Property InterfaceVersion() As IntegerCette propriété fournit la version de l’interface du complément de traçabilité implémentée. Actuellement, CaliberRM prend en charge la version 2.0 de cette interface, donc la valeur de cette propriété devrait toujours être 2.

Public Function GetVendorViews(ByVal BuildView As Boolean) As CollectionCette fonction fournit à CaliberRM une collection d’objets VendorView. Chaque vue est affichée sous forme d’onglet dans la fenêtre Modification de traçabilité de CaliberRM.

A l’initialisation de la fenêtre Modification de traçabilité, CaliberRM appelle la méthode GetVendorViews du complément en attribuant la valeur “false” au paramètre BuildView, ce qui indique que CaliberRM demande la ou les vues initiales (par défaut). Si le complément prend en charge la construction de vues dynamiques (voir “Public ReadOnly Property SupportsViewBuilding() As Boolean”, page 42), le bouton Construire la vue est activé. Quand un utilisateur clique sur le bouton Construire la vue, CaliberRM appelle GetVendorViews en attribuant la valeur “true” au paramètre BuildView. Le complément peut afficher une boîte de dialogue qui demande à l’utilisateur de spécifier les paramètres de la vue. Les vues renvoyées seront ajoutées aux onglets de vues existants.


Public Function GetVendorObject(ID As String) As VendorObjectLa fonction GetVendorObject est appelée par CaliberRM pour obtenir un VendorObject unique.

VendorView

Comme cela a déjà été mentionné, un complément de traçabilité fournit un ensemble d’objets VendorView au moyen de la méthode GetVendorViews de VendorSession. A son tour, chaque VendorView fournit un ensemble de VendorObjects affichés dans l’onglet des vues de la fenêtre Modification de traçabilité de CaliberRM.

Public ReadOnly Property ViewName() As StringCette propriété donne le nom de la vue.

Public ReadOnly Property IsList() As BooleanCaliberRM peut afficher une collection d’objets complémentaires sous forme d’arborescence ou de liste. Si cette propriété a la valeur “true”, CaliberRM affiche les objets de la vue sous forme de liste. Sinon, CaliberRM les affiche sous forme d’arborescence.

Public ReadOnly Property VendorObjects() As CollectionCette propriété fournit les objets qui constituent la vue. Si la vue représente une arborescence d’objets (c’est-à-dire IsList = “false”), cette collection d’objets doit représenter le premier niveau des nœuds de l’arborescence.

VendorObject

La classe VendorObject représente un objet unique exposé par votre complément. CaliberRM obtient ces objets en tant que membres d’un VendorView ou au moyen de la méthode GetVendorObject de VendorSession.

Public ReadOnly Property ID() As StringLa propriété ID fournit l’identificateur unique d’un objet dans CaliberRM. Par la suite, CaliberRM utilise cet ID quand il appelle la méthode GetVendorObject de VendorSession.

Public ReadOnly Property ObjectName() As StringLa propriété ObjectName fournit le nom du VendorObject.

Public ReadOnly Property ShortObjectName() As StringCette instruction fournit à CaliberRM le nom abrégé de l’objet. S’il contient plus de 16 caractères, CaliberRM tronque ce nom.

Public ReadOnly Property Icon() As LongCette propriété fournit une icône pour l’objet.

Public ReadOnly Property Traceable() As BooleanLa propriété Traceable précise si CaliberRM autorise ou nom les utilisateurs à créer une trace vers un VendorObject.


Public ReadOnly Property HasChildren() As BooleanCette propriété détermine si le VendorObject a des enfants ou non. CaliberRM ne consulte cette propriété que si le VendorObject est fourni sous forme d’arborescence d’objets (voir la propriété IsList de VendorView). Si elle a la valeur “true”, CaliberRM affiche un symbole à côté de l’objet dans l’arborescence.

Public ReadOnly Property Children() As CollectionCette propriété rend les enfants d’un VendorObject disponibles à CaliberRM. CaliberRM appelle cette méthode si la propriété HasChildren a la valeur “true” et si l’utilisateur a développé le VendorObject dans une arborescence.

Public ReadOnly Property Operations() As VariantLa propriété Operations permet à chaque VendorObject d’exposer une ou plusieurs opérations aux utilisateurs CaliberRM. Elle renvoie un tableau de chaînes dont chacune représente une opération pouvant être effectuée sur l’objet. Par exemple, si le VendorObject représente un fichier, vous pouvez exposer les opérations Open et Properties.

Public Sub DoOperation(Operation As String)Quand un utilisateur clique avec le bouton droit sur un VendorObject, CaliberRM interroge la propriété Operations et affiche un menu contextuel contenant les chaînes renvoyées. Par la suite, quand il choisit un élément dans le menu des opérations, CaliberRM appelle la méthode DoOperation du VendorObject et lui transmet le nom de l’opération sélectionnée.

Public Sub OnTraceCreated(RequirementID As Integer)Cette méthode est appelée par CaliberRM à la création d’une trace entre une exigence CaliberRM et le VendorObject.

Public Sub OnTraceDeleted(RequirementID As Integer)Cette méthode est appelée par CaliberRM à la suppression d’une trace entre une exigence CaliberRM et le VendorObject.

Public Sub OnStatusChange(RequirementID As Integer, MadeSuspect As Boolean)Cette méthode est appelée par CaliberRM quand l’état “suspect” d’une trace entre une exigence CaliberRM et le VendorObject change.

Enregistrement et activation de votre complément de traçabilitéUne fois que vous avez écrit et compilé votre complément, vous devez l’enregistrer et l’activer pour un projet spécifique sur un serveur CaliberRM et le déployer sur chaque ordinateur client CaliberRM.

Pour enregistrer et activer votre complément, exécutez les étapes suivantes :

1 Sur un ordinateur serveur CaliberRM, ouvrez CaliberRM Administrator et sélectionnez un projet dans le volet gauche.

2 Sélectionnez l’onglet External Traceability dans le volet droit.

3 Cliquez sur le bouton New. La boîte de dialogue New Integration s’affiche.


4 Tapez un nom de complément (c’est le nom qui figurera dans l’onglet Modification de traçabilité), un nom de bibliothèque (dans Visual Basic, ce nom figure dans le champ Nom de projet de la boîte de dialogue Propriétés), et choisissez une icône. Vous pouvez spécifier aussi l’emplacement d’un fichier de configuration utilisé par votre complément. CaliberRM distribue automatiquement ce fichier à tous les clients qui utilisent l’intégration (pour de plus amples informations, consultez la propriété “ConfigFilePath de VendorSession”, page 43).

5 Cliquez sur OK pour créer la nouvelle intégration. La nouvelle intégration est ajoutée à la liste des intégrations Disabled de tous les projets CaliberRM.

6 Pour activer l’intégration, sélectionnez-la dans la boîte liste Disabled et cliquez sur le bouton Vers la gauche.

7 Cliquez sur File> Save Changes. Votre complément est enregistré et activé sur le serveur CaliberRM.

8 Déployez votre complément sur chacun des ordinateurs client CaliberRM si les utilisateurs ont besoin d’établir des traces des exigences vers les objets de votre complément. Vous pouvez utiliser un programme d’installation, ou distribuer et enregistrer manuellement les fichiers nécessaires, ou utiliser le script de connexion.

Annexe A : Modè le d ’objets Cal iberRM 47

A n n e x e

AAnnexe AModèle d’objets CaliberRM

Ces schémas permettent de localiser l’objet avec lequel vous voulez travailler et de comprendre comment il s’insère dans le modèle d’objets global de CaliberRM.

Le tableau suivant explique sous quelle forme les objets et les collections sont représentés dans les schémas.

Indique un objet.

Indique une collection d’objets.

Indique qu’une vue complète de la hiérarchie d’objets se trouve ailleurs dans les schémas.


Modèle d’objets CaliberRM

Annexe A : Modè le d ’objets Cal iberRM 49

CaliberRM SDK Programmer's Guide

Documents

Transcript of CaliberRM SDK Programmer's Guide