Eh bien, seuls les e-mails peuvent recevoir des notifications lorsque vous renouvelez votre ticket dans Redmine. .. Je comprends ce sentiment ...! Si vous pouvez définir des notifications comme Backlog, vous le remarquerez même lorsque vous effectuez encore un autre travail, mais bien sûr, il n'y a pas de telle fonction.

Je me demandais quoi faire, mais si je reçois une notification à ** slack **, qui est très actif en tant qu'outil de chat professionnel dans notre entreprise, je pense que je le remarquerai. J'ai pensé que j'avais fait cette fonction.

Cette exigence

1. Notifier Slack des tickets mis à jour à un statut spécifique dans Redmine

• Coopération en temps réel si possible
• Le contenu de la notification est le titre de Redmine et le lien vers le responsable du ticket. (Je m'attends juste à ce que cela devienne confus si j'informe Slack du contenu de la détention provisoire. Il est important de le remarquer d'abord)

Tout d'abord, recherchez quelque chose qui pourrait être utilisé avec l'intégration existante

Immédiatement sorti https://www.sejuku.net/blog/852461 Cet article

Utilisez l'application RSS

Résultat: ✕ Puisque le Redmine que nous utilisons est créé dans l'intranet, j'ai abandonné car je ne peux pas me connecter à Redmine à partir de slack en utilisant RSS en premier lieu.

Utiliser le plug-in Redmine

Résultat: ✕ Notifier Slack avec un webhook à l'aide d'un plug-in appelé "Redmine Slack" Le contenu de ceci était exactement ce que je voulais faire cette fois, mais le déclencheur est ** uniquement lorsque je crée un nouveau ticket ... **. C'est délicieux ... (Puisqu'il s'agit d'un plug-in qui semble être demandé comme celui-ci, je voulais que vous augmentiez un peu plus le degré de liberté ...)

Politique de correspondance

Enfin, utilisez l 'API Redmine pour acquérir activement des données (tickets) qui remplissent les conditions et en informer Slack. Je me suis installé à la correspondance. Depuis que j'ai frappé l'API comme j'aime, il semble être très polyvalent à l'avenir.

Définition des exigences à nouveau

2. Notifier une fois toutes les 30 minutes (déplacer le lot une fois toutes les 30 minutes)
3. Condition: Obtenez un billet avec le statut de billet «Retour» et le temps de renouvellement dans les 30 minutes
4. Les éléments de slack Notify sont le numéro du ticket, l'URL, le titre, le responsable

Détails d'implémentation

Création d'un fichier Python de traitement

sashimodoshi.py

# -*- coding: utf-8 -*-
import digdag
import requests
import sys
import os
from datetime import datetime, timedelta
import json

sys.path.append(os.path.dirname(os.path.abspath(__file__)))
from .utils.util_slacker import UtilSlacker

class Main():
    def __init__(self, incoming_webhook_url, slack_token):
        self.incoming_webhook_url = incoming_webhook_url
        self.slack_token = slack_token
        self.slacker = UtilSlacker(self.incoming_webhook_url, self.slack_token)
    
    def main(self):
        redmine_api_key = "Clé d'accès à l'API" # 個人設定＞Clé d'accès à l'APIから取得
        redmine_url = "http://URL redmine"

        #Date de mise à jour dans les 30 minutes
        now = datetime.utcnow() + timedelta(minutes=-30)
        now = now.strftime('%Y-%m-%dT%H:%M:%SZ')

        request_url_for_issues = redmine_url + "/issues.json"
        params = {
            "key": redmine_api_key,
            "project_id": "dd",
            "status_id": 4,
            "updated_on": ">=" + now
        }
        issues_res = requests.get(request_url_for_issues, params)
        issues_responses = json.loads(issues_res.text)
        print(issues_responses)

        fields = []

        if len(issues_responses["issues"]) == 0: #S'il vaut 0, il sera traité
            return

        for issue in issues_responses["issues"]:
           issue_id = issue["id"]
           subject = issue["subject"]
           assigned_to_name = issue["assigned_to"]["name"]

           field = {
               "title": subject,
               "value": "Personne en charge:" + assigned_to_name + "\r\nlink：<" + redmine_url + "/issues/{0}|{0}>".format(issue_id),
           }
           print(field)
           fields.append(field)

        msg = "`Renvoi`J'ai un ticket pour.\r\n Veuillez vérifier la personne responsable."
        channel = "#pj-〇〇"
        user = "notification de renvoi Redmine"
        icon_emoji = ":redmine:"
        fallback = "redmine"
        title = ""

        attachment1 = self.slacker.attachment_creater(
            fallback=fallback, title=title, color="danger", fields=fields)
        attachments = [attachment1]
        self.slacker.slack_messenger(
            msg, channel, user, icon_emoji, is_link_name=1, attachments=attachments)

Nous appelons ce processus par lots, mais comme nous avons déjà un serveur digdag, nous avons décidé de l'exécuter dessus.

sashimodoshi.dig

timezone: Asia/Tokyo

schedule:
  cron>: 00,30 10-18 * * 1-5
  weekly>: Thu,10:30:00

_export:
  workflow_name: "sashimodoshi"

+sashimodoshi:
   py>: bin.python_project.sashimodoshi.Main.main
   incoming_webhook_url: ${env.incoming_webhook_url}
   slack_token: ${env.slack_token}

Le fichier dig ressemble à ceci. Dans les paramètres de planification, il est configuré pour fonctionner pendant 30 minutes entre 10h00 et 18h00 du lundi au vendredi. (J'imite juste cet endroit, mais je ne l'ai pas encore rattrapé ...)

Notification de relâche réelle

L'image d'implémentation ressemble à ceci. J'utilise la pièce jointe dans l'API de notification Slack cette fois, et ça a l'air bien!

Épilogue

Cette fois, nous avons mis en œuvre une notification de ralentissement avec élan pour améliorer l'efficacité du travail et l'automatisation, mais comme un problème restant

• La clé API doit être émise avec un compte à usage général pour la notification, pas un compte personnel de Redmine
• Les informations de configuration ne doivent pas être écrites dans le fichier Python en premier lieu

C'est autour, donc je vais le réparer bientôt.

C'est la première fois que je touche correctement Python, mais j'étudie toujours car il semble qu'il continuera à jouer un rôle actif en termes d'efficacité de travail et d'automatisation, comme pouvoir connecter rapidement des API et dans certains cas pouvoir faire fonctionner Excel. J'irai! !!