Fixed error 500 if the user does not have notification username

boards/abstracts/settingsmanager.py

@@ -1,181 +1,183 b''
 from boards.models import Tag
 from boards.models.thread import FAV_THREAD_NO_UPDATES
 
 MAX_TRIPCODE_COLLISIONS = 50
 
 __author__ = 'neko259'
 
 SESSION_SETTING = 'setting'
 
 # Remove this, it is not used any more cause there is a user's permission
 PERMISSION_MODERATE = 'moderator'
 
 SETTING_THEME = 'theme'
 SETTING_FAVORITE_TAGS = 'favorite_tags'
 SETTING_FAVORITE_THREADS = 'favorite_threads'
 SETTING_HIDDEN_TAGS = 'hidden_tags'
 SETTING_PERMISSIONS = 'permissions'
 SETTING_USERNAME = 'username'
 SETTING_LAST_NOTIFICATION_ID = 'last_notification'
 SETTING_IMAGE_VIEWER = 'image_viewer'
 SETTING_TRIPCODE = 'tripcode'
 
 DEFAULT_THEME = 'md'
 
 
 class SettingsManager:
     """
     Base settings manager class. get_setting and set_setting methods should
     be overriden.
     """
     def __init__(self):
         pass
 
     def get_theme(self) -> str:
         theme = self.get_setting(SETTING_THEME)
         if not theme:
             theme = DEFAULT_THEME
             self.set_setting(SETTING_THEME, theme)
 
         return theme
 
     def set_theme(self, theme):
         self.set_setting(SETTING_THEME, theme)
 
     def has_permission(self, permission):
         permissions = self.get_setting(SETTING_PERMISSIONS)
         if permissions:
             return permission in permissions
         else:
             return False
 
     def get_setting(self, setting, default=None):
         pass
 
     def set_setting(self, setting, value):
         pass
 
     def add_permission(self, permission):
         permissions = self.get_setting(SETTING_PERMISSIONS)
         if not permissions:
             permissions = [permission]
         else:
             permissions.append(permission)
         self.set_setting(SETTING_PERMISSIONS, permissions)
 
     def del_permission(self, permission):
         permissions = self.get_setting(SETTING_PERMISSIONS)
         if not permissions:
             permissions = []
         else:
             permissions.remove(permission)
         self.set_setting(SETTING_PERMISSIONS, permissions)
 
     def get_fav_tags(self) -> list:
         tag_names = self.get_setting(SETTING_FAVORITE_TAGS)
         tags = []
         if tag_names:
             tags = list(Tag.objects.filter(name__in=tag_names))
         return tags
 
     def add_fav_tag(self, tag):
         tags = self.get_setting(SETTING_FAVORITE_TAGS)
         if not tags:
             tags = [tag.name]
         else:
             if not tag.name in tags:
                 tags.append(tag.name)
 
         tags.sort()
         self.set_setting(SETTING_FAVORITE_TAGS, tags)
 
     def del_fav_tag(self, tag):
         tags = self.get_setting(SETTING_FAVORITE_TAGS)
         if tag.name in tags:
             tags.remove(tag.name)
             self.set_setting(SETTING_FAVORITE_TAGS, tags)
 
     def get_hidden_tags(self) -> list:
         tag_names = self.get_setting(SETTING_HIDDEN_TAGS)
         tags = []
         if tag_names:
             tags = list(Tag.objects.filter(name__in=tag_names))
 
         return tags
 
     def add_hidden_tag(self, tag):
         tags = self.get_setting(SETTING_HIDDEN_TAGS)
         if not tags:
             tags = [tag.name]
         else:
             if not tag.name in tags:
                 tags.append(tag.name)
 
         tags.sort()
         self.set_setting(SETTING_HIDDEN_TAGS, tags)
 
     def del_hidden_tag(self, tag):
         tags = self.get_setting(SETTING_HIDDEN_TAGS)
         if tag.name in tags:
             tags.remove(tag.name)
             self.set_setting(SETTING_HIDDEN_TAGS, tags)
 
     def get_fav_threads(self) -> dict:
         return self.get_setting(SETTING_FAVORITE_THREADS, default=dict())
 
     def add_or_read_fav_thread(self, opening_post):
         threads = self.get_fav_threads()
         thread = opening_post.get_thread()
         # Don't check for new posts if the thread is archived already
         if thread.is_archived():
             last_id = FAV_THREAD_NO_UPDATES
         else:
             last_id = thread.get_replies().last().id
         threads[str(opening_post.id)] = last_id
         self.set_setting(SETTING_FAVORITE_THREADS, threads)
 
     def del_fav_thread(self, opening_post):
         threads = self.get_fav_threads()
         if self.thread_is_fav(opening_post):
             del threads[str(opening_post.id)]
             self.set_setting(SETTING_FAVORITE_THREADS, threads)
 
     def thread_is_fav(self, opening_post):
         return str(opening_post.id) in self.get_fav_threads()
 
     def get_notification_usernames(self):
         names = set()
-        name_list = self.get_setting(SETTING_USERNAME).strip()
-        if name_list is not None and len(name_list) > 0:
-            names = name_list.lower().split(',')
-            names = set(name.strip() for name in names)
+        name_list = self.get_setting(SETTING_USERNAME)
+        if name_list is not None:
+            name_list = name_list.strip()
+            if len(name_list) > 0:
+                names = name_list.lower().split(',')
+                names = set(name.strip() for name in names)
         return names
 
 
 class SessionSettingsManager(SettingsManager):
     """
     Session-based settings manager. All settings are saved to the user's
     session.
     """
     def __init__(self, session):
         SettingsManager.__init__(self)
         self.session = session
 
     def get_setting(self, setting, default=None):
         if setting in self.session:
             return self.session[setting]
         else:
             self.set_setting(setting, default)
             return default
 
     def set_setting(self, setting, value):
         self.session[setting] = value
 
 
 def get_settings_manager(request) -> SettingsManager:
     """
     Get settings manager based on the request object. Currently only
     session-based manager is supported. In the future, cookie-based or
     database-based managers could be implemented.
     """
     return SessionSettingsManager(request.session)