Moved exceptions to a separate module

boards/abstracts/exceptions.py

@@ -0,0 +1,10
+class BannedException(Exception):
+    pass
+
+
+class ArchiveException(Exception):
+    pass
+
+
+class SyncException(Exception):
+    pass

boards/models/post/manager.py

@@ -1,181 +1,181
 import logging
 
 from datetime import datetime, timedelta, date
 from datetime import time as dtime
 
+from boards.abstracts.exceptions import BannedException, ArchiveException
 from django.db import models, transaction
 from django.utils import timezone
 from django.dispatch import Signal
 
 import boards
 
 from boards.models.user import Ban
 from boards.mdx_neboard import Parser
 from boards.models import Attachment
 from boards import utils
 
 __author__ = 'neko259'
 
 POSTS_PER_DAY_RANGE = 7
 NO_IP = '0.0.0.0'
 
 
 post_import_deps = Signal()
 
 
 class PostManager(models.Manager):
     @transaction.atomic
     def create_post(self, title: str, text: str, file=None, thread=None,
                     ip=NO_IP, tags: list=None, opening_posts: list=None,
                     tripcode='', monochrome=False, images=[]):
         """
         Creates new post
         """
 
         if thread is not None and thread.is_archived():
-            raise Exception('Cannot post into an archived thread')
+            raise ArchiveException('Cannot post into an archived thread')
 
         if not utils.is_anonymous_mode():
             is_banned = Ban.objects.filter(ip=ip).exists()
         else:
             is_banned = False
 
-        # TODO Raise specific exception and catch it in the views
         if is_banned:
-            raise Exception("This user is banned")
+            raise BannedException("This user is banned")
 
         if not tags:
             tags = []
         if not opening_posts:
             opening_posts = []
 
         posting_time = timezone.now()
         new_thread = False
         if not thread:
             thread = boards.models.thread.Thread.objects.create(
                 bump_time=posting_time, last_edit_time=posting_time,
                     monochrome=monochrome)
             list(map(thread.tags.add, tags))
             boards.models.thread.Thread.objects.process_oldest_threads()
             new_thread = True
 
         pre_text = Parser().preparse(text)
 
         post = self.create(title=title,
                            text=pre_text,
                            pub_time=posting_time,
                            poster_ip=ip,
                            thread=thread,
                            last_edit_time=posting_time,
                            tripcode=tripcode,
                            opening=new_thread)
         post.threads.add(thread)
 
         logger = logging.getLogger('boards.post.create')
 
         logger.info('Created post [{}] with text [{}] by {}'.format(post,
             post.get_text(),post.poster_ip))
 
         if file:
             self._add_file_to_post(file, post)
         for image in images:
             post.images.add(image)
 
         post.connect_threads(opening_posts)
         post.set_global_id()
 
         # Thread needs to be bumped only when the post is already created
         if not new_thread:
             thread.last_edit_time = posting_time
             thread.bump()
             thread.save()
 
         return post
 
     def delete_posts_by_ip(self, ip):
         """
         Deletes all posts of the author with same IP
         """
 
         posts = self.filter(poster_ip=ip)
         for post in posts:
             post.delete()
 
     @utils.cached_result()
     def get_posts_per_day(self) -> float:
         """
         Gets average count of posts per day for the last 7 days
         """
 
         day_end = date.today()
         day_start = day_end - timedelta(POSTS_PER_DAY_RANGE)
 
         day_time_start = timezone.make_aware(datetime.combine(
             day_start, dtime()), timezone.get_current_timezone())
         day_time_end = timezone.make_aware(datetime.combine(
             day_end, dtime()), timezone.get_current_timezone())
 
         posts_per_period = float(self.filter(
             pub_time__lte=day_time_end,
             pub_time__gte=day_time_start).count())
 
         ppd = posts_per_period / POSTS_PER_DAY_RANGE
 
         return ppd
 
     @transaction.atomic
     def import_post(self, title: str, text: str, pub_time: str, global_id,
                     opening_post=None, tags=list(), files=list(),
                     tripcode=None, version=1):
         is_opening = opening_post is None
         if is_opening:
             thread = boards.models.thread.Thread.objects.create(
                 bump_time=pub_time, last_edit_time=pub_time)
             list(map(thread.tags.add, tags))
         else:
             thread = opening_post.get_thread()
 
         post = self.create(title=title,
                            text=text,
                            pub_time=pub_time,
                            poster_ip=NO_IP,
                            last_edit_time=pub_time,
                            global_id=global_id,
                            opening=is_opening,
                            thread=thread,
                            tripcode=tripcode,
                            version=version)
 
         for file in files:
             self._add_file_to_post(file, post)
 
         post.threads.add(thread)
 
         url_to_post = '[post]{}[/post]'.format(str(global_id))
         replies = self.filter(text__contains=url_to_post)
         for reply in replies:
             post_import_deps.send(reply.__class__)
 
     @transaction.atomic
     def update_post(self, post, title: str, text: str, pub_time: str,
                     tags=list(), files=list(), tripcode=None, version=1):
         post.title = title
         post.text = text
         post.pub_time = pub_time
         post.tripcode = tripcode
         post.version = version
         post.save()
 
         post.clear_cache()
 
         post.images.clear()
         post.attachments.clear()
         for file in files:
             self._add_file_to_post(file, post)
 
         thread = post.get_thread()
         thread.tags.clear()
         list(map(thread.tags.add, tags))
 
     def _add_file_to_post(self, file, post):
         post.attachments.add(Attachment.objects.create_with_hash(file))

boards/models/post/sync.py

@@ -1,301 +1,298
 import xml.etree.ElementTree as et
 
+from boards.abstracts.exceptions import SyncException
+from boards.models import KeyPair, GlobalId, Signature, Post, Tag
 from boards.models.attachment.downloaders import download
 from boards.utils import get_file_mimetype, get_file_hash
 from django.db import transaction
-from boards.models import KeyPair, GlobalId, Signature, Post, Tag
 
 EXCEPTION_NODE = 'Sync node returned an error: {}.'
 EXCEPTION_OP = 'Load the OP first.'
 EXCEPTION_DOWNLOAD = 'File was not downloaded.'
 EXCEPTION_HASH = 'File hash does not match attachment hash.'
 EXCEPTION_SIGNATURE = 'Invalid model signature for {}.'
 EXCEPTION_AUTHOR_SIGNATURE = 'Model {} has no author signature.'
 ENCODING_UNICODE = 'unicode'
 
 TAG_MODEL = 'model'
 TAG_REQUEST = 'request'
 TAG_RESPONSE = 'response'
 TAG_ID = 'id'
 TAG_STATUS = 'status'
 TAG_MODELS = 'models'
 TAG_TITLE = 'title'
 TAG_TEXT = 'text'
 TAG_THREAD = 'thread'
 TAG_PUB_TIME = 'pub-time'
 TAG_SIGNATURES = 'signatures'
 TAG_SIGNATURE = 'signature'
 TAG_CONTENT = 'content'
 TAG_ATTACHMENTS = 'attachments'
 TAG_ATTACHMENT = 'attachment'
 TAG_TAGS = 'tags'
 TAG_TAG = 'tag'
 TAG_ATTACHMENT_REFS = 'attachment-refs'
 TAG_ATTACHMENT_REF = 'attachment-ref'
 TAG_TRIPCODE = 'tripcode'
 TAG_VERSION = 'version'
 
 TYPE_GET = 'get'
 
 ATTR_VERSION = 'version'
 ATTR_TYPE = 'type'
 ATTR_NAME = 'name'
 ATTR_VALUE = 'value'
 ATTR_MIMETYPE = 'mimetype'
 ATTR_KEY = 'key'
 ATTR_REF = 'ref'
 ATTR_URL = 'url'
 ATTR_ID_TYPE = 'id-type'
 
 ID_TYPE_MD5 = 'md5'
 
 STATUS_SUCCESS = 'success'
 
 
-class SyncException(Exception):
-    pass
-
-
 class SyncManager:
     @staticmethod
     def generate_response_get(model_list: list):
         response = et.Element(TAG_RESPONSE)
 
         status = et.SubElement(response, TAG_STATUS)
         status.text = STATUS_SUCCESS
 
         models = et.SubElement(response, TAG_MODELS)
 
         for post in model_list:
             model = et.SubElement(models, TAG_MODEL)
             model.set(ATTR_NAME, 'post')
 
             global_id = post.global_id
 
             attachments = post.attachments.all()
             if global_id.content:
                 model.append(et.fromstring(global_id.content))
                 if len(attachments) > 0:
                     attachment_refs = et.SubElement(model, TAG_ATTACHMENT_REFS)
                     for file in attachments:
                         SyncManager._attachment_to_xml(
                             None, attachment_refs, file.file.file,
                             file.hash, file.file.url)
             else:
                 content_tag = et.SubElement(model, TAG_CONTENT)
 
                 tag_id = et.SubElement(content_tag, TAG_ID)
                 global_id.to_xml_element(tag_id)
 
                 title = et.SubElement(content_tag, TAG_TITLE)
                 title.text = post.title
 
                 text = et.SubElement(content_tag, TAG_TEXT)
                 text.text = post.get_sync_text()
 
                 thread = post.get_thread()
                 if post.is_opening():
                     tag_tags = et.SubElement(content_tag, TAG_TAGS)
                     for tag in thread.get_tags():
                         tag_tag = et.SubElement(tag_tags, TAG_TAG)
                         tag_tag.text = tag.name
                 else:
                     tag_thread = et.SubElement(content_tag, TAG_THREAD)
                     thread_id = et.SubElement(tag_thread, TAG_ID)
                     thread.get_opening_post().global_id.to_xml_element(thread_id)
 
                 pub_time = et.SubElement(content_tag, TAG_PUB_TIME)
                 pub_time.text = str(post.get_pub_time_str())
 
                 if post.tripcode:
                     tripcode = et.SubElement(content_tag, TAG_TRIPCODE)
                     tripcode.text = post.tripcode
 
                 if len(attachments) > 0:
                     attachments_tag = et.SubElement(content_tag, TAG_ATTACHMENTS)
                     attachment_refs = et.SubElement(model, TAG_ATTACHMENT_REFS)
 
                     for file in attachments:
                         SyncManager._attachment_to_xml(
                             attachments_tag, attachment_refs, file.file.file,
                             file.hash, file.file.url)
                 version_tag = et.SubElement(content_tag, TAG_VERSION)
                 version_tag.text = str(post.version)
 
                 global_id.content = et.tostring(content_tag, ENCODING_UNICODE)
                 global_id.save()
 
             signatures_tag = et.SubElement(model, TAG_SIGNATURES)
             post_signatures = global_id.signature_set.all()
             if post_signatures:
                 signatures = post_signatures
             else:
                 key = KeyPair.objects.get(public_key=global_id.key)
                 signature = Signature(
                     key_type=key.key_type,
                     key=key.public_key,
                     signature=key.sign(global_id.content),
                     global_id=global_id,
                 )
                 signature.save()
                 signatures = [signature]
             for signature in signatures:
                 signature_tag = et.SubElement(signatures_tag, TAG_SIGNATURE)
                 signature_tag.set(ATTR_TYPE, signature.key_type)
                 signature_tag.set(ATTR_VALUE, signature.signature)
                 signature_tag.set(ATTR_KEY, signature.key)
 
         return et.tostring(response, ENCODING_UNICODE)
 
     @staticmethod
     @transaction.atomic
     def parse_response_get(response_xml, hostname):
         tag_root = et.fromstring(response_xml)
         tag_status = tag_root.find(TAG_STATUS)
         if STATUS_SUCCESS == tag_status.text:
             tag_models = tag_root.find(TAG_MODELS)
             for tag_model in tag_models:
                 tag_content = tag_model.find(TAG_CONTENT)
 
                 content_str = et.tostring(tag_content, ENCODING_UNICODE)
 
                 tag_id = tag_content.find(TAG_ID)
                 global_id, exists = GlobalId.from_xml_element(tag_id)
                 signatures = SyncManager._verify_model(global_id, content_str, tag_model)
 
                 version = int(tag_content.find(TAG_VERSION).text)
                 is_old = exists and global_id.post.version < version
                 if exists and not is_old:
                     print('Post with same ID exists and is up to date.')
                 else:
                     global_id.content = content_str
                     global_id.save()
                     for signature in signatures:
                         signature.global_id = global_id
                         signature.save()
 
                     title = tag_content.find(TAG_TITLE).text or ''
                     text = tag_content.find(TAG_TEXT).text or ''
                     pub_time = tag_content.find(TAG_PUB_TIME).text
                     tripcode_tag = tag_content.find(TAG_TRIPCODE)
                     if tripcode_tag is not None:
                         tripcode = tripcode_tag.text or ''
                     else:
                         tripcode = ''
 
                     thread = tag_content.find(TAG_THREAD)
                     tags = []
                     if thread:
                         thread_id = thread.find(TAG_ID)
                         op_global_id, exists = GlobalId.from_xml_element(thread_id)
                         if exists:
                             opening_post = Post.objects.get(global_id=op_global_id)
                         else:
                             raise SyncException(EXCEPTION_OP)
                     else:
                         opening_post = None
                         tag_tags = tag_content.find(TAG_TAGS)
                         for tag_tag in tag_tags:
                             tag, created = Tag.objects.get_or_create(
                                 name=tag_tag.text)
                             tags.append(tag)
 
                     # TODO Check that the replied posts are already present
                     # before adding new ones
 
                     files = []
                     tag_attachments = tag_content.find(TAG_ATTACHMENTS) or list()
                     tag_refs = tag_model.find(TAG_ATTACHMENT_REFS)
                     for attachment in tag_attachments:
                         tag_ref = tag_refs.find("{}[@ref='{}']".format(
                             TAG_ATTACHMENT_REF, attachment.text))
                         url = tag_ref.get(ATTR_URL)
                         attached_file = download(hostname + url)
                         if attached_file is None:
                             raise SyncException(EXCEPTION_DOWNLOAD)
 
                         hash = get_file_hash(attached_file)
                         if hash != attachment.text:
                             raise SyncException(EXCEPTION_HASH)
 
                         files.append(attached_file)
 
                     if is_old:
                         post = global_id.post
                         Post.objects.update_post(
                             post, title=title, text=text, pub_time=pub_time,
                             tags=tags, files=files, tripcode=tripcode,
                             version=version)
                         print('Parsed updated post {}'.format(global_id))
                     else:
                         Post.objects.import_post(
                             title=title, text=text, pub_time=pub_time,
                             opening_post=opening_post, tags=tags,
                             global_id=global_id, files=files, tripcode=tripcode,
                             version=version)
                         print('Parsed new post {}'.format(global_id))
         else:
             raise SyncException(EXCEPTION_NODE.format(tag_status.text))
 
     @staticmethod
     def generate_response_list():
         response = et.Element(TAG_RESPONSE)
 
         status = et.SubElement(response, TAG_STATUS)
         status.text = STATUS_SUCCESS
 
         models = et.SubElement(response, TAG_MODELS)
 
         for post in Post.objects.prefetch_related('global_id').all():
             tag_model = et.SubElement(models, TAG_MODEL)
             tag_id = et.SubElement(tag_model, TAG_ID)
             post.global_id.to_xml_element(tag_id)
             tag_version = et.SubElement(tag_model, TAG_VERSION)
             tag_version.text = str(post.version)
 
         return et.tostring(response, ENCODING_UNICODE)
 
     @staticmethod
     def _verify_model(global_id, content_str, tag_model):
         """
         Verifies all signatures for a single model.
         """
 
         signatures = []
 
         tag_signatures = tag_model.find(TAG_SIGNATURES)
         has_author_signature = False
         for tag_signature in tag_signatures:
             signature_type = tag_signature.get(ATTR_TYPE)
             signature_value = tag_signature.get(ATTR_VALUE)
             signature_key = tag_signature.get(ATTR_KEY)
 
             if global_id.key_type == signature_type and\
                     global_id.key == signature_key:
                 has_author_signature = True
 
             signature = Signature(key_type=signature_type,
                                   key=signature_key,
                                   signature=signature_value)
 
             if not KeyPair.objects.verify(signature, content_str):
                 raise SyncException(EXCEPTION_SIGNATURE.format(content_str))
 
             signatures.append(signature)
         if not has_author_signature:
             raise SyncException(EXCEPTION_AUTHOR_SIGNATURE.format(content_str))
 
         return signatures
 
     @staticmethod
     def _attachment_to_xml(tag_attachments, tag_refs, file, hash, url):
         if tag_attachments is not None:
             mimetype = get_file_mimetype(file)
             attachment = et.SubElement(tag_attachments, TAG_ATTACHMENT)
             attachment.set(ATTR_MIMETYPE, mimetype)
             attachment.set(ATTR_ID_TYPE, ID_TYPE_MD5)
             attachment.text = hash
 
         attachment_ref = et.SubElement(tag_refs, TAG_ATTACHMENT_REF)
         attachment_ref.set(ATTR_REF, hash)
         attachment_ref.set(ATTR_URL, url)