Créer une révision personnalisée en utilisant l'API de révision personnalisée

Utilisez l'exemple Bugzilla pour apprendre à créer un processus de révision personnalisé à l'aide de l'API.

Pourquoi et quand exécuter cette tâche

Vous pouvez utiliser l'API pour créer un processus de révision personnalisé qui définit des états et des scénarios de révision spécifiques. Pour apprendre à utiliser l'API, servez-vous du client Bugzilla qui vous est fourni à titre d'exemple dans l'archive BugzillReview.jar, située dans le répertoire suivant : http://hôte:port/com.ibm.ram.repository.web/extensionExamples/customReviewProcess/BugzillaReview.jar, où hôte et port correspondent respectivement au nom et au numéro de port de votre serveur Rational Asset Manager.

Ouvrez le fichier d'archive Java situé dans le répertoire suivant : http://hôte:port/com.ibm.ram.repository.web/extensionExamples/customReviewProcess/CustomReviewAPI.jar, où hôte et port représentent respectivement le nom d'hôte et le numéro de port de votre serveur Rational Asset Manager.

package com.ibm.ram.extension.demo.review;

import java.io.InputStream;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.*;
import org.xml.sax.helpers.DefaultHandler;

import com.ibm.ram.extension.ConfigurationDetails;
import com.ibm.ram.extension.CustomReviewProcess;
 

Lorsqu'un processus de révision démarre dans Rational Asset Manager, cette extension crée une entrée de problème (ou bogue) dans le client Bugzilla afin de permettre le suivi du processus de révision. Dans le client Bugzilla, chaque entrée est associée à un 'bug ID', ou 'ID de bogue'. Cet ID est renvoyé par la méthode start(...) de l'extension et stocké dans Rational Asset Manager. Les appels de méthode suivants incluent l'ID de bogue dans les données d'instance ; cela permet à l'extension d'établir une correspondance entre une instance de processus de révision spécifique et un ID de bogue Bugzilla. Les exemples suivants décrivent les appels de méthode pour les instances du processus de révision :

public class BugzillaReviewProcess extends CustomReviewProcess {	

L'état Bugzilla 'VERIFIED' représente l'état 'approuvé' dans Rational Asset Manager. Les actifs approuvés peuvent être trouvés dans le référentiel et réutilisés.

public static final String[] APPROVED_STATES = {BugzillaConstants.VERIFIED};

L'état Bugzilla 'CLOSED' représente l'état 'rejeté' dans Rational Asset Manager. Les actifs rejetés sont retournés à l'état de brouillon éditable.

public static final String[] REJECTED_STATES = {BugzillaConstants.CLOSED};

Les états Bugzilla 'NEW', 'ASSIGNED' et 'RESOLVED' sont utilisés pour le processus de révision dans Rational Asset Manager.

public static final String[] NON_FINAL_STATES = {BugzillaConstants.NEW, BugzillaConstants.ASSIGNED,
BugzillaConstants.RESOLVED};
	public static final String USER = "user"; 
	public static final String PASSWORD = "password"; 
	public static final String TITLE = "title";
	public static
  final String PRODUCT = "product"; 
  public static final String COMPONENT = "component"; 
	public static final String PLATFORM = "platform";  
	public static final String SEVERITY = "severity"; 
	public static final String PRIORITY = "priority"; 
	public static final String OPERATING_SYSTEM = "operatingSystem";
	public static final String VERSION = "version"; 
	public static final String URL = "url"; 	

Lorsque vous vous connectez à un serveur Rational Asset Manager, vous devez configurer les détails suivants dans le client Bugzilla : URL du serveur, nom d'utilisateur et mot de passe. Les autres données sont des détails optionnels qui peuvent être configurés en fonction du processus de révision auquel ils se rapportent (par exemple, le nom du processus de révision).

public static final ConfigurationDetails[] CONFIG_DETAILS = { 		
 new ConfigurationDetails (URL, "URL", "L'URL de la page d'accueil Bugzilla",false, true), 		
 new ConfigurationDetails (USER,"Utilisateur", "Le compte d'utilisateur qui servira à accéder à bugzilla", false, true),
 new ConfigurationDetails (PASSWORD, "Mot de passe","Le mot de passe du compte qui sera utilisé pour accéder à bugzilla", true, true), 		
 new ConfigurationDetails(TITLE, "Titre", "Le titre de la révision soumise", false, false), 		
 new ConfigurationDetails(PRODUCT, "Produit","Produit", "ProduitTest", false, false), 		
 new ConfigurationDetails(COMPONENT, "Composant","Composant", "ComposantTest", false, false), 	
 new ConfigurationDetails(PLATFORM, "Plateforme","Plateforme", "PC", false, false), 		
 new ConfigurationDetails(SEVERITY, "Gravité","Gravité", "bloquant", false, false), 		
 new ConfigurationDetails(PRIORITY, "Priorité","Priorité", "P1", false, false), 		
 new ConfigurationDetails(OPERATING_SYSTEM,"Système d'exploitation","Système d'exploitation", "Windows", false, false), 		
 new ConfigurationDetails(VERSION, "Version","Version", "autre", false, false), 	
};

Le code suivant ajoute un ID pour une entrée de bogue Bugzilla inconnue.

public static final String UNKNOWN_CUSTOM_ID = "-1";
La méthode suivante peut être utilisée pour nettoyer les données qui subsistent à la fin d'un processus de révision ; par exemple, la notification signalant qu'un utilisateur a terminé une révision.
Remarque : Dans l'exemple suivant, les données ne sont pas nettoyées.
public void end(String ramAssetId, String assetVersion, String customAssetId,Map configurationValues, boolean aborted) { 

La méthode suivante renvoie les détails de configuration que vous avez définis.

public String getName() { 
	return "Processus de révision Bugzilla 2.22.2"; 	}

La méthode suivante renvoie la description du processus Bugzilla.

public String getDescription() { 	
   return "Un processus de révision personnalisé fonctionnant en intégration avec Bugzilla 2.22.2"; 	}

La méthode suivante renvoie les noms des états 'approuvé' que vous avez définis plus haut. Lorsque l'actif atteint cet état, il est passé à l'état Approuvé dans Rational Asset Manager.

public String[] getApprovedStateNames(String assetId, String assetVersion,
String instanceData, Map configurationValues) { 		
	return APPROVED_STATES;
}

La méthode suivante renvoie les noms des états 'non final' que vous avez définis plus haut. Tant que l'actif est dans l'un de ces états, le processus de révision est actif et les réviseurs y ont accès pour effectuer leur part de révision de l'actif.

public String[] getNonFinalStateNames() { 		
	return NON_FINAL_STATES;
 }

Dans le code suivant, on communique avec le serveur Bugzilla pour déterminer l'état de l'ID de bogue fourni dans les données d'instance.

public String getState(String assetId, String assetVersion, String instanceData,Map configurationValues) 
{ 		
return (String)getStatus(getBugId(instanceData),configurationValues).get(BugzillaXMLHandler.BUG_STATUS_NODE); 
}

Le code suivant renvoie l'URL d'un problème spécifique en fonction de l'ID de bogue fourni dans les données d'instance.

public String getURL(String assetId, String assetVersion, String instanceData,Map configurationValues) 
{ 		
int bugId = getBugId(instanceData);String url = BugzillaClient client = new BugzillaClient(new URL((String)configurationValues.get(URL)));
	if(!String.valueOf(bugId).equals(UNKNOWN_CUSTOM_ID))
{
 	url = client.getURL(bugId).toString();	
} 
catch(Exception e) {e.printStackTrace(); 	
} 		
return url;""; try  
{

Le code suivant est appelé chaque fois que vous soumettez une révision. A ce stade, vous devez communiquer avec le client Bugzilla pour extraire le problème associé à ce processus de révision, lequel est déterminé par l'objet instanceData. Vous devez ensuite poursuivre la mise à jour du statut de ce problème en y ajoutant les commentaires de révision de l'utilisateur et en indiquant s'il a accepté ou rejeté la révision.

public String handleReviewSubmitted
	(String assetId, String assetVersion, String instanceData, String username, bool accepted, String comment, InputStream uploadedContent, String fileName, Map configurationValues) 
{ 		
String acceptText = accepted ? "approuvé" : "rejeté"; try 
{ 			
BugzillaClient client = new BugzillaClient(new URL((String)configurationValues.get(URL)));
Map bugStatus = getStatus(getBugId(instanceData),configurationValues);client.updateBug
(
 (String)configurationValues.get(USER),
 (String)configurationValues.get(PASSWORD),getBugId(instanceData),BugzillaConstants.KEEP_CURRENT_STATE, 
 (String)bugStatus.get(BugzillaXMLHandler.PRODUCT_NODE),
 (String)bugStatus.get(BugzillaXMLHandler.COMPONENT_NODE), 
 (String)bugStatus.get(BugzillaXMLHandler.PLATORM_NODE),
 (String)bugStatus.get(BugzillaXMLHandler.SEVERITY_NODE), 
 (String)bugStatus.get(BugzillaXMLHandler.PRIORITY_NODE), 
 (String)bugStatus.get(BugzillaXMLHandler.OP_SYS_NODE), 
 (String)bugStatus.get(BugzillaXMLHandler.VERSION_NODE),"http://", 
 (String)bugStatus.get(BugzillaXMLHandler.TITLE_NODE), username + " a " + acceptText + " avec le commentaire : " + comment);
} 
catch(Exception e)
{ 
e.printStackTrace(); 		
} 		
return instanceData; 
}

Dans le code suivant, on communique avec le client Bugzilla pour déterminer si le processus de révision indiqué est dans un état accepté.

public boolean isApproved(String assetId, String assetVersion,String instanceData, Map configurationValues) 
{ 		
return BugzillaConstants.VERIFIED_XML.equals(getState(assetId,assetVersion, instanceData, configurationValues));
}

Dans le code suivant, on communique avec le client Bugzilla pour déterminer si le processus de révision indiqué est dans un état rejeté.

public boolean isRejected(String assetId, String assetVersion, 
	String instanceData,Map configurationValues) 
{ 		
return BugzillaConstants.CLOSED_XML.equals(getState(assetId,assetVersion, instanceData, configurationValues)); 	
}

Le code suivant est appelé lorsque le processus de révision est démarré. L'ID d'actif, la version d'actif et les valeurs de configuration de ce processus de révision sont fournis par Rational Asset Manager. Vous devez communiquer avec le client Bugzilla afin de créer une entrée de problème pour ce processus de révision. Après quoi, l'ID de bogue associé au problème est retourné à Rational Asset Manager. Dans tous les autres appels en rapport avec ce processus de révision, le String obtenu au retour de cette méthode (l'ID de bogue) est passé comme paramètre d'instance.

public String start(String assetId, String assetVersion, Map configurationValues)
{ 		
	String customId; try 
{ 			
BugzillaClient client = new BugzillaClient
(newURL((String)configurationValues.get(URL))); customId =  String.valueOf(client.enterBug((String)configurationValues.get(USER),
(String)configurationValues.get(PASSWORD),  				
(String)configurationValues.get(PRODUCT),
(String)configurationValues.get(COMPONENT),  				
(String)configurationValues.get(PLATFORM),
(String)configurationValues.get(SEVERITY),  				
(String)configurationValues.get(PRIORITY),
(String)configurationValues.get(OPERATING_SYSTEM),  				
(String)configurationValues.get(VERSION),"http://",  				
(String)configurationValues.get(TITLE), "Révision démarrée"));
} 
catch(Exception e) 
{
e.printStackTrace();customId =  UNKNOWN_CUSTOM_ID;	
} 		
return customId; 
} 	
Dans le code suivant, on communique avec le client Bugzilla pour déterminer le statut d'un ID de problème (ou ID de bogue) spécifique.

@param bugzillaAssetId

@param configurationValues

@return

private Map getStatus(int bugzillaAssetId, Map configurationValues) 
{ 		
BugzillaXMLHandler handler = new BugzillaXMLHandler(); 		
 try 
{ 			
BugzillaClient client = new BugzillaClient(new URL((String)configurationValues.get(URL))); SAXParserFactory factory = SAXParserFactory.newInstance(); factory.setValidating(false); SAXParser sp = factory.newSAXParser(); sp.parse(client.getBugStatus((String)configurationValues.get(USER),
(String)configurationValues.get(PASSWORD), bugzillaAssetId), handler);
} 
catch(Exception e) 
{ 			
e.printStackTrace();
}
return handler.getResult();
}

Le code suivant détermine l'ID de bogue Bugzilla d'après les données d'instance stockées dans Rational Asset Manager.

public class BugzillaXMLHandler extends DefaultHandler { 		 		
public static final String BUG_ID_NODE = "bug_id"; 
public static final String PRODUCT_NODE = "product"; 		
public static final String COMPONENT_NODE = "component"; 	
public static final String VERSION_NODE = "version"; 		
public static final String PLATORM_NODE = "rep_platform"; 		
public static final String OP_SYS_NODE = "op_sys"; 		
public static final String BUG_STATUS_NODE = "bug_status"; 
public static final String PRIORITY_NODE = "priority"; 		
public static final String SEVERITY_NODE = "bug_severity"; 		
public static final String TITLE_NODE = "short_desc"; 		 		
private String node; 		
private Map valueMap = new HashMap();
public void startElement(String uri, String localName, String qName,
Attributes attributes) throws SAXException 
{ 			
node = qName;
} 		 		
public InputSource resolveEntity(String publicID, String systemID) 
{ 
 return new InputSource(BugzillaReviewProcess.class.getResourceAsStream("bugzilla.dtd"));
} 		 	
public void characters (char ch[], int start, int length) 
{ 	
	 if(node.equals(BUG_ID_NODE) 
 			|| node.equals(PRODUCT_NODE) 
			|| node.equals(COMPONENT_NODE)
  			|| node.equals(VERSION_NODE) 
 			|| node.equals(PLATORM_NODE)
 			|| node.equals(OP_SYS_NODE) 
 			|| node.equals(BUG_STATUS_NODE)  
			|| node.equals(PRIORITY_NODE) 
			|| node.equals(BUG_ID_NODE)
  			|| node.equals(SEVERITY_NODE)
 			|| node.equals(TITLE_NODE)) { 
	 valueMap.put(node,new String(ch, start, length));		 			
} 	
} 		 		
public Map getResult() 
{
	return valueMap; 
		} 
	} 	 
}

Commentaires