passerelle/passerelle/apps/cmis/models.py

# passerelle - uniform access to multiple data sources and services
# Copyright (C) 2016  Entr'ouvert
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU Affero General Public License as published
# by the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import base64
import binascii
import functools
import re

import httplib2
from cmislib import CmisClient
from cmislib.exceptions import (
    CmisException,
    InvalidArgumentException,
    ObjectNotFoundException,
    PermissionDeniedException,
    UpdateConflictException,
)
from django.db import models
from django.utils.six import BytesIO
from django.utils.six.moves.urllib import error as urllib2
from django.utils.translation import ugettext_lazy as _

from passerelle.base.models import BaseResource
from passerelle.utils.api import endpoint
from passerelle.utils.jsonresponse import APIError

SPECIAL_CHARS = '!#$%&+-^_`~;[]{}+=~'
FILE_PATH_PATTERN = r'^(/|(/[\w%s]+)+)$' % re.escape(SPECIAL_CHARS)
FILE_NAME_PATTERN = r'[\w%s\.]+$' % re.escape(SPECIAL_CHARS)


UPLOAD_SCHEMA = {
    'type': 'object',
    'properties': {
        'file': {
            'type': 'object',
            'properties': {
                'filename': {
                    'type': 'string',
                    'pattern': FILE_NAME_PATTERN,
                },
                'content': {'type': 'string'},
                'content_type': {'type': 'string'},
            },
            'required': ['content'],
        },
        'filename': {
            'type': 'string',
            'pattern': FILE_NAME_PATTERN,
        },
        'path': {
            'type': 'string',
            'pattern': FILE_PATH_PATTERN,
        },
        'object_type': {'type': 'string'},
        'properties': {'type': 'object', 'additionalProperties': {'type': 'string'}},
    },
    'required': ['file', 'path'],
    'unflatten': True,
}


class CmisConnector(BaseResource):
    cmis_endpoint = models.URLField(
        max_length=400, verbose_name=_('CMIS Atom endpoint'), help_text=_('URL of the CMIS Atom endpoint')
    )
    username = models.CharField(max_length=128, verbose_name=_('Service username'))
    password = models.CharField(max_length=128, verbose_name=_('Service password'))
    category = _('Business Process Connectors')

    class Meta:
        verbose_name = _('CMIS connector')

    @endpoint(
        perm='can_access',
        post={
            'request_body': {
                'schema': {
                    'application/json': UPLOAD_SCHEMA,
                }
            }
        },
    )
    def uploadfile(self, request, post_data):
        error, error_msg, data = self._validate_inputs(post_data)
        if error:
            self.logger.debug("received invalid data: %s" % error_msg)
            raise APIError(error_msg, http_status=400)
        filename = data.get('filename') or data['file']['filename']
        self.logger.info("received file_name: '%s', file_path: '%s'", filename, data["path"])
        cmis_gateway = CMISGateway(self.cmis_endpoint, self.username, self.password, self.logger)
        doc = cmis_gateway.create_doc(
            filename,
            data['path'],
            data['file_byte_content'],
            content_type=data['file'].get('content_type'),
            object_type=data.get('object_type'),
            properties=data.get('properties'),
        )
        return {'data': {'properties': doc.properties}}

    def _validate_inputs(self, data):
        """process dict
        return a tuple (error, error_msg, data)
        """
        file_ = data['file']
        if 'filename' not in file_ and 'filename' not in data:
            return True, '"filename" or "file[\'filename\']" is required', None

        try:
            data['file_byte_content'] = base64.b64decode(file_['content'])
        except (TypeError, binascii.Error):
            return True, '"file[\'content\']" must be a valid base64 string', None

        if 'properties' in data and 'object_type' not in data:
            if any(prop for prop in data['properties'] if not prop.startswith('cmis:')):
                return True, 'Properties other than cmis: require object_type to be set', None

        return False, '', data


def wrap_cmis_error(f):
    @functools.wraps(f)
    def wrapper(*args, **kwargs):
        try:
            return f(*args, **kwargs)
        except (urllib2.URLError, httplib2.HttpLib2Error) as e:
            # FIXME urllib2 still used for cmslib 0.5 compat
            raise APIError("connection error: %s" % e)
        except PermissionDeniedException as e:
            raise APIError("permission denied: %s" % e)
        except UpdateConflictException as e:
            raise APIError("update conflict: %s" % e)
        except InvalidArgumentException as e:
            raise APIError("invalid property name: %s" % e)
        except CmisException as e:
            raise APIError("cmis binding error: %s" % e)

    return wrapper


class CMISGateway(object):
    def __init__(self, cmis_endpoint, username, password, logger):
        self._cmis_client = CmisClient(cmis_endpoint, username, password)
        self._logger = logger

    def _get_or_create_folder(self, file_path):
        repo = self._cmis_client.defaultRepository
        try:
            self._logger.debug("searching '%s'" % file_path)
            res = repo.getObjectByPath(file_path)
            self._logger.debug("'%s' found" % file_path)
            return res
        except ObjectNotFoundException:
            self._logger.debug("'%s' not found" % file_path)
            basepath = ""
            folder = repo.rootFolder
            for path_part in file_path.strip('/').split('/'):
                basepath += '/%s' % path_part
                try:
                    self._logger.debug("searching '%s'" % basepath)
                    folder = repo.getObjectByPath(basepath)
                    self._logger.debug("'%s' found" % basepath)
                except ObjectNotFoundException:
                    self._logger.debug("'%s' not found" % basepath)
                    folder = folder.createFolder(path_part)
                    self._logger.debug("create folder '%s'" % basepath)
            return folder

    @wrap_cmis_error
    def create_doc(
        self, file_name, file_path, file_byte_content, content_type=None, object_type=None, properties=None
    ):
        folder = self._get_or_create_folder(file_path)
        properties = properties or {}
        if object_type:
            properties['cmis:objectTypeId'] = object_type
        return folder.createDocument(
            file_name, contentFile=BytesIO(file_byte_content), contentType=content_type, properties=properties
        )