Merge remote-tracking branch 'origin/stable'

Author: danlipert

app/app/context.py

@@ -100,11 +100,10 @@ def preprocess(request):
 
             chat_unreads_request = chat_driver.teams.get_team_unreads_for_user(profile.chat_id)
 
-            if 'message' not in chat_unreads_request:
-                for teams in chat_unreads_request:
-                    if teams['msg_count'] > 0 or teams['mention_count'] > 0:
-                        chat_unread_messages = True
-                        break
+            for teams in chat_unreads_request:
+                if teams['msg_count'] > 0 or teams['mention_count'] > 0:
+                    chat_unread_messages = True
+                    break
         except Exception as e:
             logger.error(str(e))
 

app/app/settings.py

@@ -547,7 +547,7 @@
 
 # Chat
 CHAT_PORT = env('CHAT_PORT', default=8065)  # port of where mattermost is hosted
-CHAT_URL = env('CHAT_URL', default='http://localhost')  # location of where mattermost is hosted
+CHAT_URL = env('CHAT_URL', default='localhost')  # location of where mattermost is hosted
 CHAT_DRIVER_TOKEN = env('CHAT_DRIVER_TOKEN', default='')  # driver token
 GITCOIN_HACK_CHAT_TEAM_ID = env('GITCOIN_HACK_CHAT_TEAM_ID', default='')
 GITCOIN_CHAT_TEAM_ID = env('GITCOIN_CHAT_TEAM_ID', default='')

app/chat/management/commands/sync_event_bounties_to_chat.py

@@ -0,0 +1,87 @@
+'''
+    Copyright (C) 2018 Gitcoin Core
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published
+    by the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+'''
+import logging
+
+from django.conf import settings
+from django.core.management.base import BaseCommand
+from django.db.models import Q
+from django.utils.text import slugify
+
+from celery import group
+from chat.tasks import add_to_channel, create_channel, create_user, get_driver
+from chat.utils import create_channel_if_not_exists, create_user_if_not_exists
+from dashboard.models import Bounty, Interest, Profile
+
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    help = "Create channels for all active hackathon bounties"
+
+    def add_arguments(self, parser):
+        # Positional arguments
+        parser.add_argument('event_id', type=int, help="The event ID to synchronize bounties and channels for")
+
+    def handle(self, *args, **options):
+        try:
+            bounties_to_sync = Bounty.objects.filter(
+                Q(event__pk=options['event_id'])
+            )
+            tasks = []
+            for bounty in bounties_to_sync:
+                profiles_to_connect = []
+                try:
+                    funder_profile = Profile.objects.get(handle__iexact=bounty.bounty_owner_github_username.lower())
+
+                    if funder_profile:
+                        if funder_profile.chat_id:
+                            created, funder_profile_request = create_user_if_not_exists(funder_profile)
+                            funder_profile.chat_id = funder_profile_request['id']
+                            funder_profile.save()
+                        profiles_to_connect.append(funder_profile.chat_id)
+                        for interest in bounty.interested.all():
+                            if interest.profile:
+                                if interest.profile.chat_id:
+                                    created, chat_user = create_user_if_not_exists(interest.profile)
+                                    interest.profile.chat_id = chat_user['id']
+                                    interest.profile.save()
+                                profiles_to_connect.append(interest.profile.chat_id)
+                        if bounty.chat_channel_id is None or bounty.chat_channel_id is '':
+                            bounty_channel_name = slugify(f'{bounty.github_org_name}-{bounty.github_issue_number}')
+                            bounty_channel_name = bounty_channel_name[:60]
+                            create_channel_opts = {
+                                'team_id': settings.GITCOIN_HACK_CHAT_TEAM_ID,
+                                'channel_display_name': f'{bounty_channel_name}-{bounty.title}'[:60],
+                                'channel_name': bounty_channel_name[:60]
+                            }
+                            task = create_channel.s(create_channel_opts, bounty.id)
+                            task.link(add_to_channel.s(profiles_to_connect))
+                        else:
+                            task = add_to_channel.s({'id': bounty.chat_channel_id}, profiles_to_connect)
+                        tasks.append(task)
+                except Exception as e:
+                    logger.error(str(e))
+                    continue
+            if len(tasks) > 0:
+                job = group(tasks)
+                result = job.apply_async()
+            else:
+                print("Nothing to Sync")
+
+        except Exception as e:
+            logger.error(str(e))

app/chat/tasks.py

@@ -3,8 +3,9 @@
 from app.redis_service import RedisService
 from celery import app, group
 from celery.utils.log import get_task_logger
-from dashboard.models import Profile
+from dashboard.models import Bounty, Profile
 from mattermostdriver import Driver
+from mattermostdriver.exceptions import ResourceNotFound
 
 logger = get_task_logger(__name__)
 
@@ -13,11 +14,14 @@
 # Lock timeout of 2 minutes (just in the case that the application hangs to avoid a redis deadlock)
 LOCK_TIMEOUT = 60 * 2
 
-chat_driver = Driver({
+driver_opts = {
+    'scheme': 'https' if settings.CHAT_PORT == 443 else 'http',
     'url': settings.CHAT_URL,
     'port': settings.CHAT_PORT,
     'token': settings.CHAT_DRIVER_TOKEN
-})
+}
+
+chat_driver = Driver(driver_opts)
 
 
 def get_driver():
@@ -26,23 +30,36 @@ def get_driver():
 
 
 @app.shared_task(bind=True, max_retries=3)
-def create_channel(self, options, retry: bool = True) -> None:
+def create_channel(self, options, bounty_id = None, retry: bool = True) -> None:
     """
     :param options:
     :param retry:
     :return:
     """
     with redis.lock("tasks:create_channel:%s" % options['channel_name'], timeout=LOCK_TIMEOUT):
 
+        chat_driver.login()
         try:
-            chat_driver.login()
+            channel_lookup = chat_driver.channels.get_channel_by_name(
+                options['team_id'],
+                options['channel_name']
+            )
+            if bounty_id:
+                active_bounty = Bounty.objects.get(id=bounty_id)
+                active_bounty.chat_channel_id = channel_lookup['id']
+                active_bounty.save()
+            return channel_lookup
+        except ResourceNotFound as RNF:
             new_channel = chat_driver.channels.create_channel(options={
                 'team_id': options['team_id'],
                 'name': options['channel_name'],
                 'display_name': options['channel_display_name'],
                 'type': 'O'
             })
-
+            if bounty_id:
+                active_bounty = Bounty.objects.get(id=bounty_id)
+                active_bounty.chat_channel_id = new_channel['id']
+                active_bounty.save()
             return new_channel
         except ConnectionError as exc:
             logger.info(str(exc))
@@ -54,26 +71,25 @@ def create_channel(self, options, retry: bool = True) -> None:
 
 
 @app.shared_task(bind=True, max_retries=3)
-def add_to_channel(self, options, retry: bool = True) -> None:
+def add_to_channel(self, channel_details, chat_user_ids, retry: bool = True) -> None:
     """
-    :param options:
+    :param channel_details:
     :param retry:
     :return:
     """
-    with redis.lock("tasks:add_to_channel:%s" % options['channel_id'], timeout=LOCK_TIMEOUT):
-        chat_driver.login()
-        try:
-            for x in options['profiles']:
-                if x is not None:
-                    response = chat_driver.channels.add_user(options['channel_id'], options={
-                        'user_id': x
-                    })
-        except ConnectionError as exc:
-            logger.info(str(exc))
-            logger.info("Retrying connection")
-            self.retry(30)
-        except Exception as e:
-            logger.error(str(e))
+    chat_driver.login()
+    try:
+        for chat_id in chat_user_ids:
+            if chat_id:
+                response = chat_driver.channels.add_user(channel_details['id'], options={
+                    'user_id': chat_id
+                })
+    except ConnectionError as exc:
+        logger.info(str(exc))
+        logger.info("Retrying connection")
+        self.retry(30)
+    except Exception as e:
+        logger.error(str(e))
 
 
 @app.shared_task(bind=True, max_retries=1)
@@ -113,9 +129,12 @@ def update_user(self, query_opts, update_opts, retry: bool = True) -> None:
         try:
 
             if query_opts['chat_id'] is None:
-                chat_user = chat_driver.users.get_user_by_username(query_opts['handle'])
-                if 'message' not in chat_user:
+                try:
+
+                    chat_user = chat_driver.users.get_user_by_username(query_opts['handle'])
                     chat_id = chat_user['id']
+                except Exception as e:
+                    logger.info(f"Unable to find chat user for {query_opts['handle']}")
             else:
                 chat_id = query_opts['chat_id']
 

app/chat/utils.py

@@ -0,0 +1,84 @@
+'''
+    Copyright (C) 2018 Gitcoin Core
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published
+    by the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+'''
+import logging
+
+from django.conf import settings
+
+from celery import group
+from chat.tasks import add_to_channel, create_channel, create_user, get_driver
+from dashboard.models import Profile
+from mattermostdriver.exceptions import ResourceNotFound
+
+logger = logging.getLogger(__name__)
+
+
+def create_channel_if_not_exists(channel_opts):
+    try:
+        chat_driver = get_driver()
+
+        channel_lookup_response = chat_driver.channels.get_channel_by_name(
+            channel_opts['team_id'], channel_opts['channel_name']
+        )
+        return False, channel_lookup_response
+
+    except ResourceNotFound as RNF:
+        try:
+            result = create_channel.apply_async(args=[channel_opts])
+            bounty_channel_id_response = result.get()
+
+            if 'message' in bounty_channel_id_response:
+                raise ValueError(bounty_channel_id_response['message'])
+
+            return True, bounty_channel_id_response
+        except Exception as e:
+            logger.error(str(e))
+
+
+def create_user_if_not_exists(profile):
+    try:
+        chat_driver = get_driver()
+
+        current_chat_user = chat_driver.users.get_user_by_username(profile.handle)
+        profile.chat_id = current_chat_user['id']
+        profile.save()
+        return False, current_chat_user
+    except ResourceNotFound as RNF:
+        new_user_request = create_user.apply_async(args=[{
+            "email": profile.user.email,
+            "username": profile.handle,
+            "first_name": profile.user.first_name,
+            "last_name": profile.user.last_name,
+            "nickname": profile.handle,
+            "auth_data": f'{profile.user.id}',
+            "auth_service": "gitcoin",
+            "locale": "en",
+            "props": {},
+            "notify_props": {
+                "email": "false",
+                "push": "mention",
+                "desktop": "all",
+                "desktop_sound": "true",
+                "mention_keys": f'{profile.handle}, @{profile.handle}',
+                "channel": "true",
+                "first_name": "false"
+            },
+        }, {
+            "tid": settings.GITCOIN_HACK_CHAT_TEAM_ID
+        }])
+
+        return True, new_user_request.get()

app/chat/views.py

@@ -22,27 +22,24 @@
 from django.template.response import TemplateResponse
 from django.utils.translation import gettext_lazy as _
 
-from chat.tasks import get_driver
+from marketing.models import Stat
 
 
 def chat(request):
     """Render chat landing page response."""
 
     try:
-        chat_driver = get_driver()
+        users_online_count = Stat.objects.get(key='chat_active_users')
+        users_total_count = Stat.objects.get(key='chat_total_users')
 
-        chat_stats = chat_driver.teams.get_team_stats(settings.GITCOIN_CHAT_TEAM_ID)
-        if 'message' not in chat_stats:
-            users_online = chat_stats['active_member_count']
-        else:
-            users_online = 'N/A'
     except Exception as e:
-        print(str(e))
-        users_online = 'N/A'
+        users_online_count = 'N/A'
+        users_total_count = 'N/A'
     context = {
-        'users_online': users_online,
+        'users_online': users_online_count,
+        'users_count': users_total_count,
         'title': "Chat",
-        'cards_desc': f"Gitcoin chat has {users_online} users online now!"
+        'cards_desc': f"Gitcoin chat has {users_online_count} users online now!"
     }
 
     return TemplateResponse(request, 'chat.html', context)

app/dashboard/tasks.py

@@ -3,6 +3,7 @@
 from app.redis_service import RedisService
 from celery import app, group
 from celery.utils.log import get_task_logger
+from chat.tasks import create_channel
 from dashboard.models import Profile
 from marketing.mails import func_name, send_mail
 from retail.emails import render_share_bounty
@@ -27,7 +28,7 @@ def bounty_on_create(self, team_id, new_bounty, retry: bool = True) -> None:
             'team_id': team_id,
             'channel_name': f'bounty-{new_bounty.id}',
             'channel_display_name': f'bounty-{new_bounty.id}'
-        })
+        }, new_bounty.id)
     )
 
     # what has to happen that we can issue without a dependency from any subtasks?