[PYTHON] Ich habe versucht, unsere Dunkelheit mit der Chatwork-API aufzudecken

Die Anwendung des Artikels wird auf github veröffentlicht

Ich habe eine Geschichte über das Erstellen einer Anwendung zusammengestellt, in der stille Rentner von Chatwork nachgeschlagen werden, die das Unternehmen nicht ankündigt. (* Wir sind nicht verantwortlich für Probleme mit dem Unternehmen, zu dem der Benutzer aufgrund des Betriebs gehört.)

Slack-, Scraping- und Excel-Dokumente sollten durch Anordnen der Datenerfassungsmethode umgeleitet werden können

Ursprung

――Wir haben mehr als 200 Mitarbeiter, aber ich fühlte mich sehr unwohl, weil es keine Ankündigung von Rentnern gab, weil einige der Mitarbeiter, die ich kannte, gekündigt hatten, bevor ich es wusste. ――Sie sind nur dann Ingenieur, wenn Sie Probleme mit der Technologie lösen! ――Wenn ich meinen vorherigen Job bemerkte, hatten die Leute gekündigt, also sollte es Leute geben, die die gleichen Probleme haben → Der Wunsch nach Genehmigung, befriedigt zu werden ―― ~~ Ich habe keine Pläne für aufeinanderfolgende Feiertage ~~

Funktionale Ziele

--Überwachen Sie die täglichen Registrierungsänderungen basierend auf Ihren Chatwork-Kontakten

• Veröffentlichen Sie die Überwachungsergebnisse in Mein Kanal
• Ermöglichen das Anzeigen von zusammenfassenden Berichten für einen bestimmten Zeitraum, z. B. jährlich oder monatlich
• Seien Sie vorsichtig beim Umgang mit persönlichen Informationen und API-Schlüsseln

Technologie verwendet

• Host-Umgebung: Windows10 + Ubuntu20.4 unter WSL2 (Wenn Docker verwendet werden kann, spielt das Host-Betriebssystem keine Rolle.)
• Docker
• Python(Django)

Ergebnis

Ich konnte innerhalb des Zeitraums neue Mitarbeiter / Rentner anzeigen und die täglichen Veränderungen bei den internen Mitgliedern erfassen.

↓ Berichtsbildschirm

↓ Ergebnisbildschirm für Chatwork-Benachrichtigungen

Arbeitsprozess

Umgebung

• Wenn Sie den Befehl docker-compose verwenden können, finden Sie weitere erforderliche Elemente in Auf github veröffentlichtes Projekt.

--Bitte bereiten Sie das Chatwork-API-Token (+ room_id des Benachrichtigungsziels, wenn Sie eine Stapelbenachrichtigung verwenden) vor, das für den Betrieb der Anwendung erforderlich ist. So erhalten Sie ein API-Token (offiziell)

Aufbau der Docker-Umgebung

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"

Erklärung der Hauptverarbeitung

• Holen Sie sich eine Liste der Kontaktmitglieder mit Ihrem Konto-Token
• Erklären Sie den Beitritt / Austritt von Mitgliedern, indem Sie Listendaten mit unterschiedlichen Erfassungszeiten vergleichen
• Da frühere Daten nicht über die API referenziert werden können, werden die zu vergleichenden Daten in der Datenbank gespeichert.
• Entwickelt, um die Differenz zwischen Kontaktmitgliedern zurückzugeben, wenn zwei Daten an get_diff () vergeben werden --show () , das eine Funktion zum Anzeigen eines Berichts hat, zeigt einen monatlichen Mitgliederwechselbericht für die letzten sechs Monate an (da es sich um einen monatlichen Bericht handelt, werden Informationen zu heißen Rentnern in dem später beschriebenen Stapel behandelt).
• Bei der Stapelverarbeitung wird dieselbe Methode wie bei Berichten verwendet, um Mitglieder, die sich Tag für Tag in Chatwork geändert haben, als aktuelle Nachrichten zu veröffentlichen.

Berichtsbildschirmverarbeitung + Erfassung und Speicherung von Chatwork-Kontaktlisten, Datenvergleichsmethode

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)

Stapelverarbeitung (senden Sie die Differenz zwischen den Daten des aktuellen Tages und den Daten des vorherigen Tages an Ihren eigenen Mein 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)

Andere

• Der Einheitentest ist einfach, aber implementiert
• Da der Verlust persönlicher Informationen nicht in Mode ist, wird der von der API erhaltene Name angegeben, um nur die ersten beiden Zeichen in der Datenbank zu speichern.
• Da es absolut NG ist, das API-Token des Unternehmenskontos zu verlieren, haben wir beschlossen, es als Umgebungsvariable zu übergeben.
• Die Stapelverarbeitung wird jeden Tag ausgeführt, also über cron. Da die Umgebungsvariablen jedoch vom Benutzer unabhängig sind, mussten Maßnahmen dagegen ergriffen werden.
• Es gab viele Unannehmlichkeiten wie die DB-Erfassung mit Djangos Modellen und die Handhabung der Iteration. Erkennen Sie, dass die QueryBuilder- und Collection-Klassen von Laravel nicht zu leugnen sind, einschließlich der Tatsache, dass sie selbst im Code anderer Unternehmen leicht zu verstehen sind.

Schließlich

Es ist eine App, die ich mit einer groben Idee an Feiertagen gemacht habe, also ist es rau, aber es wäre sehr ermutigend, wenn Sie uns Ihre Meinung mitteilen könnten. Bitte hinterlassen Sie einen Kommentar.

• Detaillierte Anfrage zum Hinzufügen von Kommentaren
• Anleitung zu Verbesserungsplänen
• Andere technische Fragen usw.