TOC

Intégration de l’API JIRA REST

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 Maven

Les artefacts requis se trouvent dans le référentiel public Maven d'Atlassian: 


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

Une fois le référentiel ajouté auxpom.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épendancescore etfugue.

3. Créer 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

  • password - 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",
  "http://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();
}

LegetJiraRestClient() utilise toutes les informations fournies et renvoie une instance deJiraRestClient. 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 tels que OAuth sont également pris en charge.

La méthodegetUri() convertit simplement lesjiraUrl en une instance dejava.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 examiner 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 allons utiliser ce numéro 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();
}

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

Le problème va comme une instance deIssueInput à l'API restante. En dehors des 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 desIssueInput.

3.2. Mettre à jour la description du problème

Chaque problème dans Jira est identifié par unString unique comme «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'instanceIssue représente un problème identifié par lesissueKey. Nous pouvons utiliser cette instance pour lire la description de ce problème: 

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

Ceci 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 Issue, 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 auxissue au nom de l'utilisateur dont les informations d'identification ont été utilisées. Cela peut être vérifié en vérifiant le nombre de 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 deIssue 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 instanceIssue pour ajouter un commentaire au nom de l'utilisateur. Comme ajouter un vote, ajouter 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'usinevalueOf() fournie par la classeComment pour créer une instance deComment. Il existe diverses autres méthodes d'usine pour les cas d'utilisation avancés, tels que le contrôle de la visibilité d'unComment.

Allons chercher une nouvelle instance desIssue et lisons tous lesComments: 

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

3.5. Supprimer un problème

Supprimer un problème est également assez simple. Nous avons seulement besoin 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 REST de Jira et effectue certaines des opérations de base.

La source complète de cet article peut être trouvéeover on GitHub.

Related