131 lines
3.9 KiB
Python
131 lines
3.9 KiB
Python
import logging
|
|
|
|
import os
|
|
|
|
import settings
|
|
from db import collection
|
|
from sync import create_post
|
|
from sync.data import Provider
|
|
from sync.models import Model
|
|
from sync.models.Image import Image
|
|
|
|
from utils.fn import swap_ext
|
|
from utils.hash import hash_str
|
|
from utils.io import read_yaml_md, parse_yaml_front_matter
|
|
from utils.text.transform import url_encode_text
|
|
|
|
logger = logging.getLogger(settings.name + '.Person')
|
|
store = collection(settings.collection_collective)
|
|
|
|
|
|
class Person(Model):
|
|
@staticmethod
|
|
async def find(query):
|
|
return store.find(query)
|
|
|
|
@staticmethod
|
|
async def delete(query):
|
|
return store.find_one_and_delete(query)
|
|
|
|
@staticmethod
|
|
async def scan(provider):
|
|
scan_dir = settings.dir_persons
|
|
documents = provider.type_filter(scan_dir, '.md')
|
|
documents = [Person.read(provider, i) for i in documents]
|
|
return documents
|
|
|
|
@staticmethod
|
|
def read(provider, path):
|
|
params = get_manifest(provider, path)
|
|
|
|
return Person(
|
|
provider,
|
|
path,
|
|
params=params,
|
|
)
|
|
|
|
def __init__(self, provider, file, params=None):
|
|
self.__hash_salt = settings.hash_salt_person
|
|
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.picture = None
|
|
self.preview = None
|
|
self.post = None
|
|
self.images = None
|
|
self.documents = None
|
|
|
|
super().__init__(provider, store, file, params)
|
|
|
|
def init(self):
|
|
pass
|
|
self.__set_id()
|
|
self.__set_hash()
|
|
|
|
async def build(self, **kwargs):
|
|
sizes = kwargs['sizes']
|
|
image_path = self._get_relpath(self.get_param('picture'))
|
|
|
|
self.picture = await Image.new(self.provider, image_path, sizes)
|
|
|
|
markdown_post = self.get_param('content')
|
|
post, images, documents = await create_post(self.provider, self.get_param('folder'), markdown_post, sizes)
|
|
self.post = post
|
|
self.images = images
|
|
self.documents = documents
|
|
|
|
if self.has_param('preview'):
|
|
preview = self.get_param('preview')
|
|
preview = self._get_relpath(preview)
|
|
self.preview = await Image.new(self.provider, preview, sizes)
|
|
|
|
def bake(self):
|
|
return {
|
|
**self.params,
|
|
'post': self.post,
|
|
'images': [x.ref for x in self.images],
|
|
'documents': [x.ref for x in self.documents],
|
|
'id': self.id,
|
|
'hash': self.hash,
|
|
'file': self.file,
|
|
'picture': self.picture.ref,
|
|
'preview': self.preview.ref if self.preview else None,
|
|
}
|
|
|
|
def __set_id(self):
|
|
if 'id' in self.params:
|
|
self.id = self.params['id']
|
|
else:
|
|
self.id = url_encode_text(self.params['name'])
|
|
|
|
def __set_hash(self):
|
|
files = [self.file]
|
|
files.append(self._get_relpath(self.get_param('picture')))
|
|
|
|
if self.has_param('preview'):
|
|
files.append(self._get_relpath(self.get_param('preview')))
|
|
|
|
hashes = [self.provider.hash(x) for x in files]
|
|
self.hash = hash_str(
|
|
self.__hash_salt + ''.join(hashes)
|
|
)
|
|
|
|
def __str__(self):
|
|
return f'<Person file={self.file} id={self.id}>'
|
|
|
|
|
|
def get_manifest(provider: Provider, path: str) -> dict:
|
|
data = provider.read(path).read().decode('utf-8')
|
|
|
|
manifest = parse_yaml_front_matter(data)
|
|
return {
|
|
**manifest,
|
|
'picture': manifest['picture'] if 'picture' in manifest else os.path.basename(swap_ext('.jpg')(path)),
|
|
'preview': manifest['preview'] if 'preview' in manifest else os.path.basename(swap_ext('.jpg')(path)),
|
|
'folder': os.path.dirname(path),
|
|
'hidden': manifest['hidden'] if 'hidden' in manifest else False,
|
|
}
|