267 lines
6.8 KiB
Python
267 lines
6.8 KiB
Python
import datetime
|
|
import logging
|
|
import os
|
|
import re
|
|
import shutil
|
|
|
|
from os.path import dirname
|
|
from pathlib import Path
|
|
from sys import getfilesystemencoding
|
|
|
|
from django.core.exceptions import PermissionDenied
|
|
from django.utils.decorators import method_decorator
|
|
from django.utils.functional import cached_property
|
|
|
|
from django_http_auth.decorators import http_basic_auth
|
|
|
|
from djangodav.acls import DavAcl, ReadOnlyAcl, FullAcl
|
|
from djangodav.base.resources import BaseDavResource, MetaEtagMixIn
|
|
from djangodav.fs.resources import DummyFSDAVResource
|
|
from djangodav.locks import DummyLock
|
|
from djangodav.utils import url_join
|
|
from djangodav.views import DavView
|
|
|
|
from procat2.models import Catalog
|
|
from procat2.settings import ASSET_DIR
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
fs_encoding = getfilesystemencoding()
|
|
|
|
|
|
@method_decorator(http_basic_auth, name='dispatch')
|
|
class MarkupDavView(DavView):
|
|
|
|
def __init__(self):
|
|
super().__init__(resource_class=resource_factory, lock_class=DummyLock, acl_class=FullAcl)
|
|
|
|
def get_access(self, resource):
|
|
return resource.get_acl()
|
|
|
|
|
|
def resource_factory(**kwargs):
|
|
# log.info(f"resource_factory '{kwargs}'")
|
|
path = kwargs['path']
|
|
if path == RootFolderResource.PATH:
|
|
return RootFolderResource(**kwargs)
|
|
elif path == CatalogFolderResource.PATH:
|
|
return CatalogFolderResource(**kwargs)
|
|
elif is_my_cats_catalog(path):
|
|
return CatalogResource(**kwargs)
|
|
elif is_markup_catalog(path):
|
|
return MarkupResource(**kwargs)
|
|
else:
|
|
return NonsensicalResource(**kwargs)
|
|
|
|
def is_my_cats_catalog(path):
|
|
return re.search(fr'^{CatalogFolderResource.PATH}.*-([0-9]+)\.pdf', path, re.I)
|
|
|
|
def is_markup_catalog(path):
|
|
return re.search(fr'^{MarkupResource.PATH}', path, re.I)
|
|
|
|
|
|
class MarkupDavResource(MetaEtagMixIn, BaseDavResource):
|
|
|
|
def __str__(self):
|
|
return f"<{type(self).__name__} '{self.user}' '{self.path}'>"
|
|
|
|
def get_acl(self):
|
|
return ReadOnlyAcl()
|
|
# return DavAcl(read=True, write=False, delete=False, full=None)
|
|
|
|
|
|
class RootFolderResource(MarkupDavResource):
|
|
NAME = ''
|
|
PATH = '/'
|
|
|
|
def get_parent(self):
|
|
return None
|
|
|
|
def get_children(self):
|
|
children = [CatalogFolderResource(CatalogFolderResource.PATH, self.user),
|
|
MarkupResource(MarkupResource.PATH, self.user)]
|
|
for child in children:
|
|
yield child
|
|
|
|
@property
|
|
def getcontentlength(self):
|
|
return 2
|
|
|
|
def get_created(self):
|
|
return datetime.datetime.now() # TODO last created time of object in there?
|
|
|
|
def get_modified(self):
|
|
return datetime.datetime.now() # TODO last modified time of object in there?
|
|
|
|
@property
|
|
def is_collection(self):
|
|
return True
|
|
|
|
@property
|
|
def is_object(self):
|
|
return False
|
|
|
|
@property
|
|
def exists(self):
|
|
return True
|
|
|
|
|
|
class CatalogFolderResource(MarkupDavResource):
|
|
NAME = 'My Catalogs'
|
|
PATH = f'/{NAME}/'
|
|
MARKUP_SUBMIT_NAME = 'For Markup'
|
|
MARKUP_SUBMIT_PATH = f'/{MARKUP_SUBMIT_NAME}/'
|
|
|
|
def get_parent(self):
|
|
return RootFolderResource(user=self.user)
|
|
|
|
def get_children(self):
|
|
for child in self.user_catalogs:
|
|
yield CatalogResource(path=url_join(*(self.path + [child])), user=self.user)
|
|
|
|
@cached_property
|
|
def user_catalogs(self):
|
|
cats = Catalog.objects.filter(owner=self.user).order_by('-updated')
|
|
return [c.pdf_name() for c in cats if c.pdf_exists()]
|
|
|
|
@property
|
|
def getcontentlength(self):
|
|
return 2 # TODO based on contents
|
|
|
|
def get_created(self):
|
|
return datetime.datetime.now() # TODO last created time of object in there?
|
|
|
|
def get_modified(self):
|
|
return datetime.datetime.now() # TODO last modified time of object in there?
|
|
|
|
@property
|
|
def is_collection(self):
|
|
return True
|
|
|
|
@property
|
|
def is_object(self):
|
|
return False
|
|
|
|
@property
|
|
def exists(self):
|
|
return True
|
|
|
|
|
|
class CatalogResource(MarkupDavResource):
|
|
|
|
def get_parent(self):
|
|
return CatalogFolderResource(path=CatalogFolderResource.PATH, user=self.user)
|
|
|
|
def get_children(self):
|
|
return
|
|
yield
|
|
|
|
@cached_property
|
|
def catalog(self):
|
|
id = self.id_from_pdf_name(self.path)
|
|
return Catalog.objects.get(id=id)
|
|
|
|
def id_from_pdf_name(self, path):
|
|
result = re.search(r'-([0-9]+)\.pdf', path[-1], re.I)
|
|
if result and result.groups():
|
|
return result.group(1)
|
|
else:
|
|
return None
|
|
|
|
@property
|
|
def getcontentlength(self):
|
|
if self.catalog.pdf_exists():
|
|
return os.stat(self.catalog.pdf_file()).st_size
|
|
else:
|
|
return 0
|
|
|
|
def get_created(self):
|
|
return self.catalog.created
|
|
|
|
def get_modified(self):
|
|
return self.catalog.updated
|
|
|
|
@property
|
|
def is_collection(self):
|
|
return False
|
|
|
|
@property
|
|
def is_object(self):
|
|
return True
|
|
|
|
@property
|
|
def exists(self):
|
|
return self.catalog.pdf_exists()
|
|
|
|
def read(self):
|
|
if self.catalog.pdf_exists():
|
|
return open(self.catalog.pdf_file(), 'rb')
|
|
else:
|
|
return None
|
|
|
|
|
|
|
|
class MarkupResource(MarkupDavResource, DummyFSDAVResource):
|
|
NAME = 'For Markup'
|
|
PATH = f'/{NAME}/'
|
|
|
|
def get_parent(self):
|
|
parent_path = self.path[:-1]
|
|
if len(parent_path):
|
|
return MarkupResource(path=self.construct_path(parent_path, True), user=self.user)
|
|
else:
|
|
return RootFolderResource(user=self.user)
|
|
|
|
def get_children(self):
|
|
path = self.get_abs_path()
|
|
if os.path.isdir(path):
|
|
for child in os.listdir(path):
|
|
is_unicode = isinstance(child, str)
|
|
if not is_unicode:
|
|
child = child.decode(fs_encoding)
|
|
yield MarkupResource(path=url_join(*(self.path + [child])), user=self.user)
|
|
|
|
def get_abs_path(self):
|
|
path = os.path.join(self.get_markup_user_path(), *self.path[1:])
|
|
# log.debug(f'markup folder user is {self.user} and path {self.path}: {path}')
|
|
return path
|
|
|
|
def write(self, request, temp_file=None, range_start=None):
|
|
super().write(request, temp_file=temp_file, range_start=range_start)
|
|
|
|
def get_acl(self):
|
|
return FullAcl()
|
|
|
|
|
|
class NonsensicalResource(MarkupDavResource):
|
|
|
|
def get_parent(self):
|
|
log.debug(f'nonsense parent of {self.path}')
|
|
return RootFolderResource(path=RootFolderResource.PATH, user=self.user)
|
|
|
|
def get_children(self):
|
|
return
|
|
yield
|
|
|
|
@property
|
|
def getcontentlength(self):
|
|
return 0
|
|
|
|
def get_created(self):
|
|
return datetime.datetime.now()
|
|
|
|
def get_modified(self):
|
|
return datetime.datetime.now()
|
|
|
|
@property
|
|
def is_collection(self):
|
|
return False
|
|
|
|
@property
|
|
def is_object(self):
|
|
return True
|
|
|
|
@property
|
|
def exists(self):
|
|
return False
|