[Sync] Document refactoring + attaching to post

utils/Sync/sync/models/Document.py

@@ -6,14 +6,17 @@ from db import collection
 from sync.data import scan_subdirs, request
 from sync.models import Model
 from sync.models.Image import Image
-from utils.hash import hash_str
+from utils.hash import hash_str, md5
 from utils.image import image_magick_pdf_to_img
-from utils.text.transform import url_encode_text, url_encode_file
 
 store = collection(settings.collection_documents)
 
 
 class Document(Model):
+    @staticmethod
+    async def find_one(query):
+        return store.find_one(query)
+
     @staticmethod
     async def find(query):
         return store.find(query)
@@ -24,7 +27,8 @@ class Document(Model):
 
     @staticmethod
     async def scan(provider):
-        paths = scan_subdirs(provider, '.pdf')
+        scan_dir = settings.dir_documents
+        paths = scan_subdirs(provider, '.pdf', scan_dir)
         return [Document.read_path(provider, path) for path in paths]
 
     @staticmethod
@@ -39,28 +43,53 @@ class Document(Model):
         return Document(
             provider,
             path,
-            **document
+            document
         )
 
-    def __init__(self, provider, file, category=None, title=None):
+    @staticmethod
+    async def new(provider, file, sizes):
+        document = Document.read_path(provider, file)
+        changed = await document.is_changed()
+        if changed:
+            await document.build(sizes=sizes)
+            await document.upload()
+            await document.save()
+        else:
+            doc = await Document.find_one({'file': file})
+            document = Document(provider, file, doc)
+            document.ref = doc['_id']
+            await document.create_preview(sizes)
+
+        return document
+
+    def __init__(self, provider, file, params=None):
+        self.__hash_salt = settings.hash_salt_documents
         self.__hash_keys = ['id', 'url']
 
         self.__id_template: str = '{category}-{file}'
         self.__url_template: str = settings.document_url_template
         self.__url_preview_template: str = settings.document_url_preview_template
 
-        self.category = category
-        self.title = title
+        self.title = None
+        self.file_name = None
+        self.file_size = None
         self.type = 'document'  # 'award'
         self.preview = None
 
-        super().__init__(provider, store, file)
+        super().__init__(provider, store, file, params=params)
 
     def init(self):
         self.__set_id()
         self.__set_url()
         self.__set_hash()
 
+        filename = os.path.basename(self.file)
+        self.file_name = filename
+        self.file_size = self.provider.size(self.file)
+
+        if self.has_param('title'):
+            self.title = self.get_param('title')
+
     async def build(self, **kwargs):
         sizes = kwargs['sizes']
         await self.create_preview(sizes)
@@ -75,7 +104,10 @@ class Document(Model):
         query = {'id': document['id']}
         try:
             self.store.update_one(query, {'$set': document}, upsert=True)
-            # return self.read(document)
+
+            doc = await Document.find_one(query)
+            self.ref = doc['_id']
+
             return self
         except ValueError:
             pass
@@ -89,58 +121,59 @@ class Document(Model):
         await request.upload(url, filepath)
 
     def bake(self):
-        file = self.file
-        filename = os.path.basename(file)
-
         return {
+            **self.params,
             'id': self.id,
+            'file': self.file,
             'hash': self.hash,
             'url': self.url,
             'type': self.type,
-            'file': {
-                'name': filename,
-                'size': self.provider.size(file)
-            },
-            'preview': self.preview,
             'title': self.title,
+            'preview': self.preview.ref,
+            'fileInfo': {
+                'name': self.file_name,
+                'size': self.file_size,
+            },
         }
 
     def __filename(self):
         return os.path.basename(self.file)
 
     def __set_id(self):
-        self.id = self.__id_template.format(
-            category=url_encode_text(self.category),
-            file=url_encode_text(self.__filename())
-        )
+        self.id = md5(self.file)
 
     def __set_url(self):
+        s = os.path.splitext(self.file)
+        file = f'{self.id}{s[1]}'
+
         self.url = self.__url_template.format(
-            file=url_encode_file(self.__filename())
+            file=file
         )
 
     def __set_hash(self):
         doc = [getattr(self, key) for key in self.__hash_keys]
 
         self.hash = hash_str(
-            hash_str(doc) + self.provider.hash(self.file)
+            self.__hash_salt + hash_str(doc) + self.provider.hash(self.file)
         )
 
     async def create_preview(self, sizes):
-        def url(_, size, ext):
-            file = url_encode_text(self.__filename())
-            return self.__url_preview_template.format(id=file, size=size, ext=ext)
+        if False and self.has_param('preview'):
+            preview = self.get_param('preview')
+            preview = await Image.find_one({'_id': preview})
+        else:
+            def url(_, size, ext):
+                return self.__url_preview_template.format(id=self.id, size=size, ext=ext)
 
-        temp_preview_path = await pdf_to_jpg(self.provider, self.file)
-        preview = await Image.new(self.provider, temp_preview_path, sizes, url)
+            temp_preview_path = await pdf_to_jpg(self.provider, self.file)
+            preview = await Image.new(self.provider, temp_preview_path, sizes, url)
+            os.remove(temp_preview_path)
 
         if preview:
-            self.preview = preview.id
-
-        os.remove(temp_preview_path)
+            self.preview = preview
 
     def __str__(self):
-        return '<Document hash={} file={} id={}>'.format(self.hash, self.file, self.id)
+        return f'<Document file={self.file} id={self.id}>'
 
 
 async def pdf_to_jpg(provider, pdf):