Separate most Twitter features in their own controller so it might be easier to implement those in the handler

src/controller/twitter/filters.py

@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+import time
+import widgetUtils
+import application
+from wxUI.dialogs import filterDialogs
+from wxUI import commonMessageDialogs
+
+class filter(object):
+    def __init__(self, buffer, filter_title=None, if_word_exists=None, in_lang=None, regexp=None, word=None, in_buffer=None):
+        self.buffer = buffer
+        self.dialog = filterDialogs.filterDialog(languages=[i["name"] for i in application.supported_languages])
+        if self.dialog.get_response()  == widgetUtils.OK:
+            title = self.dialog.get("title")
+            contains = self.dialog.get("contains")
+            term = self.dialog.get("term")
+            regexp = self.dialog.get("regexp")
+            allow_rts = self.dialog.get("allow_rts")
+            allow_quotes = self.dialog.get("allow_quotes")
+            allow_replies = self.dialog.get("allow_replies")
+            load_language = self.dialog.get("load_language")
+            ignore_language = self.dialog.get("ignore_language")
+            lang_option = None
+            if ignore_language:
+                lang_option = False
+            elif load_language:
+                lang_option = True
+            langs = self.dialog.get_selected_langs()
+            langcodes = []
+            for i in application.supported_languages:
+                if i["name"] in langs:
+                    langcodes.append(i["code"])
+            d = dict(in_buffer=self.buffer.name, word=term, regexp=regexp, in_lang=lang_option, languages=langcodes, if_word_exists=contains, allow_rts=allow_rts, allow_quotes=allow_quotes, allow_replies=allow_replies)
+            if title in self.buffer.session.settings["filters"]:
+                return commonMessageDialogs.existing_filter()
+            self.buffer.session.settings["filters"][title] = d
+            self.buffer.session.settings.write()
+
+class filterManager(object):
+
+    def __init__(self, session):
+        self.session = session
+        self.dialog = filterDialogs.filterManagerDialog()
+        self.insert_filters(self.session.settings["filters"])
+        if self.dialog.filters.get_count() == 0:
+            self.dialog.edit.Enable(False)
+            self.dialog.delete.Enable(False)
+        else:
+            widgetUtils.connect_event(self.dialog.edit, widgetUtils.BUTTON_PRESSED, self.edit_filter)
+            widgetUtils.connect_event(self.dialog.delete, widgetUtils.BUTTON_PRESSED, self.delete_filter)
+        response = self.dialog.get_response()
+
+    def insert_filters(self, filters):
+        self.dialog.filters.clear()
+        for f in list(filters.keys()):
+            filterName = f
+            buffer = filters[f]["in_buffer"]
+            if filters[f]["if_word_exists"] == "True" and filters[f]["word"] != "":
+                filter_by_word = "True"
+            else:
+                filter_by_word = "False"
+            filter_by_lang = ""
+            if filters[f]["in_lang"] != "None":
+                filter_by_lang = "True"
+            b = [f, buffer, filter_by_word, filter_by_lang]
+            self.dialog.filters.insert_item(False, *b)
+
+    def edit_filter(self, *args, **kwargs):
+        pass
+
+    def delete_filter(self, *args, **kwargs):
+        filter_title = self.dialog.filters.get_text_column(self.dialog.filters.get_selected(), 0)
+        response = commonMessageDialogs.delete_filter()
+        if response == widgetUtils.YES:
+            self.session.settings["filters"].pop(filter_title)
+            self.session.settings.write()
+            self.insert_filters(self.session.settings["filters"])

src/controller/twitter/lists.py

@@ -0,0 +1,114 @@
+# -*- coding: utf-8 -*-
+import widgetUtils
+import output
+import logging
+from wxUI.dialogs import lists
+from tweepy.errors import TweepyException
+from sessions.twitter import compose, utils
+from pubsub import pub
+
+log = logging.getLogger("controller.listsController")
+
+class listsController(object):
+    def __init__(self, session, user=None):
+        super(listsController, self).__init__()
+        self.session = session
+        if user == None:
+            self.dialog = lists.listViewer()
+            self.dialog.populate_list(self.get_all_lists())
+            widgetUtils.connect_event(self.dialog.createBtn, widgetUtils.BUTTON_PRESSED, self.create_list)
+            widgetUtils.connect_event(self.dialog.editBtn, widgetUtils.BUTTON_PRESSED, self.edit_list)
+            widgetUtils.connect_event(self.dialog.deleteBtn, widgetUtils.BUTTON_PRESSED, self.remove_list)
+            widgetUtils.connect_event(self.dialog.view, widgetUtils.BUTTON_PRESSED, self.open_list_as_buffer)
+            widgetUtils.connect_event(self.dialog.deleteBtn, widgetUtils.BUTTON_PRESSED, self.remove_list)
+        else:
+            self.dialog = lists.userListViewer(user)
+            self.dialog.populate_list(self.get_user_lists(user))
+            widgetUtils.connect_event(self.dialog.createBtn, widgetUtils.BUTTON_PRESSED, self.subscribe)
+            widgetUtils.connect_event(self.dialog.deleteBtn, widgetUtils.BUTTON_PRESSED, self.unsubscribe)
+        self.dialog.get_response()
+
+    def get_all_lists(self):
+        return [compose.compose_list(item) for item in self.session.db["lists"]]
+
+    def get_user_lists(self, user):
+        self.lists = self.session.twitter.get_lists(reverse=True, screen_name=user)
+        return [compose.compose_list(item) for item in self.lists]
+
+    def create_list(self, *args, **kwargs):
+        dialog = lists.createListDialog()
+        if dialog.get_response() == widgetUtils.OK:
+            name = dialog.get("name")
+            description = dialog.get("description")
+            p = dialog.get("public")
+            if p == True:
+                mode = "public"
+            else:
+                mode = "private"
+            try:
+                new_list = self.session.twitter.create_list(name=name, description=description, mode=mode)
+                self.session.db["lists"].append(new_list)
+                self.dialog.lista.insert_item(False, *compose.compose_list(new_list))
+            except TweepyException as e:
+                output.speak("error %s" % (str(e)))
+                log.exception("error %s" % (str(e)))
+        dialog.destroy()
+
+    def edit_list(self, *args, **kwargs):
+        if self.dialog.lista.get_count() == 0: return
+        list = self.session.db["lists"][self.dialog.get_item()]
+        dialog = lists.editListDialog(list)
+        if dialog.get_response() == widgetUtils.OK:
+            name = dialog.get("name")
+            description = dialog.get("description")
+            p = dialog.get("public")
+            if p == True:
+                mode = "public"
+            else:
+                mode = "private"
+            try:
+                self.session.twitter.update_list(list_id=list.id, name=name, description=description, mode=mode)
+                self.session.get_lists()
+                self.dialog.populate_list(self.get_all_lists(), True)
+            except TweepyException as e:
+                output.speak("error %s" % (str(e)))
+                log.exception("error %s" % (str(e)))
+        dialog.destroy()
+
+    def remove_list(self, *args, **kwargs):
+        if self.dialog.lista.get_count() == 0: return
+        list = self.session.db["lists"][self.dialog.get_item()].id
+        if lists.remove_list() == widgetUtils.YES:
+            try:
+                self.session.twitter.destroy_list(list_id=list)
+                self.session.db["lists"].pop(self.dialog.get_item())
+                self.dialog.lista.remove_item(self.dialog.get_item())
+            except TweepyException as e:
+                output.speak("error %s" % (str(e)))
+                log.exception("error %s" % (str(e)))
+
+    def open_list_as_buffer(self, *args, **kwargs):
+        if self.dialog.lista.get_count() == 0: return
+        list = self.session.db["lists"][self.dialog.get_item()]
+        pub.sendMessage("create-new-buffer", buffer="list", account=self.session.db["user_name"], create=list.name)
+
+    def subscribe(self, *args, **kwargs):
+        if self.dialog.lista.get_count() == 0: return
+        list_id = self.lists[self.dialog.get_item()].id
+        try:
+            list = self.session.twitter.subscribe_list(list_id=list_id)
+            item = utils.find_item(list.id, self.session.db["lists"])
+            self.session.db["lists"].append(list)
+        except TweepyException as e:
+            output.speak("error %s" % (str(e)))
+            log.exception("error %s" % (str(e)))
+
+    def unsubscribe(self, *args, **kwargs):
+        if self.dialog.lista.get_count() == 0: return
+        list_id = self.lists[self.dialog.get_item()].id
+        try:
+            list = self.session.twitter.unsubscribe_list(list_id=list_id)
+            self.session.db["lists"].remove(list)
+        except TweepyException as e:
+            output.speak("error %s" % (str(e)))
+            log.exception("error %s" % (str(e)))

src/controller/twitter/messages.py

@@ -0,0 +1,381 @@
+# -*- coding: utf-8 -*-
+import os
+import arrow
+import languageHandler
+import wx
+import widgetUtils
+import output
+import sound
+import config
+from pubsub import pub
+from twitter_text import parse_tweet
+from wxUI.dialogs import twitterDialogs, urlList
+from wxUI import commonMessageDialogs
+from extra import translator, SpellChecker
+from extra.AudioUploader import audioUploader
+from extra.autocompletionUsers import completion
+from sessions.twitter import utils
+
+class basicTweet(object):
+    """ This class handles the tweet main features. Other classes should derive from this class."""
+    def __init__(self, session, title, caption, text="", messageType="tweet", max=280, *args, **kwargs):
+        super(basicTweet, self).__init__()
+        self.max = max
+        self.title = title
+        self.session = session
+        self.message = getattr(twitterDialogs, messageType)(title=title, caption=caption, message=text, *args, **kwargs)
+        self.message.text.SetValue(text)
+        self.message.text.SetInsertionPoint(len(self.message.text.GetValue()))
+        widgetUtils.connect_event(self.message.spellcheck, widgetUtils.BUTTON_PRESSED, self.spellcheck)
+        widgetUtils.connect_event(self.message.add_audio, widgetUtils.BUTTON_PRESSED, self.attach)
+        widgetUtils.connect_event(self.message.text, widgetUtils.ENTERED_TEXT, self.text_processor)
+        widgetUtils.connect_event(self.message.translate, widgetUtils.BUTTON_PRESSED, self.translate)
+        if hasattr(self.message, "add"):
+            widgetUtils.connect_event(self.message.add, widgetUtils.BUTTON_PRESSED, self.on_attach)
+        self.attachments = []
+
+    def translate(self, event=None):
+        dlg = translator.gui.translateDialog()
+        if dlg.get_response() == widgetUtils.OK:
+            text_to_translate = self.message.text.GetValue()
+            language_dict = translator.translator.available_languages()
+            for k in language_dict:
+                if language_dict[k] == dlg.dest_lang.GetStringSelection():
+                    dst = k
+            msg = translator.translator.translate(text=text_to_translate, target=dst)
+            self.message.text.ChangeValue(msg)
+            self.message.text.SetInsertionPoint(len(self.message.text.GetValue()))
+            self.text_processor()
+            self.message.text.SetFocus()
+            output.speak(_(u"Translated"))
+        else:
+            return
+
+    def text_processor(self, *args, **kwargs):
+        text = self.message.text.GetValue()
+        results = parse_tweet(text)
+        self.message.SetTitle(_("%s - %s of %d characters") % (self.title, results.weightedLength, self.max))
+        if results.weightedLength > self.max:
+            self.session.sound.play("max_length.ogg")
+
+    def spellcheck(self, event=None):
+        text = self.message.text.GetValue()
+        checker = SpellChecker.spellchecker.spellChecker(text, "")
+        if hasattr(checker, "fixed_text"):
+            self.message.text.ChangeValue(checker.fixed_text)
+            self.text_processor()
+            self.message.text.SetFocus()
+
+    def attach(self, *args, **kwargs):
+        def completed_callback(dlg):
+            url = dlg.uploaderFunction.get_url()
+            pub.unsubscribe(dlg.uploaderDialog.update, "uploading")
+            dlg.uploaderDialog.destroy()
+            if "sndup.net/" in url:
+                self.message.text.ChangeValue(self.message.text.GetValue()+url+" #audio")
+                self.text_processor()
+            else:
+                commonMessageDialogs.common_error(url)
+            dlg.cleanup()
+        dlg = audioUploader.audioUploader(self.session.settings, completed_callback)
+        self.message.text.SetFocus()
+
+    def can_attach(self):
+        if len(self.attachments) == 0:
+            return True
+        elif len(self.attachments) == 1 and (self.attachments[0]["type"] == "video" or self.attachments[0]["type"] == "gif"):
+            return False
+        elif len(self.attachments) < 4:
+            return True
+        return False
+
+    def on_attach(self, *args, **kwargs):
+        can_attach = self.can_attach()
+        menu = self.message.attach_menu(can_attach)
+        self.message.Bind(wx.EVT_MENU, self.on_attach_image, self.message.add_image)
+        self.message.Bind(wx.EVT_MENU, self.on_attach_video, self.message.add_video)
+        if hasattr(self.message, "add_poll"):
+            self.message.Bind(wx.EVT_MENU, self.on_attach_poll, self.message.add_poll)
+        self.message.PopupMenu(menu, self.message.add.GetPosition())
+
+    def on_attach_image(self, *args, **kwargs):
+        can_attach = self.can_attach()
+        video_or_gif_present = False
+        for a in self.attachments:
+            if a["type"] == "video" or a["type"] == "gif":
+                video_or_gif = True
+                break
+        if can_attach == False or video_or_gif_present == True:
+            return self.message.unable_to_attach_file()
+        image, description  = self.message.get_image()
+        if image != None:
+            if image.endswith("gif"):
+                image_type = "gif"
+            else:
+                image_type = "photo"
+            imageInfo = {"type": image_type, "file": image, "description": description}
+            if len(self.attachments) > 0 and image_type == "gif":
+                return self.message.unable_to_attach_file()
+            self.attachments.append(imageInfo)
+            self.message.add_item(item=[os.path.basename(imageInfo["file"]), imageInfo["type"], imageInfo["description"]])
+            self.text_processor()
+
+    def on_attach_video(self, *args, **kwargs):
+        if len(self.attachments) > 0:
+            return self.message.unable_to_attach_file()
+        video = self.message.get_video()
+        if video != None:
+            videoInfo = {"type": "video", "file": video, "description": ""}
+            if len(self.attachments) > 0:
+                return self.message.unable_to_attach_file()
+            self.attachments.append(videoInfo)
+            self.message.add_item(item=[os.path.basename(videoInfo["file"]), videoInfo["type"], videoInfo["description"]])
+            self.text_processor()
+
+    def on_attach_poll(self, *args, **kwargs):
+        dlg = twitterDialogs.poll()
+        if dlg.ShowModal() == wx.ID_OK:
+            self.poll_options = dlg.get_options()
+            self.poll_period = 60*24*dlg.period.GetValue()
+        dlg.Destroy()
+
+    def remove_attachment(self, *args, **kwargs):
+        attachment = self.message.attachments.GetFocusedItem()
+        if attachment > -1 and len(self.attachments) > attachment:
+            self.attachments.pop(attachment)
+            self.message.remove_item(list_type="attachment")
+            self.text_processor()
+            self.message.text.SetFocus()
+
+class tweet(basicTweet):
+    def __init__(self, session, title, caption, text="", max=280, messageType="tweet", *args, **kwargs):
+        self.thread = []
+        self.poll_options = None
+        self.poll_period = None
+        super(tweet, self).__init__(session, title, caption, text, messageType, max, *args, **kwargs)
+        widgetUtils.connect_event(self.message.autocomplete_users, widgetUtils.BUTTON_PRESSED, self.autocomplete_users)
+        if hasattr(self.message, "add_tweet"):
+            widgetUtils.connect_event(self.message.add_tweet, widgetUtils.BUTTON_PRESSED, self.add_tweet)
+            widgetUtils.connect_event(self.message.remove_tweet, widgetUtils.BUTTON_PRESSED, self.remove_tweet)
+        widgetUtils.connect_event(self.message.remove_attachment, widgetUtils.BUTTON_PRESSED, self.remove_attachment)
+        self.text_processor()
+
+    def autocomplete_users(self, *args, **kwargs):
+        c = completion.autocompletionUsers(self.message, self.session.session_id)
+        c.show_menu()
+
+    def add_tweet(self, event, update_gui=True, *args, **kwargs):
+        text = self.message.text.GetValue()
+        attachments = self.attachments[::]
+        tweetdata = dict(text=text, attachments=attachments, poll_options=self.poll_options, poll_period=self.poll_period)
+        self.thread.append(tweetdata)
+        self.attachments = []
+        self.poll_options = None
+        self.poll_period = None
+        if update_gui:
+            self.message.reset_controls()
+            self.message.add_item(item=[text, len(attachments)], list_type="tweet")
+            self.message.text.SetFocus()
+            self.text_processor()
+
+    def get_tweet_data(self):
+        self.add_tweet(event=None, update_gui=False)
+        return self.thread
+
+    def text_processor(self, *args, **kwargs):
+        super(tweet, self).text_processor(*args, **kwargs)
+        if len(self.thread) > 0:
+            self.message.tweets.Enable(True)
+            self.message.remove_tweet.Enable(True)
+        else:
+            self.message.tweets.Enable(False)
+            self.message.remove_tweet.Enable(False)
+        if len(self.attachments) > 0:
+            self.message.attachments.Enable(True)
+            self.message.remove_attachment.Enable(True)
+        else:
+            self.message.attachments.Enable(False)
+            self.message.remove_attachment.Enable(False)
+        if hasattr(self.message, "add_tweet"):
+            if len(self.message.text.GetValue()) > 0 or len(self.attachments) > 0:
+                self.message.add_tweet.Enable(True)
+            else:
+                self.message.add_tweet.Enable(False)
+
+    def remove_tweet(self, *args, **kwargs):
+        tweet = self.message.tweets.GetFocusedItem()
+        if tweet > -1 and len(self.thread) > tweet:
+            self.thread.pop(tweet)
+            self.message.remove_item(list_type="tweet")
+            self.text_processor()
+            self.message.text.SetFocus()
+
+
+class reply(tweet):
+    def __init__(self, session, title, caption, text, users=[], ids=[]):
+        super(reply, self).__init__(session, title, caption, text, messageType="reply", users=users)
+        self.ids = ids
+        self.users = users
+        if len(users) > 0:
+            widgetUtils.connect_event(self.message.mention_all, widgetUtils.CHECKBOX, self.mention_all)
+            self.message.mention_all.Enable(True)
+            if config.app["app-settings"]["remember_mention_and_longtweet"]:
+                self.message.mention_all.SetValue(config.app["app-settings"]["mention_all"])
+            self.mention_all()
+        self.message.text.SetInsertionPoint(len(self.message.text.GetValue()))
+        self.text_processor()
+
+    def text_processor(self, *args, **kwargs):
+        super(tweet, self).text_processor(*args, **kwargs)
+        if len(self.attachments) > 0:
+            self.message.attachments.Enable(True)
+            self.message.remove_attachment.Enable(True)
+        else:
+            self.message.attachments.Enable(False)
+            self.message.remove_attachment.Enable(False)
+
+    def mention_all(self, *args, **kwargs):
+        if self.message.mention_all.GetValue() == True:
+            for i in self.message.checkboxes:
+                i.SetValue(True)
+                i.Hide()
+        else:
+            for i in self.message.checkboxes:
+                i.SetValue(False)
+                i.Show()
+
+    def get_ids(self):
+        excluded_ids  = []
+        for i in range(0, len(self.message.checkboxes)):
+            if self.message.checkboxes[i].GetValue() == False:
+                excluded_ids.append(self.ids[i])
+        return excluded_ids
+
+    def get_people(self):
+        people  = ""
+        for i in range(0, len(self.message.checkboxes)):
+            if self.message.checkboxes[i].GetValue() == True:
+                people = people + "{0} ".format(self.message.checkboxes[i].GetLabel(),)
+        return people
+
+class dm(basicTweet):
+    def __init__(self, session, title, caption, users):
+        super(dm, self).__init__(session, title, caption, messageType="dm", max=10000, users=users)
+        widgetUtils.connect_event(self.message.autocomplete_users, widgetUtils.BUTTON_PRESSED, self.autocomplete_users)
+        self.text_processor()
+        widgetUtils.connect_event(self.message.cb, widgetUtils.ENTERED_TEXT, self.user_changed)
+
+    def user_changed(self, *args, **kwargs):
+        self.title = _("Direct message to %s") % (self.message.cb.GetValue())
+        self.text_processor()
+
+    def autocomplete_users(self, *args, **kwargs):
+        c = completion.autocompletionUsers(self.message, self.session.session_id)
+        c.show_menu("dm")
+
+    def text_processor(self, *args, **kwargs):
+        super(dm, self).text_processor(*args, **kwargs)
+        if len(self.attachments) > 0:
+            self.message.attachments.Enable(True)
+            self.message.remove_attachment.Enable(True)
+        else:
+            self.message.attachments.Enable(False)
+            self.message.remove_attachment.Enable(False)
+
+    def can_attach(self):
+        if len(self.attachments) == 0:
+            return True
+        return False
+
+class viewTweet(basicTweet):
+    def __init__(self, tweet, tweetList, is_tweet=True, utc_offset=0, date="", item_url=""):
+        """ This represents a tweet displayer. However it could be used for showing something wich is not a tweet, like a direct message or an event.
+         param tweet: A dictionary that represents a full tweet or a string for non-tweets.
+         param tweetList: If is_tweet is set to True, this could be a list of quoted tweets.
+         param is_tweet: True or false, depending wether the passed object is a tweet or not."""
+        if is_tweet == True:
+            self.title = _(u"Tweet")
+            image_description = []
+            text = ""
+            for i in range(0, len(tweetList)):
+                # tweets with message keys are longer tweets, the message value is the full messaje taken from twishort.
+                if hasattr(tweetList[i], "message")  and tweetList[i].is_quote_status == False:
+                    value = "message"
+                else:
+                    value = "full_text"
+                if hasattr(tweetList[i], "retweeted_status") and tweetList[i].is_quote_status == False:
+                    if not hasattr(tweetList[i], "message"):
+                        text = text + "rt @%s: %s\n" % (tweetList[i].retweeted_status.user.screen_name, tweetList[i].retweeted_status.full_text)
+                    else:
+                        text = text + "rt @%s: %s\n" % (tweetList[i].retweeted_status.user.screen_name, getattr(tweetList[i], value))
+                else:
+                    text = text + " @%s: %s\n" % (tweetList[i].user.screen_name, getattr(tweetList[i], value))
+                # tweets with extended_entities could include image descriptions.
+                if hasattr(tweetList[i], "extended_entities") and "media" in tweetList[i].extended_entities:
+                    for z in tweetList[i].extended_entities["media"]:
+                        if "ext_alt_text" in z and z["ext_alt_text"] != None:
+                            image_description.append(z["ext_alt_text"])
+                if hasattr(tweetList[i], "retweeted_status") and hasattr(tweetList[i].retweeted_status, "extended_entities") and "media" in tweetList[i].retweeted_status["extended_entities"]:
+                    for z in tweetList[i].retweeted_status.extended_entities["media"]:
+                        if "ext_alt_text" in z and z["ext_alt_text"] != None:
+                            image_description.append(z["ext_alt_text"])
+            # set rt and likes counters.
+            rt_count = str(tweet.retweet_count)
+            favs_count = str(tweet.favorite_count)
+            # Gets the client from where this tweet was made.
+            source = tweet.source
+            original_date = arrow.get(tweet.created_at, locale="en")
+            date = original_date.shift(seconds=utc_offset).format(_(u"MMM D, YYYY. H:m"), locale=languageHandler.getLanguage())
+            if text == "":
+                if hasattr(tweet, "message"):
+                    value = "message"
+                else:
+                    value = "full_text"
+                if hasattr(tweet, "retweeted_status"):
+                    if not hasattr(tweet, "message"):
+                        text = "rt @%s: %s" % (tweet.retweeted_status.user.screen_name, tweet.retweeted_status.full_text)
+                    else:
+                        text = "rt @%s: %s" % (tweet.retweeted_status.user.screen_name, getattr(tweet, value))
+                else:
+                    text = getattr(tweet, value)
+            text = self.clear_text(text)
+            if hasattr(tweet, "extended_entities") and "media" in tweet.extended_entities:
+                for z in tweet.extended_entities["media"]:
+                    if "ext_alt_text" in z and z["ext_alt_text"] != None:
+                        image_description.append(z["ext_alt_text"])
+            if hasattr(tweet, "retweeted_status") and hasattr(tweet.retweeted_status, "extended_entities") and "media" in tweet.retweeted_status.extended_entities:
+                for z in tweet.retweeted_status.extended_entities["media"]:
+                    if "ext_alt_text" in z and z["ext_alt_text"] != None:
+                        image_description.append(z["ext_alt_text"])
+            self.message = twitterDialogs.viewTweet(text, rt_count, favs_count, source, date)
+            results = parse_tweet(text)
+            self.message.set_title(results.weightedLength)
+            [self.message.set_image_description(i) for i in image_description]
+        else:
+            self.title = _(u"View item")
+            text = tweet
+            self.message = twitterDialogs.viewNonTweet(text, date)
+        widgetUtils.connect_event(self.message.spellcheck, widgetUtils.BUTTON_PRESSED, self.spellcheck)
+        if item_url != "":
+            self.message.enable_button("share")
+            widgetUtils.connect_event(self.message.share, widgetUtils.BUTTON_PRESSED, self.share)
+            self.item_url = item_url
+        widgetUtils.connect_event(self.message.translateButton, widgetUtils.BUTTON_PRESSED, self.translate)
+        self.message.ShowModal()
+
+    # We won't need text_processor in this dialog, so let's avoid it.
+    def text_processor(self):
+        pass
+
+    def clear_text(self, text):
+        text = utils.StripChars(text)
+        urls = utils.find_urls_in_text(text)
+        for i in urls:
+            if "https://twitter.com/" in i:
+                text = text.replace(i, "\n")
+        return text
+
+    def share(self, *args, **kwargs):
+        if hasattr(self, "item_url"):
+            output.copy(self.item_url)
+            output.speak(_("Link copied to clipboard."))

src/controller/twitter/templateEditor.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+import re
+import wx
+from typing import List
+from sessions.twitter.templates import tweet_variables, dm_variables, person_variables
+from wxUI.dialogs.twitterDialogs import templateDialogs
+
+class EditTemplate(object):
+    def __init__(self, template: str, type: str) -> None:
+        super(EditTemplate, self).__init__()
+        self.default_template = template
+        if type == "tweet":
+            self.variables = tweet_variables
+        elif type == "dm":
+            self.variables = dm_variables
+        else:
+            self.variables = person_variables
+        self.template: str = template
+
+    def validate_template(self, template: str) -> bool:
+        used_variables: List[str] = re.findall("\$\w+", template)
+        validated: bool = True
+        for var in used_variables:
+            if var[1:] not in self.variables:
+                validated = False
+        return validated
+
+    def run_dialog(self) -> str:
+        dialog = templateDialogs.EditTemplateDialog(template=self.template, variables=self.variables, default_template=self.default_template)
+        response = dialog.ShowModal()
+        if response == wx.ID_SAVE:
+            validated: bool = self.validate_template(dialog.template.GetValue())
+            if validated == False:
+                templateDialogs.invalid_template()
+                self.template = dialog.template.GetValue()
+                return self.run_dialog()
+            else:
+                return dialog.template.GetValue()
+        else:
+            return ""

src/controller/twitter/trendingTopics.py

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+from wxUI.dialogs import trends
+import widgetUtils
+
+class trendingTopicsController(object):
+    def __init__(self, session):
+        super(trendingTopicsController, self).__init__()
+        self.countries = {}
+        self.cities = {}
+        self.dialog = trends.trendingTopicsDialog()
+        self.information = session.twitter.available_trends()
+        self.split_information()
+        widgetUtils.connect_event(self.dialog.country, widgetUtils.RADIOBUTTON, self.get_places)
+        widgetUtils.connect_event(self.dialog.city, widgetUtils.RADIOBUTTON, self.get_places)
+        self.get_places()
+
+    def split_information(self):
+        for i in self.information:
+            if i["placeType"]["name"] == "Country":
+                self.countries[i["name"]] = i["woeid"]
+            else:
+                self.cities[i["name"]] = i["woeid"]
+
+    def get_places(self, event=None):
+        values = []
+        if self.dialog.get_active() == "country":
+            for i in self.information:
+                if i["placeType"]["name"] == "Country":
+                    values.append(i["name"])
+        elif self.dialog.get_active() == "city":
+            for i in self.information:
+                if i["placeType"]["name"] != "Country":
+                    values.append(i["name"])
+        self.dialog.set(values)
+
+    def get_woeid(self):
+        selected = self.dialog.get_item()
+        if self.dialog.get_active() == "country":
+            woeid = self.countries[selected]
+        else:
+            woeid = self.cities[selected]
+        return woeid
+
+    def get_string(self):
+        return self.dialog.get_item()

src/controller/twitter/user.py

@@ -0,0 +1,128 @@
+# -*- coding: utf-8 -*-
+import wx
+import webbrowser
+import widgetUtils
+import output
+from wxUI.dialogs import update_profile, show_user
+import logging
+log = logging.getLogger("controller.user")
+from tweepy.errors import TweepyException, Forbidden, NotFound
+from sessions.twitter import utils
+
+class profileController(object):
+    def __init__(self, session, user=None):
+        super(profileController, self).__init__()
+        self.file = None
+        self.session = session
+        self.user = user
+        if user == None:
+            self.get_data(screen_name=self.session.db["user_name"])
+            self.dialog = update_profile.updateProfileDialog()
+            self.fill_profile_fields()
+            self.uploaded = False
+            widgetUtils.connect_event(self.dialog.upload_image, widgetUtils.BUTTON_PRESSED, self.upload_image)
+        else:
+            try:
+                self.get_data(screen_name=self.user)
+            except TweepyException as err:
+                if type(err) == NotFound:
+                    wx.MessageDialog(None, _(u"That user does not exist"), _(u"Error"), wx.ICON_ERROR).ShowModal()
+                if type(err) == Forbidden:
+                    wx.MessageDialog(None, _(u"User has been suspended"), _(u"Error"), wx.ICON_ERROR).ShowModal()
+                log.error("error %s" % (str(err)))
+                return
+            self.dialog = show_user.showUserProfile()
+            string = self.get_user_info()
+            self.dialog.set("text", string)
+            self.dialog.set_title(_(u"Information for %s") % (self.data.screen_name))
+            if self.data.url != None:
+                self.dialog.enable_url()
+                widgetUtils.connect_event(self.dialog.url, widgetUtils.BUTTON_PRESSED, self.visit_url)
+        if self.dialog.get_response() == widgetUtils.OK and self.user == None:
+            self.do_update()
+
+    def get_data(self, screen_name):
+        self.data = self.session.twitter.get_user(screen_name=screen_name)
+        if screen_name != self.session.db["user_name"]:
+            self.friendship_status = self.session.twitter.get_friendship(source_screen_name=self.session.db["user_name"], target_screen_name=screen_name)
+
+    def fill_profile_fields(self):
+        self.dialog.set_name(self.data.name)
+        if self.data.url != None:
+            self.dialog.set_url(self.data.url)
+        if len(self.data.location) > 0:
+            self.dialog.set_location(self.data.location)
+        if len(self.data.description) > 0:
+            self.dialog.set_description(self.data.description)
+
+    def get_image(self):
+        file = self.dialog.upload_picture()
+        if file != None:
+            self.file = open(file, "rb")
+            self.uploaded = True
+            self.dialog.change_upload_button(self.uploaded)
+
+    def discard_image(self):
+        self.file = None
+        output.speak(_(u"Discarded"))
+        self.uploaded = False
+        self.dialog.change_upload_button(self.uploaded)
+
+    def upload_image(self, *args, **kwargs):
+        if self.uploaded == False:
+            self.get_image()
+        elif self.uploaded == True:
+            self.discard_image()
+
+    def do_update(self):
+        if self.user != None: return
+        name = self.dialog.get("name")
+        description = self.dialog.get("description")
+        location = self.dialog.get("location")
+        url = self.dialog.get("url")
+        if self.file != None:
+            try:
+                self.session.twitter.update_profile_image(image=self.file)
+            except TweepyException as e:
+                output.speak(u"Error %s" % (str(e)))
+        try:
+            self.session.twitter.update_profile(name=name, description=description, location=location, url=url)
+        except TweepyException as e:
+            output.speak(u"Error %s." % (str(e)))
+
+    def get_user_info(self):
+        string = u""
+        string = string + _(u"Username: @%s\n") % (self.data.screen_name)
+        string = string + _(u"Name: %s\n") % (self.data.name)
+        if self.data.location != "":
+            string = string + _(u"Location: %s\n") % (self.data.location)
+        if self.data.url != None:
+            string = string+ _(u"URL: %s\n") % (self.data.entities["url"]["urls"][0]["expanded_url"])
+        if self.data.description != "":
+            if self.data.entities.get("description") != None and self.data.entities["description"].get("urls"):
+                self.data.description = utils.expand_urls(self.data.description, self.data.entities["description"])
+            string = string+ _(u"Bio: %s\n") % (self.data.description)
+        if self.data.protected == True: protected = _(u"Yes")
+        else: protected = _(u"No")
+        string = string+ _(u"Protected: %s\n") % (protected)
+        if hasattr(self, "friendship_status"):
+            relation = False
+            friendship = _(u"Relationship: ")
+            if self.friendship_status[0].following:
+                friendship += _(u"You follow {0}. ").format(self.data.name,)
+                relation = True
+            if self.friendship_status[1].following:
+                friendship += _(u"{0} is following you.").format(self.data.name,)
+                relation = True
+            if relation == True:
+                string = string+friendship+"\n"
+        string = string+_(u"Followers: %s\n Friends: %s\n") % (self.data.followers_count, self.data.friends_count)
+        if self.data.verified == True: verified = _(u"Yes")
+        else: verified = _(u"No")
+        string = string+ _(u"Verified: %s\n") % (verified)
+        string = string+ _(u"Tweets: %s\n") % (self.data.statuses_count)
+        string = string+ _(u"Likes: %s") % (self.data.favourites_count)
+        return string
+
+    def visit_url(self, *args, **kwargs):
+        webbrowser.open_new_tab(self.data.url)

src/controller/twitter/userActions.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+import widgetUtils
+import output
+from wxUI.dialogs import userActions
+from pubsub import pub
+from tweepy.errors  import TweepyException
+from extra.autocompletionUsers import completion
+
+class userActionsController(object):
+    def __init__(self, buffer, users=[], default="follow"):
+        super(userActionsController, self).__init__()
+        self.buffer = buffer
+        self.session = buffer.session
+        self.dialog = userActions.UserActionsDialog(users, default)
+        widgetUtils.connect_event(self.dialog.autocompletion, widgetUtils.BUTTON_PRESSED, self.autocomplete_users)
+        if self.dialog.get_response() == widgetUtils.OK:
+            self.process_action()
+
+    def autocomplete_users(self, *args, **kwargs):
+        c = completion.autocompletionUsers(self.dialog, self.session.session_id)
+        c.show_menu("dm")
+
+    def process_action(self):
+        action = self.dialog.get_action()
+        user = self.dialog.get_user()
+        if user == "": return
+        getattr(self, action)(user)
+
+    def follow(self, user):
+        try:
+            self.session.twitter.create_friendship(screen_name=user )
+            pub.sendMessage("restartStreaming", session=self.session.session_id)
+        except TweepyException  as err:
+            output.speak("Error %s" % (str(err)), True)
+
+    def unfollow(self, user):
+        try:
+            id = self.session.twitter.destroy_friendship(screen_name=user )
+            pub.sendMessage("restartStreaming", session=self.session.session_id)
+        except TweepyException as err:
+            output.speak("Error %s" % (str(err)), True)
+
+    def mute(self, user):
+        try:
+            id = self.session.twitter.create_mute(screen_name=user )
+            pub.sendMessage("restartStreaming", session=self.session.session_id)
+        except TweepyException as err:
+            output.speak("Error %s" % (str(err)), True)
+
+    def unmute(self, user):
+        try:
+            id = self.session.twitter.destroy_mute(screen_name=user )
+            pub.sendMessage("restartStreaming", session=self.session.session_id)
+        except TweepyException as err:
+            output.speak("Error %s" % (str(err)), True)
+
+    def report(self, user):
+        try:
+            id = self.session.twitter.report_spam(screen_name=user )
+            pub.sendMessage("restartStreaming", session=self.session.session_id)
+        except TweepyException as err:
+            output.speak("Error %s" % (str(err)), True)
+
+    def block(self, user):
+        try:
+            id = self.session.twitter.create_block(screen_name=user )
+            pub.sendMessage("restartStreaming", session=self.session.session_id)
+        except TweepyException as err:
+            output.speak("Error %s" % (str(err)), True)
+
+    def unblock(self, user):
+        try:
+            id = self.session.twitter.destroy_block(screen_name=user )
+        except TweepyException as err:
+            output.speak("Error %s" % (str(err)), True)
+
+    def ignore_client(self, user):
+        tweet = self.buffer.get_right_tweet()
+        if hasattr(tweet, "sender"):
+            output.speak(_(u"You can't ignore direct messages"))
+            return
+        client = tweet.source
+        if client not in self.session.settings["twitter"]["ignored_clients"]:
+            self.session.settings["twitter"]["ignored_clients"].append(client)
+            self.session.settings.write()