Intégration de l'API JIRA REST

1. Introduction

Dans cet article, nous verrons rapidement comment s'intégrer à JIRA à l'aide de son API REST.

2. Dépendance de Maven

Les artefacts requis peuvent être trouvés dans le référentiel public Maven d'Atlassian:

 atlassian-public //packages.atlassian.com/maven/repository/public 

Une fois le référentiel ajouté au pom.xml , nous devons ajouter les dépendances ci-dessous:

 com.atlassian.jira jira-rest-java-client-core 4.0.0   com.atlassian.fugue fugue 2.6.1 

Vous pouvez vous référer à Maven Central pour les dernières versions des dépendances core et fugue .

3. Création d'un client Jira

Tout d'abord, examinons quelques informations de base dont nous avons besoin pour pouvoir nous connecter à une instance Jira:

  • username - est le nom d'utilisateur de tout utilisateur Jira valide
  • mot de passe - est le mot de passe de cet utilisateur
  • jiraUrl - est l'URL où l'instance Jira est hébergée

Une fois que nous avons ces détails, nous pouvons instancier notre client Jira:

MyJiraClient myJiraClient = new MyJiraClient( "user.name", "password", "//jira.company.com");

Le constructeur de cette classe:

public MyJiraClient(String username, String password, String jiraUrl) { this.username = username; this.password = password; this.jiraUrl = jiraUrl; this.restClient = getJiraRestClient(); }

Le getJiraRestClient () utilise toutes les informations fournies et renvoie une instance de JiraRestClient . Voici l'interface principale à travers laquelle nous communiquerons avec l'API Jira REST:

private JiraRestClient getJiraRestClient() { return new AsynchronousJiraRestClientFactory() .createWithBasicHttpAuthentication(getJiraUri(), this.username, this.password); }

Ici, nous utilisons l'authentification de base pour communiquer avec l'API. Cependant, des mécanismes d'authentification plus sophistiqués comme OAuth sont également pris en charge.

La méthode getUri () convertit simplement jiraUrl en une instance de java.net.URI :

private URI getJiraUri() { return URI.create(this.jiraUrl); }

Ceci conclut notre infrastructure de création d'un client Jira personnalisé. Nous pouvons maintenant jeter un œil à différentes manières d'interagir avec l'API.

3.1. Créer un nouveau problème

Commençons par créer un nouveau problème. Nous utiliserons ce problème nouvellement créé pour tous les autres exemples de cet article:

public String createIssue(String projectKey, Long issueType, String issueSummary) { IssueRestClient issueClient = restClient.getIssueClient(); IssueInput newIssue = new IssueInputBuilder( projectKey, issueType, issueSummary).build(); return issueClient.createIssue(newIssue).claim().getKey(); }

La projectKey est l'unique qui définit votre projet. Ce n'est rien d'autre que le préfixe qui est ajouté à tous nos problèmes. L'argument suivant, issueType est également dépendant du projet qui identifie le type de vos problèmes comme «Tâche» ou «Histoire». The issueSummary est le titre de notre numéro.

Le problème va comme une instance de IssueInput à l'API restante. Outre les entrées que nous avons décrites, des éléments tels que l'assigné, le rapporteur, les versions affectées et d'autres métadonnées peuvent devenir un IssueInput .

3.2. Mettre à jour la description du problème

Chaque problème dans Jira est identifié par une chaîne unique telle que « MYKEY-123 ». Nous avons besoin de cette clé de problème pour interagir avec l'API restante et mettre à jour la description du problème:

public void updateIssueDescription(String issueKey, String newDescription) { IssueInput input = new IssueInputBuilder() .setDescription(newDescription) .build(); restClient.getIssueClient() .updateIssue(issueKey, input) .claim(); }

Une fois la description mise à jour, ne relisons pas la description mise à jour:

public Issue getIssue(String issueKey) { return restClient.getIssueClient() .getIssue(issueKey) .claim(); }

L' instance Issue représente un problème identifié par issueKey . Nous pouvons utiliser cette instance pour lire la description de ce problème:

Issue issue = myJiraClient.getIssue(issueKey); System.out.println(issue.getDescription());

Cela imprimera la description du problème sur la console.

3.3. Votez pour un problème

Une fois que nous avons obtenu une instance de problème, nous pouvons également l'utiliser pour effectuer des actions de mise à jour / d'édition. Votons pour le problème:

public void voteForAnIssue(Issue issue) { restClient.getIssueClient() .vote(issue.getVotesUri()) .claim(); }

Cela ajoutera le vote au problème au nom de l'utilisateur dont les informations d'identification ont été utilisées. Cela peut être vérifié en vérifiant le décompte des votes:

public int getTotalVotesCount(String issueKey) { BasicVotes votes = getIssue(issueKey).getVotes(); return votes == null ? 0 : votes.getVotes(); }

Une chose à noter ici est que nous récupérons à nouveau une nouvelle instance de Issue ici car nous voulons que le décompte des votes mis à jour soit reflété.

3.4. Ajouter un commentaire

Nous pouvons utiliser la même instance Issue pour ajouter un commentaire au nom de l'utilisateur. Tout comme l'ajout d'un vote, l'ajout d'un commentaire est également assez simple:

public void addComment(Issue issue, String commentBody) { restClient.getIssueClient() .addComment(issue.getCommentsUri(), Comment.valueOf(commentBody)); }

Nous avons utilisé la méthode d'usine valueOf () fournie par la classe Comment pour créer une instance d'un Comment . Il existe diverses autres méthodes d'usine pour les cas d'utilisation avancés, comme le contrôle de la visibilité d'un commentaire .

Récupérons une nouvelle instance du problème et lisons tous les commentaires :

public List getAllComments(String issueKey) { return StreamSupport.stream(getIssue(issueKey).getComments().spliterator(), false) .collect(Collectors.toList()); }

3.5. Supprimer un problème

La suppression d'un problème est également assez simple. Nous n'avons besoin que de la clé de problème qui identifie le problème:

public void deleteIssue(String issueKey, boolean deleteSubtasks) { restClient.getIssueClient() .deleteIssue(issueKey, deleteSubtasks) .claim(); }

4. Conclusion

Dans cet article rapide, nous avons créé un client Java simple qui s'intègre à l'API Jira REST et effectue certaines des opérations de base.

La source complète de cet article se trouve à l'adresse over sur GitHub.