Change focus revamped

matrigram/bot.py

@@ -71,9 +71,9 @@ def __init__(self, *args, **kwargs):
         ]
 
         callback_query_routes = [
-            (r'^LEAVE (?P<room>\S+)$', self.do_leave),
-            (r'^FOCUS (?P<room>\S+)$', self.do_change_focus),
-            (r'^JOIN (?P<room>\S+)$', self.do_join),
+            (r'^LEAVE (?P<room>\S+)$', self.leave_callback),
+            (r'^FOCUS (?P<room>\S+)$', self.change_focus_room_callback),
+            (r'^JOIN (?P<room>\S+)$', self.invite_callback),
             (r'^NOP$', self.do_nop),
         ]
 
@@ -170,16 +170,13 @@ def login(self, msg, match):
                 'typing_thread': None,
                 'should_type': False,
             }
-
             rooms = client.get_rooms_aliases()
             logger.debug("rooms are: %s", rooms)
 
             if rooms:
                 room_aliases = '\n'.join([room_alias[0] for room_alias in rooms.values()])
                 self.sendMessage(chat_id, 'You are currently in rooms:\n{}'.format(room_aliases))
-                self.sendMessage(chat_id,
-                                 'You are now participating in: {}'.format(
-                                     client.get_focus_room_alias()))
+                self.do_change_focus(client.get_next_room(None), chat_id)
             logger.debug('%s user state:\n%s', chat_id, self.users[chat_id])
         else:
             self.sendMessage(chat_id, login_message)
@@ -209,6 +206,7 @@ def join_room(self, msg, match):
             self.sendMessage(chat_id, 'Can\'t join room')
         else:
             self.sendMessage(chat_id, "Joined {}".format(room_name))
+            self.do_change_focus(room_name, chat_id)
 
     @logged_in
     def leave_room(self, msg, _):
@@ -227,21 +225,18 @@ def leave_room(self, msg, _):
         }
         self.sendMessage(chat_id, 'Choose a room to leave:', reply_markup=keyboard)
 
-    def do_leave(self, msg, match):
+    def leave_callback(self, msg, match):
         query_id, _, _ = telepot.glance(msg, flavor='callback_query')
         chat_id = msg['message']['chat']['id']
         room_name = match.group('room')
         client = self._get_client(chat_id)
 
-        prev_focus_room = client.get_focus_room_alias()
-        client.leave_room(room_name)
+        logger.info('leaving %s', room_name)
         self.sendMessage(chat_id, 'Left {}'.format(room_name))
-        curr_focus_room = client.get_focus_room_alias()
+        if room_name == client.get_focus_room_alias():
+            self.do_change_focus(client.get_next_room(room_name), chat_id)
 
-        if curr_focus_room != prev_focus_room and curr_focus_room is not None:
-            self.sendMessage(chat_id,
-                             'You are now participating in: {}'.format(
-                                 client.get_focus_room_alias()))
+        client.leave_room(room_name)
 
         self.answerCallbackQuery(query_id, 'Done!')
 
@@ -262,22 +257,28 @@ def change_focus_room(self, msg, _):
         }
         self.sendMessage(chat_id, 'Choose a room to focus:', reply_markup=keyboard)
 
-    def do_change_focus(self, msg, match):
+    def change_focus_room_callback(self, msg, match):
         query_id, _, _ = telepot.glance(msg, flavor='callback_query')
         chat_id = msg['message']['chat']['id']
         room_name = match.group('room')
+        self.do_change_focus(room_name, chat_id)
+        self.answerCallbackQuery(query_id, 'Done!')
 
-        self.sendChatAction(chat_id, 'typing')
+    def do_change_focus(self, room_name, chat_id):
         client = self._get_client(chat_id)
+        if room_name == client.get_focus_room_alias():
+            return
+        self.sendChatAction(chat_id, 'typing')
 
         client.set_focus_room(room_name)
-        self.sendMessage(chat_id, 'You are now participating in {}'.format(room_name))
-        self.sendMessage(chat_id, '{} Room history:'.format(room_name))
-        client.backfill_previous_messages()
-
-        self.answerCallbackQuery(query_id, 'Done!')
+        if room_name is None:
+            self.sendMessage(chat_id, 'You are currently not participating in any room')
+        else:
+            self.sendMessage(chat_id, 'You are now participating in {}'.format(room_name))
+            self.sendMessage(chat_id, '{} Room history:'.format(room_name))
+            client.backfill_previous_messages()
 
-    def do_join(self, msg, match):
+    def invite_callback(self, msg, match):
         query_id, _, _ = telepot.glance(msg, flavor='callback_query')
         chat_id = msg['message']['chat']['id']
         room_name = match.group('room')
@@ -290,6 +291,7 @@ def do_join(self, msg, match):
             self.answerCallbackQuery(query_id, 'Can\'t join room')
         else:
             self.answerCallbackQuery(query_id, 'Joined {}'.format(room_name))
+            self.do_change_focus(room_name, chat_id)
 
     def do_nop(self, msg, _):
         query_id, _, _ = telepot.glance(msg, flavor='callback_query')
@@ -458,14 +460,15 @@ def send_topic(self, sender, topic, client):
         self.sendChatAction(chat_id, 'typing')
         self.sendMessage(chat_id, "{} changed topic to: \"{}\"".format(sender, topic))
 
-    def send_kick(self, room, client):
-        logger.info('got kicked from %s', room)
+    def send_kick(self, room_name, client):
+        logger.info('got kicked from %s', room_name)
         chat_id = self._get_chat_id(client)
         if not chat_id:
             return
 
-        self.sendMessage(chat_id, 'You got kicked from {}'.format(room))
-        client.set_focus_room(None)
+        self.sendMessage(chat_id, 'You got kicked from {}'.format(room_name))
+        if client.get_focus_room_alias() == room_name:
+            self.do_change_focus(client.get_next_room(None), chat_id)
 
     @logged_in
     def set_name(self, msg, match):

matrigram/client.py

@@ -35,13 +35,16 @@ def login(self, username, password):
         try:
             self.token = self.client.login_with_password(username, password)
             logger.info('token = %s', self.token)
+            self.focus_room_id = None
+            '''
             rooms = self.get_rooms_aliases()
             if rooms:
                 # set focus room to "first" room
                 self.set_focus_room(rooms.keys()[0])
-
+            '''
             self.client.add_invite_listener(self.on_invite_event)
             self.client.add_leave_listener(self.on_leave_event)
+
             self.client.start_listener_thread()
             return True, "OK"
         except MatrixRequestError:
@@ -89,6 +92,7 @@ def on_leave_event(self, room_id, le):
         logger.debug(pprint_json(le))
 
         if le['timeline']['events'][0]['sender'] != le['timeline']['events'][0]['state_key']:
+            logger.info('sending kick event to bot from room: %s', room_id)
             self.tb.send_kick(self._room_id_to_alias(room_id), self)
 
     def on_invite_event(self, _, ie):
@@ -104,7 +108,6 @@ def on_invite_event(self, _, ie):
     def join_room(self, room_id_or_alias):
         try:
             self.client.join_room(room_id_or_alias)
-            self.set_focus_room(room_id_or_alias)
             return True
         except MatrixRequestError:
             return False
@@ -115,17 +118,10 @@ def leave_room(self, room_id_or_alias):
             logger.error('cant find room')
             return False
 
-        if self.focus_room_id == room.room_id:
-            rooms = self.get_rooms_aliases()
-            room_id = self._room_alias_to_id(room_id_or_alias)
-
-            del rooms[room_id]
-            new_focus_room = rooms.keys()[0] if rooms else None
-            self.set_focus_room(new_focus_room)
-
         return room.leave()
 
     def set_focus_room(self, room_id_or_alias):
+        logger.info('setting focus room to: %s', room_id_or_alias)
         if self._room_alias_to_id(room_id_or_alias) == self.focus_room_id:
             return
 
@@ -136,7 +132,7 @@ def set_focus_room(self, room_id_or_alias):
             self.room_listener_uid = None
             room_obj.remove_ephemeral_listener(self.ephemeral_listener_uid)
             self.ephemeral_listener_uid = None
-            logger.info("remove focus room %s", self.focus_room_id)
+            logger.info('remove focus room %s', self.focus_room_id)
             self.focus_room_id = None
 
         # set new room on focus
@@ -203,6 +199,23 @@ def get_room_obj(self, room_id_or_alias):
 
         return rooms.get(room_id)
 
+    def get_next_room(self, room_id_or_alias):
+        """Returns a joined room that is not 'room_id_or_alias' if one exists
+
+        Args:
+            room_id_or_alias (str): Room's id or alias.
+
+        Returns (str): Room's alias, None of none exists
+
+        """
+        rooms = self.get_rooms_aliases()
+        room_id = self._room_alias_to_id(room_id_or_alias)
+        if room_id is not None:
+            del rooms[room_id]
+        new_focus_room = rooms.keys()[0] if rooms else None
+        logger.info('next room is: %s', new_focus_room)
+        return self._room_id_to_alias(new_focus_room)
+
     def send_message(self, msg):
         room_obj = self.get_room_obj(self.focus_room_id)