Merge pull request #83 from duynguyenhoang/feature/support_set_snooze

Add set snooze time feature

Author: haskellcamargo

README.md

@@ -88,16 +88,20 @@ at most 9 workspaces defined inside `workspaces`:
 }
 ```
 
+You can use the keys from 1 up to 9 to switch workspaces or event right-click the indicator:
+
+![Multiple workspaces](./resources/example_7.png)
+
+
 ### Quick Switcher
 
 You can use <kbd>ctrl k</kbd> (or your custom shortcut) to navigate in your DMs and channels.
 
 ![](./resources/example_8.png)
 
-You can use the keys from 1 up to 9 to switch workspaces or event right-click the indicator:
-
-![Multiple workspaces](./resources/example_7.png)
+### Set snooze
 
+You can use <kbd>ctrl d</kbd> (or your custom shortcut) to set snooze time.
 
 ### Default keybindings
 ```json

app.py

@@ -22,6 +22,8 @@
 from sclack.store import Store
 from sclack.themes import themes
 
+from sclack.widgets.set_snooze import SetSnoozeWidget
+
 loop = asyncio.get_event_loop()
 
 SCLACK_SUBTYPE = 'sclack_message'
@@ -54,6 +56,8 @@ def _exception_handler(self, loop, context):
     def __init__(self, config):
         self._loading = False
         self.config = config
+        self.quick_switcher = None
+        self.set_snooze_widget = None
         self.workspaces = list(config['workspaces'].items())
         self.store = Store(self.workspaces, self.config)
         Store.instance = self.store
@@ -75,7 +79,7 @@ def __init__(self, config):
             urwid.AttrWrap(chatbox, 'chatbox')
         ])
         self._body = urwid.Frame(self.columns, header=self.workspaces_line)
-        self.quick_switcher = None
+
         self.urwid_loop = urwid.MainLoop(
             self._body,
             palette=palette,
@@ -253,6 +257,7 @@ def mount_chatbox(self, executor, channel):
         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.chatbox, 'open_set_snooze', self.open_set_snooze)
 
         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)
@@ -587,6 +592,24 @@ def go_to_channel(self, channel_id):
             self.quick_switcher = None
         loop.create_task(self._go_to_channel(channel_id))
 
+    def handle_set_snooze_time(self, snoozed_time):
+        loop.create_task(self.dispatch_snooze_time(snoozed_time))
+
+    def handle_close_set_snooze(self):
+        """
+        Close set_snooze
+        :return:
+        """
+        if self.set_snooze_widget:
+            urwid.disconnect_signal(self.set_snooze_widget, 'set_snooze_time', self.handle_set_snooze_time)
+            urwid.disconnect_signal(self.set_snooze_widget, 'close_set_snooze', self.handle_close_set_snooze)
+            self.urwid_loop.widget = self._body
+            self.set_snooze_widget = None
+
+    @asyncio.coroutine
+    def dispatch_snooze_time(self, snoozed_time):
+        self.store.set_snooze(snoozed_time)
+
     @asyncio.coroutine
     def load_picture_async(self, url, width, message_widget, auth=True):
         width = min(width, 800)
@@ -716,8 +739,10 @@ def go_to_sidebar(self):
         if len(self.columns.contents) > 2:
             self.columns.contents.pop()
         self.columns.focus_position = 0
+
         if self.store.state.editing_widget:
             self.leave_edit_mode()
+
         if self.quick_switcher:
             urwid.disconnect_signal(self.quick_switcher, 'go_to_channel', self.go_to_channel)
             self.urwid_loop.widget = self._body
@@ -743,6 +768,11 @@ def go_to_last_message(self):
         self.chatbox.body.go_to_last_message()
 
     def unhandled_input(self, key):
+        """
+        Handle shortcut key press
+        :param key:
+        :return:
+        """
         keymap = self.store.config['keymap']
 
         if key == keymap['go_to_chatbox'] or key == keymap['cursor_right'] and self.message_box:
@@ -763,13 +793,22 @@ def unhandled_input(self, key):
                 # Stop rtm to switch workspace
                 self.real_time_task.cancel()
                 return self.switch_to_workspace(int(key))
+        elif key == keymap['set_snooze']:
+            return self.open_set_snooze()
 
     def open_quick_switcher(self):
         if not self.quick_switcher:
             self.quick_switcher = QuickSwitcher(self.urwid_loop.widget, self.urwid_loop)
             urwid.connect_signal(self.quick_switcher, 'go_to_channel', self.go_to_channel)
             self.urwid_loop.widget = self.quick_switcher
 
+    def open_set_snooze(self):
+        if not self.set_snooze_widget:
+            self.set_snooze_widget = SetSnoozeWidget(self.urwid_loop.widget, self.urwid_loop)
+            urwid.connect_signal(self.set_snooze_widget, 'set_snooze_time', self.handle_set_snooze_time)
+            urwid.connect_signal(self.set_snooze_widget, 'close_set_snooze', self.handle_close_set_snooze)
+            self.urwid_loop.widget = self.set_snooze_widget
+
     def configure_screen(self, screen):
         screen.set_terminal_properties(colors=self.store.config['colors'])
         screen.set_mouse_tracking()

config.json

@@ -15,7 +15,8 @@
         "quit_application": "q",
         "set_edit_topic_mode": "t",
         "set_insert_mode": "i",
-        "yank_message": "y"
+        "yank_message": "y",
+        "set_snooze": "ctrl d"
     },
     "sidebar": {
         "width": 25,
@@ -50,6 +51,7 @@
         "square": "\uF445",
         "snooze": "\uF9B1",
         "status": "\uF075",
-        "timezone": "\uF0AC"
+        "timezone": "\uF0AC",
+        "alarm_snooze": "\ufb8c"
     }
 }

sclack/components.py

@@ -218,7 +218,7 @@ def keypress(self, size, key):
 
 class ChatBox(urwid.Frame):
     __metaclass__ = urwid.MetaSignals
-    signals = ['go_to_sidebar', 'open_quick_switcher', 'set_insert_mode', 'mark_read']
+    signals = ['go_to_sidebar', 'open_quick_switcher', 'set_insert_mode', 'mark_read', 'open_set_snooze']
 
     def __init__(self, messages, header, message_box, event_loop):
         self._header = header
@@ -241,6 +241,10 @@ def keypress(self, size, key):
         if key == keymap['open_quick_switcher']:
             urwid.emit_signal(self, 'open_quick_switcher')
             return True
+        if key == keymap['set_snooze']:
+            urwid.emit_signal(self, 'open_set_snooze')
+            return True
+
         return super(ChatBox, self).keypress(size, key)
 
     @property

sclack/markdown.py

@@ -3,6 +3,7 @@
 from .store import Store
 from .emoji import emoji_codemap
 
+
 class MarkdownText(urwid.SelectableIcon):
     _buffer = ''
     _state = 'message'

sclack/quick_switcher.py

@@ -3,16 +3,19 @@
 import unicodedata
 from .store import Store
 
+
 def get_icon(name):
     return Store.instance.config['icons'][name]
 
+
 def remove_diacritic(input):
     '''
     Accept a unicode string, and return a normal string (bytes in Python 3)
     without any diacritical marks.
     '''
     return unicodedata.normalize('NFKD', input).encode('ASCII', 'ignore').decode()
 
+
 class QuickSwitcherItem(urwid.AttrMap):
     def __init__(self, icon, title, id):
         markup = [' ', icon, ' ', title]
@@ -27,6 +30,7 @@ def __init__(self, icon, title, id):
             }
         )
 
+
 class QuickSwitcherList(urwid.ListBox):
     def __init__(self, items):
         self.body = urwid.SimpleFocusListWalker(items)
@@ -69,7 +73,7 @@ def __init__(self, base, event_loop):
                     priority.append({'id': dm['id'], 'icon': icon, 'title': name, 'type': 'user'})
                 else:
                     icon = ('quick_search_presence_away', get_icon('offline'))
-                    lines.append({'id': dm['id'],'icon': icon, 'title': name, 'type': 'user'})
+                    lines.append({'id': dm['id'], 'icon': icon, 'title': name, 'type': 'user'})
         priority.sort(key=lambda item: item['title'])
         lines.sort(key=lambda item: item['title'])
         self.header = urwid.Edit('')
@@ -84,10 +88,10 @@ def __init__(self, base, event_loop):
         overlay = urwid.Overlay(
             switcher,
             base,
-            align = 'center',
-            width = ('relative', 40),
-            valign = 'middle',
-            height = 15
+            align='center',
+            width=('relative', 40),
+            valign='middle',
+            height=15
         )
         self.last_keypress = (time.time() - 0.3, None)
         super(QuickSwitcher, self).__init__(overlay, 'quick_switcher_dialog')
@@ -139,4 +143,3 @@ def keypress(self, size, key):
         if now - self.last_keypress[0] < 0.3 and self.last_keypress[1] is not None:
             self.event_loop.remove_alarm(self.last_keypress[1])
         self.last_keypress = (now, self.event_loop.set_alarm_in(0.3, self.set_filter))
-

sclack/store.py

@@ -125,6 +125,9 @@ def mark_read(self, channel_id, ts):
         elif self.is_dm(channel_id):
             return self.slack.api_call('im.mark', channel=channel_id, ts=ts)
 
+    def set_snooze(self, snoozed_time):
+        return self.slack.api_call('dnd.setSnooze', num_minutes=snoozed_time)
+
     def load_channel(self, channel_id):
         if channel_id[0] in ('C', 'G', 'D'):
             self.state.channel = self.get_channel_info(channel_id)

sclack/themes.py

@@ -42,7 +42,9 @@
         ('selected_workspace_separator', '', '', '', 'h198', 'h54'),
         ('previous_workspace_separator', '', '', '', 'h54', 'h198'),
         ('quick_switcher_dialog', '', '', '', 'white', 'h239'),
+        ('set_snooze_dialog', '', '', '', 'white', 'h239'),
         ('active_quick_switcher_item', '', '', '', 'white', 'h32'),
+        ('active_set_snooze_item', '', '', '', 'white', 'h32'),
         ('quick_search_presence_active', '', '', '', 'h40', 'h239'),
         ('quick_search_active_focus', '', '', '', 'h40', 'h32'),
         ('quick_search_presence_away', '', '', '', 'white', 'h239')

sclack/widgets/set_snooze.py

@@ -0,0 +1,114 @@
+import urwid
+from sclack.store import Store
+
+
+def get_icon(name):
+    return Store.instance.config['icons'][name]
+
+
+class SetSnoozeWidgetItem(urwid.AttrMap):
+    def __init__(self, icon, title, id):
+        markup = [' ', icon, ' ', title]
+        self.id = id
+        super(SetSnoozeWidgetItem, self).__init__(
+            urwid.SelectableIcon(markup),
+            None,
+            {
+                None: 'active_set_snooze_item',
+                'quick_search_presence_active': 'quick_search_active_focus',
+            }
+        )
+
+
+class SetSnoozeWidgetList(urwid.ListBox):
+    def __init__(self, items):
+        self.body = urwid.SimpleFocusListWalker(items)
+        super(SetSnoozeWidgetList, self).__init__(self.body)
+
+
+class SetSnoozeWidget(urwid.AttrWrap):
+    __metaclass__ = urwid.MetaSignals
+    signals = ['close_set_snooze', 'set_snooze_time']
+
+    def __init__(self, base, event_loop):
+        lines = []
+        self.event_loop = event_loop
+
+        snooze_times = [
+            {
+                'label': 'Off',
+                'time': 0,
+            },
+            {
+                'label': '20 minutes',
+                'time': 20,
+            },
+            {
+                'label': '1 hour',
+                'time': 60,
+            },
+            {
+                'label': '2 hours',
+                'time': 120,
+            },
+            {
+                'label': '4 hours',
+                'time': 240,
+            },
+            {
+                'label': '8 hours',
+                'time': 480,
+            },
+            {
+                'label': '24 hours',
+                'time': 1400,
+            },
+        ]
+
+        for snooze_time in snooze_times:
+            lines.append({
+                'icon': get_icon('alarm_snooze'),
+                'title': snooze_time['label'],
+                'time': snooze_time['time']
+            })
+
+        self.header = urwid.Edit('')
+
+        self.original_items = lines
+        widgets = [SetSnoozeWidgetItem(item['icon'], item['title'], item['time']) for item in self.original_items]
+
+        self.snooze_time_list = SetSnoozeWidgetList(widgets)
+
+        snooze_list = urwid.LineBox(
+            urwid.Frame(self.snooze_time_list, header=self.header),
+            title='Snooze notifications',
+            title_align='left'
+        )
+        overlay = urwid.Overlay(
+            snooze_list,
+            base,
+            align='center',
+            width=('relative', 15),
+            valign='middle',
+            height=10,
+            right=5
+        )
+        super(SetSnoozeWidget, self).__init__(overlay, 'set_snooze_dialog')
+
+    def keypress(self, size, key):
+        reserved_keys = ('up', 'down', 'page up', 'page down')
+        if key in reserved_keys:
+            return super(SetSnoozeWidget, self).keypress(size, key)
+        elif key == 'enter':
+            focus = self.snooze_time_list.body.get_focus()
+            if focus[0]:
+                urwid.emit_signal(self, 'set_snooze_time', focus[0].id)
+                urwid.emit_signal(self, 'close_set_snooze')
+                return True
+        elif key == 'esc':
+            focus = self.snooze_time_list.body.get_focus()
+            if focus[0]:
+                urwid.emit_signal(self, 'close_set_snooze')
+                return True
+
+        self.header.keypress((size[0],), key)