[PYTHON] J'ai essayé de découvrir notre obscurité avec l'API Chatwork

L'application de l'article est publiée sur github

J'ai résumé l'histoire de la création d'une application qui examine les retraités silencieux de Chatwork que l'entreprise n'annonce pas. (* Nous ne sommes pas responsables des problèmes avec la société à laquelle appartient l'utilisateur en raison de son fonctionnement)

Slack, grattage, les documents Excel devraient pouvoir être détournés en organisant la méthode d'acquisition des données

Origine

«Nous avons plus de 200 employés, mais j'étais très mal à l'aise parce qu'il n'y avait pas d'annonce de départs à la retraite parce que certains des employés que je connaissais avaient démissionné avant que je ne le sache. ――Vous n'êtes ingénieur que si vous résolvez des problèmes avec la technologie! --Quand j'ai remarqué mon emploi précédent, des gens avaient démissionné, il devrait donc y avoir des gens qui ont les mêmes problèmes → Le désir d'approbation d'être satisfait ―― ~~ Je n'ai pas de projets de vacances consécutives ~~

Objectifs fonctionnels

Surveiller les changements d'inscription quotidiens en fonction de vos contacts Chatwork --Publiez les résultats de la surveillance sur Ma chaîne -Permettre de voir des rapports de synthèse pour une certaine période telle que annuelle ou mensuelle
Soyez prudent lors du traitement des informations personnelles et des clés API

Technologie utilisée

Environnement hôte: Windows10 + Ubuntu20.4 sur WSL2 (si Docker peut être utilisé, le système d'exploitation hôte n'a pas d'importance)
Docker
Python(Django)

Résultat

J'ai pu afficher les nouveaux employés / retraités dans la période et appréhender les changements quotidiens des membres internes.

↓ Écran de rapport

↓ Écran de résultats de notification de Chatwork

Processus de travail

Environnement

--Si vous pouvez utiliser la commande docker-compose, vous pouvez trouver d'autres éléments nécessaires dans Projet publié sur github.

Veuillez préparer le jeton d'API Chatwork (+ room_id de la destination de notification si vous utilisez la notification par lots) requis pour le fonctionnement de l'application. Comment obtenir un jeton API (officiel)

Construction de l'environnement Docker

`Dockerfile`


FROM python:3
ENV PYTHONUNBUFFERED 1
ENV PYTHONIOENCODING utf-8
RUN mkdir /script /app
WORKDIR /script
COPY requirements.txt /script/
RUN apt update && apt install -y cron vim
RUN pip install -r requirements.txt
WORKDIR /app

`requirements.txt`


Django>=3.0,<4.0
psycopg2-binary>=2.8
django-environ
requests
python-dateutil

`docker-compose.yml`


version: '3'

services:
  app:
    build: .
    command: python manage.py runserver 0.0.0.0:8000
    environment:
      - CHATWORK_API_TOKEN=${CHATWORK_API_TOKEN}
      - ROOM_ID=${ROOM_ID}
      - TZ=Asia/Tokyo
    volumes:
      - ./app:/app
      - ./export_environment.sh:/script/export_environment.sh
      - ./crontab:/script/crontab
    ports:
      - "8000:8000"

Explication principale du traitement

Obtenez une liste de contacts à l'aide de votre jeton de compte
Clarifier les membres rejoignant / retirant les membres en comparant les données de la liste avec différents temps d'acquisition
Comme les données passées ne peuvent pas être référencées à partir de l'API, les données à comparer sont stockées dans la base de données.
Conçu pour renvoyer la différence entre les membres du contact lorsque deux dates sont données à get_diff () --show () , qui a une fonction pour afficher un rapport, affiche un rapport de changement de membre pour les six derniers mois sur une base mensuelle (puisqu'il s'agit d'un rapport mensuel, les informations sur les retraités chauds seront traitées dans le lot décrit plus loin).
Dans le traitement par lots, la même méthode que pour les rapports est utilisée pour publier les membres qui ont changé de jour en jour sur Chatwork comme des nouvelles de dernière heure.

Traitement de l'écran de rapport + acquisition et sauvegarde de la liste de contacts Chatwork, méthode de comparaison des données

`app/chatwork/views.py`


from django.shortcuts import render
from django.http import HttpResponse
from chatwork.models import Account
import requests
from datetime import date
from dateutil.relativedelta import relativedelta
from django.db.models import Count
import environ
env = environ.Env(DEBUG=(bool, False))

# Create your views here.

def show(request):
    diff_list = list()
    for i in range(6):
        end = (date.today() - relativedelta(months=i)).isoformat()
        start = (date.today() - relativedelta(months=(i+1))).isoformat()
        diff_list.append(get_diff(start, end))

    params = dict(d1=diff_list[0], d2=diff_list[1], d3=diff_list[2], d4=diff_list[3], d5=diff_list[4], d6=diff_list[5])
    return render(request, 'chatwork/show.html', params)

def get_diff(start, end):
    if not Account.objects.filter(date=date.today().isoformat()):
        base = 'https://api.chatwork.com/v2/'
        end_point = 'contacts'
        api_token = env('CHATWORK_API_TOKEN')
        headers = {'X-ChatWorkToken': api_token, 'Content-Type': 'application/x-www-form-urlencoded'}
        res = requests.get(base + end_point, headers=headers)
        for contact in res.json():
            data = dict(account_id=contact['account_id'], name=contact['name'][:2], department=contact['department'], date=date.today().isoformat())
            Account.objects.update_or_create(**data)
    query = Account.objects.filter(date__gte=start, date__lte=end).values('date').annotate(Count('date'))
    if len(query) < 2:
        return dict(period='no comparable data found during ' + start + ' ~ ' + end, added=list(), dropped=list())
    latest = query.order_by('-date')[0]['date'].isoformat()
    oldest = query.order_by('date')[0]['date'].isoformat()
    period = oldest + '~' + latest

    data_latest = Account.objects.filter(date=latest) or list()
    data_oldest = Account.objects.filter(date=oldest) or list()

    ids_latest = data_latest.values_list('account_id', flat=True) if data_latest else list()
    ids_oldest = data_oldest.values_list('account_id', flat=True) if data_oldest else list()

    added = Account.objects.filter(date=latest).filter(account_id__in=ids_latest).exclude(account_id__in=ids_oldest)
    dropped = Account.objects.filter(date=oldest).filter(account_id__in=ids_oldest).exclude(account_id__in=ids_latest)

    return dict(period=period, added=added, dropped=dropped)

Traitement par lots (envoyez la différence entre les données du jour en cours et les données du jour précédent à votre propre My Chat)

`app/chatwork/management/commands/contact_daily.py`


from django.core.management.base import BaseCommand

from chatwork.models import Account
from chatwork.views import get_diff

from datetime import date
from dateutil.relativedelta import relativedelta
import environ
import requests
env = environ.Env(DEBUG=(bool, False))

class Command(BaseCommand):
    def handle(self, *args, **options):
        today = date.today().isoformat()
        yesterday = (date.today() - relativedelta(days=1)).isoformat()
        data = get_diff(yesterday, today)
        report_title = data['period']
        report_added = 'added: ' + '(' + str(len(data['added'])) + ')' + ' / '.join(list(d.name for d in data['added']))
        report_dropped = 'dropped: ' + '(' + str(len(data['dropped'])) + ')' + ' / '.join(list(d.name for d in data['dropped']))
        report = """
{report_title}
{report_added}
{report_dropped}
        """.format(report_title=report_title, report_added=report_added, report_dropped=report_dropped).strip()

        base = 'https://api.chatwork.com/v2/'
        room_id = env('ROOM_ID')
        end_point = 'rooms/' + room_id + '/messages'
        api_token = env('CHATWORK_API_TOKEN')
        headers = {'X-ChatWorkToken': api_token, 'Content-Type': 'application/x-www-form-urlencoded'}
        payload = dict(body=report, self_unread=1)
        res = requests.post(base + end_point, headers=headers, params=payload)

Autre

Le test d'unité est simple mais implémenté
Comme la fuite d'informations personnelles n'est pas à la mode, le nom obtenu de l'API est spécifié pour être enregistré dans la base de données uniquement pour les deux premiers caractères.
Comme il est absolument mauvais de divulguer le jeton API du compte d'entreprise, nous avons décidé de le passer en tant que variable d'environnement.
Le traitement par lots est exécuté tous les jours, donc c'est via cron, mais comme les variables d'environnement sont indépendantes de l'utilisateur, il était nécessaire de prendre des mesures contre lui.
Il y avait de nombreux inconvénients tels que l'acquisition de bases de données à l'aide des modèles de Django et la gestion de l'itération. Reconnaissez que les classes QueryBuilder et Collection de Laravel sont indéniables, y compris le fait qu'elles sont faciles à comprendre même dans le code d'autres entreprises.

finalement

C'est une application que j'ai créée avec une idée approximative des vacances, donc c'est difficile, mais ce serait très encourageant si vous pouviez nous donner votre avis, alors laissez un commentaire.

Demande d'ajout de commentaire détaillé --Guidage sur les plans d'amélioration --Autres questions techniques, etc.