Merge pull request #82 from duynguyenhoang/feature/support_mark_read

Add mark as read feature

Author: haskellcamargo

app.py

@@ -6,6 +6,7 @@
 import os
 import requests
 import sys
+import time
 import traceback
 import tempfile
 import urwid
@@ -24,6 +25,7 @@
 loop = asyncio.get_event_loop()
 
 SCLACK_SUBTYPE = 'sclack_message'
+MARK_READ_ALARM_PERIOD = 3
 
 
 class SclackEventLoop(urwid.AsyncioEventLoop):
@@ -81,6 +83,7 @@ def __init__(self, config):
             unhandled_input=self.unhandled_input
         )
         self.configure_screen(self.urwid_loop.screen)
+        self.last_keypress = (0, None)
 
     def start(self):
         self._loading = True
@@ -246,11 +249,14 @@ def mount_chatbox(self, executor, channel):
             user=self.store.state.auth['user'],
             is_read_only=self.store.state.channel.get('is_read_only', False)
         )
-        self.chatbox = ChatBox(messages, header, self.message_box)
+        self.chatbox = ChatBox(messages, header, self.message_box, self.urwid_loop)
         urwid.connect_signal(self.chatbox, 'set_insert_mode', self.set_insert_mode)
+        urwid.connect_signal(self.chatbox, 'mark_read', self.handle_mark_read)
         urwid.connect_signal(self.chatbox, 'open_quick_switcher', self.open_quick_switcher)
+
         urwid.connect_signal(self.message_box.prompt_widget, 'submit_message', self.submit_message)
         urwid.connect_signal(self.message_box.prompt_widget, 'go_to_last_message', self.go_to_last_message)
+
         self.real_time_task = loop.create_task(self.start_real_time())
 
     def edit_message(self, widget, user_id, ts, original_text):
@@ -318,20 +324,22 @@ def on_change_topic(self, text):
         self.store.set_topic(self.store.state.channel['id'], text)
         self.go_to_sidebar()
 
-    def render_message(self, message):
+    def render_message(self, message, channel_id=None):
         is_app = False
         subtype = message.get('subtype')
 
         if subtype == SCLACK_SUBTYPE:
             message = Message(
                 message['ts'],
+                '',
                 User('1', 'sclack'),
                 MarkdownText(message['text']),
                 Indicators(False, False)
             )
             urwid.connect_signal(message, 'go_to_sidebar', self.go_to_sidebar)
             urwid.connect_signal(message, 'quit_application', self.quit_application)
             urwid.connect_signal(message, 'set_insert_mode', self.set_insert_mode)
+            urwid.connect_signal(message, 'mark_read', self.handle_mark_read)
 
             return message
 
@@ -417,8 +425,11 @@ def render_message(self, message):
         if file:
             files.append(file)
 
+        message_channel = channel_id if channel_id is not None else message.get('channel')
+
         message = Message(
             message['ts'],
+            message_channel,
             user,
             text,
             indicators,
@@ -434,6 +445,7 @@ def render_message(self, message):
         urwid.connect_signal(message, 'delete_message', self.delete_message)
         urwid.connect_signal(message, 'quit_application', self.quit_application)
         urwid.connect_signal(message, 'set_insert_mode', self.set_insert_mode)
+        urwid.connect_signal(message, 'mark_read', self.handle_mark_read)
 
         return message
 
@@ -458,7 +470,7 @@ def lazy_load_images(self, files, widget):
                     not file.get('is_external', True)
                 ))
 
-    def render_messages(self, messages):
+    def render_messages(self, messages, channel_id=None):
         _messages = []
         previous_date = self.store.state.last_date
         last_read_datetime = datetime.fromtimestamp(float(self.store.state.channel.get('last_read', '0')))
@@ -485,11 +497,59 @@ def render_messages(self, messages):
                 _messages.append(NewMessagesDivider(unread_text, date=date_text))
             elif date_text is not None:
                 _messages.append(TextDivider(('history_date', date_text), 'center'))
-            message = self.render_message(message)
+
+            message = self.render_message(message, channel_id)
+
             if message is not None:
                 _messages.append(message)
+
         return _messages
 
+    def handle_mark_read(self, data):
+        """
+        Mark as read to bottom
+        :return:
+        """
+        row_index = data if data is not None else -1
+
+        def read(*kwargs):
+            loop.create_task(
+                self.mark_read_slack(row_index)
+            )
+
+        now = time.time()
+        if now - self.last_keypress[0] < MARK_READ_ALARM_PERIOD and self.last_keypress[1] is not None:
+            self.urwid_loop.remove_alarm(self.last_keypress[1])
+
+        self.last_keypress = (now, self.urwid_loop.set_alarm_in(MARK_READ_ALARM_PERIOD, read))
+
+    def scroll_messages(self, *args):
+        index = self.chatbox.body.scroll_to_new_messages()
+        loop.create_task(
+            self.mark_read_slack(index)
+        )
+
+    @asyncio.coroutine
+    def mark_read_slack(self, index):
+        if not self.chatbox.body or not self.chatbox.body.body:
+            return
+
+        if index is None or index == -1:
+            index = len(self.chatbox.body.body) - 1
+
+        if self.chatbox.body.body and self.chatbox.body.body and len(self.chatbox.body.body) > index:
+            message = self.chatbox.body.body[index]
+
+            # Only apply for message
+            if not hasattr(message, 'channel_id'):
+                if len(self.chatbox.body.body) > index + 1:
+                    message = self.chatbox.body.body[index + 1]
+                else:
+                    message = self.chatbox.body.body[index - 1]
+
+            if message.channel_id:
+                self.store.mark_read(message.channel_id, message.ts)
+
     @asyncio.coroutine
     def _go_to_channel(self, channel_id):
         with concurrent.futures.ThreadPoolExecutor(max_workers=20) as executor:
@@ -506,14 +566,14 @@ def _go_to_channel(self, channel_id):
                     'subtype': SCLACK_SUBTYPE,
                 }])
             else:
-                messages = self.render_messages(self.store.state.messages)
+                messages = self.render_messages(self.store.state.messages, channel_id=channel_id)
 
             header = self.render_chatbox_header()
             self.chatbox.body.body[:] = messages
             self.chatbox.header = header
             self.chatbox.message_box.is_read_only = self.store.state.channel.get('is_read_only', False)
             self.sidebar.select_channel(channel_id)
-            self.urwid_loop.set_alarm_in(0, lambda *args: self.chatbox.body.scroll_to_new_messages())
+            self.urwid_loop.set_alarm_in(0, self.scroll_messages)
 
             if len(self.store.state.messages) == 0:
                 self.go_to_sidebar()
@@ -602,7 +662,10 @@ def stop_typing(*args):
                         else:
                             self.chatbox.body.body.extend(self.render_messages([event]))
                             self.chatbox.body.scroll_to_bottom()
-                    elif event['type'] == 'user_typing':
+                    else:
+                        pass
+                elif event['type'] == 'user_typing':
+                    if event.get('channel') == self.store.state.channel['id']:
                         user = self.store.find_user_by_id(event['user'])
                         name = user.get('display_name') or user.get('real_name') or user['name']
                         if alarm is not None:
@@ -623,6 +686,7 @@ def stop_typing(*args):
                         'user': self.store.state.auth['user_id']
                     }]))
                     self.chatbox.body.scroll_to_bottom()
+                    self.handle_mark_read(-1)
                 else:
                     pass
                     # print(json.dumps(event, indent=2))

sclack/components.py

@@ -12,6 +12,9 @@
 from .store import Store
 
 
+MARK_READ_ALARM_PERIOD = 3
+
+
 def get_icon(name):
     return Store.instance.config['icons'][name]
 
@@ -25,9 +28,18 @@ def __init__(self, widget, color):
             tline='', trcorner='', rline='', bline='', brcorner='')
         super(Box, self).__init__(body, urwid.AttrSpec(color, 'h235'))
 
+
 class Attachment(Box):
-    def __init__(self, color=None, service_name=None, title=None, title_link=None,
-        author_name=None, pretext=None, text=None, fields=None, footer=None):
+    def __init__(self,
+                 color=None,
+                 service_name=None,
+                 title=None,
+                 title_link=None,
+                 author_name=None,
+                 pretext=None,
+                 text=None,
+                 fields=None,
+                 footer=None):
         body = []
         if not color:
             color = 'CCCCCC'
@@ -64,7 +76,7 @@ def file(self, image):
 
 
 class BreadCrumbs(urwid.Text):
-    def __init__(self, elements=[]):
+    def __init__(self, elements=()):
         separator = ('separator', ' {} '.format(get_icon('divider')))
         body = []
         for element in elements:
@@ -206,20 +218,24 @@ def keypress(self, size, key):
 
 class ChatBox(urwid.Frame):
     __metaclass__ = urwid.MetaSignals
-    signals = ['go_to_sidebar', 'open_quick_switcher', 'set_insert_mode']
+    signals = ['go_to_sidebar', 'open_quick_switcher', 'set_insert_mode', 'mark_read']
 
-    def __init__(self, messages, header, message_box):
+    def __init__(self, messages, header, message_box, event_loop):
         self._header = header
         self.message_box = message_box
-        self.body = ChatBoxMessages(messages=messages)
+        self.body = ChatBoxMessages(messages=messages, event_loop=event_loop)
         self.body.scroll_to_bottom()
         urwid.connect_signal(self.body, 'set_date', self._header.on_set_date)
         urwid.connect_signal(self.body, 'set_insert_mode', self.set_insert_mode)
+        urwid.connect_signal(self.body, 'mark_read', self.mark_as_read)
         super(ChatBox, self).__init__(self.body, header=header, footer=self.message_box)
 
     def set_insert_mode(self):
         urwid.emit_signal(self, 'set_insert_mode')
 
+    def mark_as_read(self, data):
+        urwid.emit_signal(self, 'mark_read', data)
+
     def keypress(self, size, key):
         keymap = Store.instance.config['keymap']
         if key == keymap['open_quick_switcher']:
@@ -241,12 +257,14 @@ def header(self, header):
 
 class ChatBoxMessages(urwid.ListBox):
     __metaclass__ = urwid.MetaSignals
-    signals = ['set_auto_scroll', 'set_date', 'set_insert_mode']
+    signals = ['set_auto_scroll', 'set_date', 'set_insert_mode', 'mark_read']
 
-    def __init__(self, messages=[]):
+    def __init__(self, messages=(), event_loop=None):
         self.body = urwid.SimpleFocusListWalker(messages)
         super(ChatBoxMessages, self).__init__(self.body)
         self.auto_scroll = True
+        self.last_keypress = (0, None, 0)
+        self.event_loop = event_loop
 
     @property
     def auto_scroll(self):
@@ -256,23 +274,47 @@ def auto_scroll(self):
     def auto_scroll(self, switch):
         if type(switch) != bool:
             return
+
         self._auto_scroll = switch
         urwid.emit_signal(self, 'set_auto_scroll', switch)
 
+    def mark_read_emit(self, loop, data):
+        urwid.emit_signal(self, 'mark_read', data)
+
     def keypress(self, size, key):
         keymap = Store.instance.config['keymap']
         self.handle_floating_date(size)
+
+        if key in (keymap['cursor_up'], keymap['cursor_down'], 'up', 'down', ):
+            now = time.time()
+            max_focus = self.get_focus()[1]
+
+            if now - self.last_keypress[0] < MARK_READ_ALARM_PERIOD and self.last_keypress[1] is not None:
+                if max_focus < self.last_keypress[2]:
+                    max_focus = self.last_keypress[2]
+
+                self.event_loop.remove_alarm(self.last_keypress[1])
+
+            self.last_keypress = (
+                now,
+                self.event_loop.set_alarm_in(MARK_READ_ALARM_PERIOD, self.mark_read_emit, max_focus),
+                max_focus
+            )
+
         # Go to insert mode
         if key == 'down' and self.get_focus()[1] == len(self.body) - 1:
             urwid.emit_signal(self, 'set_insert_mode')
             return True
+
         super(ChatBoxMessages, self).keypress(size, key)
+
         if key in ('page up', 'page down'):
             self.auto_scroll = self.get_focus()[1] == len(self.body) - 1
+
         if key == keymap['cursor_up']:
             self.keypress(size, 'up')
         if key == keymap['cursor_down']:
-            self.keypress(size,'down')
+            self.keypress(size, 'down')
 
     def mouse_event(self, size, event, button, col, row, focus):
         self.handle_floating_date(size)
@@ -290,6 +332,7 @@ def scroll_to_new_messages(self):
         for index, widget in enumerate(self.body):
             if isinstance(widget, NewMessagesDivider):
                 return self.set_focus(index)
+
         return self.scroll_to_bottom()
 
     def scroll_to_bottom(self):
@@ -440,10 +483,19 @@ def __init__(self, is_edited=False, is_starred=False):
 
 class Message(urwid.AttrMap):
     __metaclass__ = urwid.MetaSignals
-    signals = ['delete_message', 'edit_message', 'go_to_profile', 'go_to_sidebar', 'quit_application', 'set_insert_mode']
-
-    def __init__(self, ts, user, text, indicators, reactions=[], attachments=[]):
+    signals = [
+        'delete_message',
+        'edit_message',
+        'go_to_profile',
+        'go_to_sidebar',
+        'quit_application',
+        'set_insert_mode',
+        'mark_read',
+    ]
+
+    def __init__(self, ts, channel_id, user, text, indicators, reactions=(), attachments=()):
         self.ts = ts
+        self.channel_id = channel_id
         self.user_id = user.id
         self.markdown_text = text
         self.original_text = text.original_text
@@ -837,7 +889,7 @@ def __init__(self, id, name, color=None, is_app=False):
         self.id = id
         if not color:
             color = '333333'
-        color='#{}'.format(shorten_hex(color))
+        color = '#{}'.format(shorten_hex(color))
         markup = [
             (urwid.AttrSpec(color, 'h235'), '{} '.format(name))
         ]