Depuis que je suis passé à orgmode, j’ai essayé de faire fonctionner cela avec la plupart de mon environnement. Comme je travaille avec gitlab au quotidien, j’ai pensé que je commencerais par là en premier.

Bibliothèques

Org Parse

Org Format

Convertir des trucs : pypandoc

Python pour Gitlab

Framework de ligne de commande

Autres

Token Gitlab : Docs

Portée - que construisons-nous

Automatisons la plupart du travail qui est redondant avec gitlab.

  • Utilisateurs

    • Créer, mettre à jour, supprimer, lister
    • Ajouter à un projet spécifique
    • Affecter une tâche
    • Intégrer

  • Créer des issues basées sur un fichier org.

Mais plus spécifiquement, 2 choses sont une priorité en ce moment :

  • intégrer les utilisateurs
  • publier des issues à partir d’un fichier de projet

Intégration

La façon dont j’ai implémenté l’intégration est simplement de créer un projet d’intégration (en fait 2, un pour l’intégration interne, et un pour l’intégration des contractants), où les utilisateurs sont ajoutés et affectés à une issue “Bienvenue” décrivant pour eux le processus d’intégration.

Donc une première version brute de notre fonction d’intégration ressemblera à ceci :

  • identifier si l’utilisateur est interne ou externe (pour définir à quel processus d’intégration il appartient)

  • puis ajouter l’utilisateur (l’utilisateur a été créé en premier) au projet d’intégration (j’ai codé en dur l’id du projet - oui, c’est mauvais, nous corrigerons cela plus tard)

  • puis créer une issue (il s’avère que vous devez créer et assigner l’issue, sinon l’utilisateur ne reçoit pas l’email correctement)

  • puis rendre l’issue confidentielle

    Donc cela donne quelque chose comme ça.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

          def onboard_user(username, external, template_file):
          """intégrer les utilisateurs"""
          project_id = 34 # TODO: déplacer vers un fichier de config
          if external:
              project_id = 24

          user = add_user_to_project(username, project_id)

          issue_content = org.issue_from_template('onboarding',template_file)
          issue = create_and_assign_project_issue(project_id, issue_content, username)
          issue.confidential = True
          issue.save()

          print("Utilisateur intégré", username)
          return user

    Mais avant de pouvoir intégrer qui que ce soit, nous devons créer les utilisateurs et s’autoriser avec l’API

    Pour l’instant, cela se passe depuis la ligne de commande.

    La prochaine étape sera de migrer cette ligne de commande interactive et principalement d’être gérée depuis un fichier org, où je peux ajouter un utilisateur, les sauvegarder comme contacts, et mettre à jour par lot la création et l’intégration de n’importe qui.

    Mais voyons pour l’instant la création d’un utilisateur :

    1
2
3
4
5
6
7

          def create_user(name, username, email, password):
          """créer un utilisateur"""
          user = gl.users.create({'name':name,
                                  'username':username,
                                  'email': email,
                                  'password': password})
          print("Utilisateur créé:", user.username)

    Pas trop difficile.

    Cela notifiera l’utilisateur de sa création et nous sommes bons.

    C’est tout pour l’instant.

  • Quelle est la suite ?

    Il m’a fallu un moment pour rassembler toutes les informations pour commencer, mais une fois que vous y êtes, c’est assez simple.

    Donc la prochaine étape, pour un autre post, sera comment dispatcher une nouvelle issue depuis org mode