Add the Telegram SeumBookBot!

bot/admin.py

@@ -0,0 +1,9 @@
+from django.contrib import admin
+
+# Register your models here.
+from .models import TelegramUser, TelegramUserCheck, TelegramUserChat, TelegramChat
+
+admin.site.register(TelegramUser)
+admin.site.register(TelegramUserCheck)
+admin.site.register(TelegramUserChat)
+admin.site.register(TelegramChat)

bot/apps.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class BotConfig(AppConfig):
+    name = 'bot'

bot/migrations/0001_initial.py

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.10 on 2017-05-08 14:02
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ('counter', '0008_auto_20170122_1732'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='TelegramChat',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('chat_id', models.BigIntegerField(unique=True, verbose_name='telegram_chat_id')),
+                ('notify_only_members', models.BooleanField(verbose_name='notify_only_members')),
+            ],
+            options={
+                'verbose_name': 'telegram_chat',
+                'verbose_name_plural': 'telegram_chats',
+            },
+        ),
+        migrations.CreateModel(
+            name='TelegramUser',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('telegram_user_id', models.BigIntegerField(unique=True, verbose_name='telegram_user_id')),
+                ('counter', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='counter.Counter', verbose_name='counter')),
+            ],
+            options={
+                'verbose_name': 'telegram_user',
+                'verbose_name_plural': 'telegram_users',
+            },
+        ),
+        migrations.CreateModel(
+            name='TelegramUserChat',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('telegram_user_id', models.BigIntegerField(verbose_name='telegram_user_id')),
+                ('telegram_chat_id', models.BigIntegerField(verbose_name='telegram_chat_id')),
+            ],
+            options={
+                'verbose_name': 'telegram_user_chat',
+                'verbose_name_plural': 'telegram_user_chats',
+            },
+        ),
+        migrations.CreateModel(
+            name='TelegramUserCheck',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('telegram_user_id', models.BigIntegerField(verbose_name='telegram_user_id')),
+                ('verif_key', models.TextField(unique=True, verbose_name='verify_key')),
+            ],
+            options={
+                'verbose_name': 'telegram_user_check',
+                'verbose_name_plural': 'telegram_user_checks',
+            },
+        ),
+        migrations.AlterUniqueTogether(
+            name='telegramuserchat',
+            unique_together=set([('telegram_user_id', 'telegram_chat_id')]),
+        ),
+    ]

bot/models.py

@@ -0,0 +1,65 @@
+from datetime import datetime
+
+from django.contrib.auth.models import User
+from django.db import models
+from django.utils.translation import ugettext_lazy as _, get_language
+
+import arrow
+from babel.dates import format_timedelta
+
+# Link a SeumBook counter to a Telegram User
+class TelegramUser(models.Model):
+    counter = models.ForeignKey('counter.Counter', verbose_name=_('counter'))
+    telegram_user_id = models.BigIntegerField(_('telegram_user_id'), unique=True)
+
+    class Meta:
+        verbose_name = _('telegram_user')
+        verbose_name_plural = _('telegram_users')
+
+    def __str__(self):
+        return _('%(counter)s is %(telegram_user_id)d') % {'counter': self.counter, 'telegram_user_id': self.telegram_user_id}
+
+# When a user wants to link his SeumBook account to his Telegram account,
+# he/she send a message to the bot in a private chat, then the bot answers with
+# an URL to the SeumBook website containing a `verif_key`. The user then log in
+# on the SeumBook website, and based on the `verif_key` parameter, we find the
+# corresponding Telegram User.
+# This object remember which Telegram User received which `verif_key`
+class TelegramUserCheck(models.Model):
+    telegram_user_id = models.BigIntegerField(_('telegram_user_id'))
+    verif_key = models.TextField(_('verify_key'), unique=True)
+
+    class Meta:
+        verbose_name = _('telegram_user_check')
+        verbose_name_plural = _('telegram_user_checks')
+
+    def __str__(self):
+        return _('%(telegram_user_id)d has verif key %(verif_key)s') % {'telegram_user_id': self.telegram_user_id, 'verif_key': self.verif_key}
+
+# Memorize which telegram user is in which chat
+class TelegramUserChat(models.Model):
+    telegram_user_id = models.BigIntegerField(_('telegram_user_id'))
+    telegram_chat_id = models.BigIntegerField(_('telegram_chat_id'))
+
+    class Meta:
+        verbose_name = _('telegram_user_chat')
+        verbose_name_plural = _('telegram_user_chats')
+        unique_together = ('telegram_user_id', 'telegram_chat_id')
+
+    def __str__(self):
+        return _('%(telegram_user_id)d is in the chat %(telegram_chat)d') % {'telegram_user_id': self.telegram_user_id, 'telegram_chat_id': self.telegram_chat_id}
+
+# Memorize the Telegram chats in which the bot are, and the options of them
+class TelegramChat(models.Model):
+    chat_id = models.BigIntegerField(_('telegram_chat_id'), unique=True)
+    # notify_only_members: True: only when somebody we know is in the chat has the
+    # seum, we notify the channel
+    # notify_only_members: False: we notify the channel for every new seum
+    notify_only_members = models.BooleanField(_('notify_only_members'))
+
+    class Meta:
+        verbose_name = _('telegram_chat')
+        verbose_name_plural = _('telegram_chats')
+
+    def __str__(self):
+        return _('%(chat_id)d is a telegram chat, with option notify_only_members to %(notify_only_members)s') % {'chat_id': self.chat_id, 'notify_only_members': self.notify_only_members}

bot/urls.py

@@ -0,0 +1,11 @@
+from django.conf.urls import url
+from counter.rss import SeumFeed
+from django.contrib.auth import views as auth_views
+from django.views.generic.base import RedirectView
+
+from .views import telegram
+
+urlpatterns = [
+    url(r'^webhook/$', telegram.webhook, name='telwebhook'),
+    url(r'^link/telegram/(?P<verif_key>.+)/$', telegram.link, name='tellink'),
+]

bot/views/telegram.py

@@ -0,0 +1,175 @@
+from django.contrib.auth.models import User
+from django.core.urlresolvers import reverse
+from django.shortcuts import render
+from django.utils.translation import ugettext as _
+from django.views.decorators.csrf import csrf_exempt
+from django.http import HttpResponse
+from django.contrib.auth.decorators import login_required
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+from django.db.utils import IntegrityError
+from django.conf import settings
+
+import json
+import requests
+import random
+import string
+import re
+
+from counter.models import Counter, Reset
+from bot.models import TelegramUser, TelegramUserCheck, TelegramUserChat, TelegramChat
+
+telegram_ips = ['149.154.167.' + str(i) for i in range(197, 234)]
+telegram_url = 'https://api.telegram.org/bot' + settings.BOT_TELEGRAM_KEY + '/'
+telegram_bot_id = settings.BOT_TELEGRAM_ID
+telegram_bot_name = settings.BOT_TELEGRAM_NAME
+
+@receiver(post_save, sender=Reset)
+def notify_telegram(sender, instance, created, **kwargs):
+    if not settings.BOT_TELEGRAM_KEY or not settings.telegram_bot_id or not settings.telegram_bot_name:
+        return
+    if created:
+        chat_ids = [e.chat_id for e in TelegramChat.objects.filter(notify_only_members=False)]
+        try:
+            telegram_user = TelegramUser.objects.get(counter=instance.counter)
+            chats = TelegramUserChat.objects.filter(telegram_user_id=telegram_user.telegram_user_id)
+            chat_ids = chat_ids + [e.telegram_chat_id for e in chats]
+        except TelegramUser.DoesNotExist:
+            do_nothing = True
+
+        if instance.who is None or instance.who == instance.counter:
+            message = str(instance.counter) + ' has le seum: ' + instance.reason
+        else:
+            message = str(instance.who) + ' put le seum to ' + str(instance.counter) + ': ' + instance.reason
+
+        for chat_id in set(chat_ids):
+            requests.post(telegram_url + 'sendMessage', json={'chat_id': chat_id, 'text': message})
+
+@login_required
+def link(request, verif_key):
+    try:
+        telegram_user_check = TelegramUserCheck.objects.get(verif_key=verif_key)
+        the_counter = Counter.objects.get(user__id=request.user.id)
+        TelegramUser.objects.create(counter=the_counter, telegram_user_id=telegram_user_check.telegram_user_id)
+        TelegramUserCheck.objects.filter(telegram_user_id=telegram_user_check.telegram_user_id).delete()
+        return HttpResponse('Your Telegram account has been linked!')
+    except TelegramUserCheck.DoesNotExist:
+        return HttpResponse(status=404)
+
+@csrf_exempt
+def webhook(request):
+    ip = request.META.get('REMOTE_ADDR')
+
+    # Uncomment the following two lines, and correctly configure the
+    # reverse proxy to enable the security, or everyone will be able
+    # to put le seum to everyone
+    if not ip in telegram_ips:
+        return HttpResponse(status=401)
+
+    data = json.loads(request.body.decode('utf-8'))
+    print(data)
+
+    # We have different types of messages
+    # - a simple text message from a person
+    # - the bot joined/left a channel
+    # - somebody joined/left a channel
+    # The idea is to keep a list of all the telegram users in all channels
+    # Then when a new seum is created, we look all the channels in which this user
+    # is, and we send a message in those to notify everybody
+
+    if not 'message' in data or not 'chat' in data['message']:
+        return HttpResponse(201) # we should return something correct, or Telegram will try to send us the message again multiple times
+
+    chat = data['message']['chat']
+
+    if chat['type'] != 'private':
+        if 'new_chat_member' in data['message']:
+            user_id = data['message']['new_chat_member']['id']
+            if user_id == telegram_bot_id:
+                r = requests.get(telegram_url + 'getChatMembersCount?chat_id=' + str(chat['id'])).json()
+                if r['result'] < 20: # when there are less than 20 people, we deactivate notify_only_members
+                    try:
+                        TelegramChat.objects.create(chat_id=chat['id'], notify_only_members=True)
+                    except IntegrityError as e:
+                        print(e)
+                        return HttpResponse('')
+                    requests.post(telegram_url + 'sendMessage', json={'chat_id': chat['id'], 'text': 'Hello everyone! Because of Telegram restrictions, I don\'t know who is here :( . Everybody, please say /seumhello, so I can see you\'re here!'})
+                else:
+                    TelegramChat.objects.create(chat_id=chat['id'], notify_only_members=False)
+                    requests.post(telegram_url + 'sendMessage', json={'chat_id': chat['id'], 'text': 'Hello everyone! I will notify you everytime a person in the world has the seum. I you prefer to be notified only when a member of this group has the seum, use the command /notify_every_seum_or_not'})
+            else:
+                TelegramUserChat.objects.create(telegram_user_id=user_id, telegram_chat_id=chat['id'])
+            return HttpResponse('')
+
+        if 'left_chat_member' in data['message']:
+            user_id = data['message']['left_chat_member']['id']
+            if user_id == telegram_bot_id:
+                TelegramUserChat.objects.filter(telegram_chat_id=chat['id']).delete()
+                TelegramChat.objects.filter(chat_id=chat['id']).delete()
+            else:
+                TelegramUserChat.objects.filter(telegram_user_id=user_id, telegram_chat_id=chat['id']).delete()
+            return HttpResponse(200)
+
+    if not 'message' in data or not 'from' in data['message'] or not 'id' in data['message']['from']:
+        return HttpResponse(201)
+
+    telegram_user_id = data['message']['from']['id']
+
+    if chat['type'] != 'private':
+        # For each message we receive in a non private chat, we save that this user is in this chat
+        try:
+            TelegramUserChat.objects.create(telegram_user_id=telegram_user_id, telegram_chat_id=chat['id'])
+        except:
+            do_nothing = True
+
+    text = data['message']['text']
+    if text == '/notify_every_seum_or_not' or text == '/notify_every_seum_or_not@' + telegram_bot_name:
+        tchat = TelegramChat.objects.get(chat_id=chat['id'])
+        tchat.notify_only_members = not tchat.notify_only_members
+        if tchat.notify_only_members:
+            requests.post(telegram_url + 'sendMessage', json={'chat_id': chat['id'], 'text': 'Ok, I will notify you only if someone in the group has the seum. But, because of Telegram restrictions, I don\'t know who is here :( . Everybody, please say /seumhello, so I can see you\'re here!'})
+        else:
+            requests.post(telegram_url + 'sendMessage', json={'chat_id': chat['id'], 'text': 'Ok, so now I will notify you everytime a person in the world has the seum.'})
+        tchat.save()
+
+    try:
+        telegram_user = TelegramUser.objects.get(telegram_user_id=telegram_user_id)
+        # in that cas we need to parse the message
+        # and either create a new seum and reset a counter
+        # either like some existing seum
+
+        if text == '/seumunlink' or text == '/seumunlink@' + telegram_bot_name:
+            TelegramUser.objects.filter(telegram_user_id=telegram_user_id).delete()
+            requests.post(telegram_url + 'sendMessage', json={'chat_id': chat['id'], 'text': 'Your Telegram account has successfully been unlinked from your SeumBook account', 'reply_to_message_id': data['message']['message_id']})
+            return HttpResponse('')
+
+        if text == '/seumhello' or text == '/seumhello@' + telegram_bot_name:
+            requests.post(telegram_url + 'sendMessage', json={'chat_id': chat['id'], 'text': 'Hello ' + telegram_user.counter.name + ' :-)', 'reply_to_message_id': data['message']['message_id']})
+            return HttpResponse('')
+
+        seum_cmd = r"^/seum((@" + telegram_bot_name + ")?) (.+)$"
+        if re.match(seum_cmd, text) is not None:
+            # it's a /seum cmd
+            m = re.sub(seum_cmd, r"\3", text)
+            maybe_counter = m.split(' ')[0]
+            try:
+                yes_counter = Counter.objects.get(trigramme=maybe_counter)
+                seum_message = ' '.join(m.split(' ')[1:])
+            except Counter.DoesNotExist:
+                yes_counter = telegram_user.counter
+                seum_message = m
+            reset = Reset(counter=yes_counter, who=telegram_user.counter, reason=seum_message)
+            reset.save()
+    except TelegramUser.DoesNotExist:
+        print('in that case we send a link to the user')
+        if chat['type'] == 'private' and chat['id'] == telegram_user_id:
+            # We are in a private channel, we directly send the link
+            verif_key = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(30))
+            requests.post(telegram_url + 'sendMessage', json={'chat_id': chat['id'], 'text': 'Open the following URL to link your Telegram account to your SeumBook account: ' + request.build_absolute_uri(reverse('tellink', args=[verif_key]))})
+            TelegramUserCheck.objects.create(telegram_user_id=telegram_user_id, verif_key=verif_key)
+        else:
+            print('bou')
+            # We are not in a private channel, so we mention the user to talk with us
+            requests.post(telegram_url + 'sendMessage', json={'chat_id': chat['id'], 'text': 'Your Telegram account isn\'t linked to a SeumBook account. Say hello to me in a private chat to link it :-)! https://telegram.me/' + telegram_bot_name + '?start=Hello', 'reply_to_message_id': data['message']['message_id']})
+
+    return HttpResponse('')

requirements.txt

@@ -6,3 +6,4 @@ django-debug-toolbar==1.6
 django-graphos-3
 pandas==0.19
 django_extensions==1.7.8
+requests==2.13.0

seum/settings.py.default

@@ -124,6 +124,10 @@ EMAIL_HOST_PASSWORD = ''
 EMAIL_USE_TLS = False
 DEFAULT_FROM_EMAIL = 'SeumMan <seum@merigoux.ovh>'
 
+# Telegram Bot
+# BOT_TELEGRAM_KEY = 'telegram-bot-key'
+# BOT_TELEGRAM_ID = 1234
+# BOT_TELEGRAM_NAME = 'telegramBot'
 
 #Production settings
 SECURE_CONTENT_TYPE_NOSNIFF = True

seum/urls.py

@@ -20,6 +20,7 @@ from django.contrib import admin
 from django.views.generic.base import RedirectView
 
 urlpatterns = [
+    url(r'^bot/', include('bot.urls')),
     url(r'^i18n/', include('django.conf.urls.i18n'), name='set_language'),]
 
 urlpatterns += i18n_patterns(