[MIG] Migration to 16.0 : field cmis_document

cmis_field/controllers/main.py

@@ -1,5 +1,8 @@
 # Copyright 2016 ACSONE SA/NV (<http://acsone.eu>)
 # License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html)
+import base64
+from io import BytesIO
+
 from odoo import http
 
 
@@ -12,3 +15,32 @@ def create_field_value(self, model_name, res_id, field_name):
         model_inst._fields[field_name].create_value(model_inst)
         value = getattr(model_inst, field_name)
         return {"value": value}
+
+    @http.route('/web/cmis/field/create_document_value', type='json', methods=['POST'],
+                auth="user")
+    def create_document_field_value(self, model_name, res_id, field_name, documents):
+        if documents:
+            self._decode_files(documents)
+            model_inst = http.request.env[model_name].browse(int(res_id))
+            model_inst._fields[field_name].create_value(model_inst, {res_id: documents[0]})
+            value = getattr(model_inst, field_name)
+            return {'value': value}
+        return {'value': None}
+
+    @http.route(
+    '/web/cmis/field/cmis_document/get_document_parent',
+        type='json',
+        methods=['POST'],
+        auth="user"
+    )
+    def get_document_parent(self, model_name, res_id, backend_id, field_name):
+        env = http.request.env
+        record = env[model_name].browse(int(res_id))
+        backend = env["cmis.backend"].browse(int(backend_id))
+        return record._fields[field_name].get_create_parents(record, backend)[record.id]
+
+    def _decode_files(self, documents):
+        for doc in documents:
+            file_ = doc.get("data")
+            _, content = file_.split(",")
+            doc["data"] = BytesIO(base64.b64decode(content))

cmis_field/fields/__init__.py

@@ -1 +1,2 @@
+from .cmis_document import CmisDocument
 from .cmis_folder import CmisFolder

cmis_field/fields/cmis_document.py

@@ -0,0 +1,202 @@
+# Copyright 2020 ACSONE SA/NV (<http://acsone.eu>)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+
+import threading
+import time
+from functools import partial
+from odoo import api, fields, registry, SUPERUSER_ID, _
+from odoo.exceptions import UserError
+from odoo.tools.sql import pg_varchar
+from cmislib.exceptions import ObjectNotFoundException
+
+
+class CmisDocument(fields.Field):
+    type = "cmis_document"
+    column_type = ("varchar", pg_varchar())
+    backend_name = None
+    create_method = None
+    create_parent_get = None
+    create_properties_get = None
+    copy = False  # noderef are not copied by default
+
+    def __init__(self, **kwargs):
+        self.backend_name = kwargs.get("backend_name")
+        super().__init__(**kwargs)
+
+    def _is_registry_loading_mode(self, env):
+        """
+        Check if we are in the installation process.
+        """
+        return env.context.get("install_mode")
+
+    def get_backend(self, env, raise_if_not_found=True):
+        return env['cmis.backend'].get_by_name(
+            self.backend_name, raise_if_not_found)
+
+    def _description_backend(self, env):
+        if self.inherited:
+            # In the case of a cmis field inherited from another module
+            # the attribute backend_name is not inherited so we have to
+            # get it on the original fiel
+            backend = self.inherited_field.get_backend(env, raise_if_not_found=False)
+        else:
+            backend = self.get_backend(env, raise_if_not_found=False)
+        if len(backend) > 1:
+            if self._is_registry_loading_mode(env):
+                # While the registry is loading, specific attributes are not available
+                # on the field (such as `backend_name`). At this stage, the fields
+                # are accessed to validate the xml views of the module being
+                # loaded/updated. We can therefore safely takes the first backend
+                # into the list.
+                backend = backend[:1]
+            else:
+                msg = (_('Too many backend found. '
+                         'Please check your configuration.'))
+                return {'backend_error': msg}
+        if not backend:
+            if self.backend_name:
+                msg = (_('Backend named %s not found. '
+                         'Please check your configuration.') %
+                       self.backend_name)
+            else:
+                msg = _('No backend found. Please check your configuration.')
+            return {'backend_error': msg}
+        result = backend.get_web_description()[backend.id]
+        return result
+
+    def get_cmis_object(self, record):
+        """Returns an instance of
+        :class:`cmislib.browser.binding.BrowserDocument`
+        This instance is a proxy object that can be used to perform action on
+        the document into the cmis container
+        :param record:
+        """
+        val = self.__get__(record, record)
+        if not val:
+            return None
+        backend = self.get_backend(record.env)
+        repo = backend.get_cmis_repository()
+        return repo.getObject(val)
+
+    def create_value(self, records, documents):
+        """Create a new document for each record into the cmis container and
+        store the value as field value
+
+        :param records: An odoo recordset
+        :param documents: A mapping of files to their corresponding record as a dict of
+        dicts. The key of the parent dict should be the id of the corresponding record,
+        while each child dict should contain a 'name' key for the name of the file,
+        a 'mimetype' key for its mimetype and a 'data' key for its content (bytes).
+        :type documents: dict[:int, dict['name': str, 'mimetype': str, 'file': bytes]]
+
+        """
+        for record in records:
+            self._check_null(record)
+        self._create_value(records, documents)
+
+    def _create_value(self, records, documents):
+        backend = self.get_backend(records.env)
+        if self.create_method:
+            fct = self.create_method
+            if not callable(fct):
+                fct = getattr(records, fct)
+            fct(self, backend)
+            return
+        self._create_in_cmis(records, backend, documents)
+
+    def _create_in_cmis(self, records, backend, documents):
+        parents = self.get_create_parents(records, backend)
+        properties = self.get_create_properties(records, backend)
+        for record in records:
+            document = documents[record.id]
+            name = document.get("name")
+            backend.is_valid_cmis_name(name, raise_if_invalid=True)
+            parent = parents[record.id]
+            props = properties[record.id] or {}
+            object_id = parent.createDocument(
+                name,
+                properties=props,
+                contentFile=document.get("data"),
+                contentType=document.get("mimetype"),
+            )
+
+            def clean_up_document(cmis_object_id, backend_id, dbname):
+                db_registry = registry(dbname)
+                with api.Environment.manage(), db_registry.cursor() as cr:
+                    env = api.Environment(cr, SUPERUSER_ID, {})
+                    backend = env["cmis.backend"].browse(backend_id)
+                    _repo = backend.get_cmis_repository()
+                    # The rollback is delayed by an arbitrary length of time to give
+                    # the GED time to create the folder. If the folder is not properly
+                    # created at the time the rollback executes, it cannot be deleted.
+                    time.sleep(0.5)
+                    try:
+                        _repo.getObject(cmis_object_id).delete()
+                    except ObjectNotFoundException:
+                        pass
+
+            # remove created resource in case of rollback
+            test_mode = getattr(threading.current_thread(), 'testing', False)
+            if not test_mode:
+                record.env.cr.postrollback.add(
+                    partial(
+                        clean_up_document,
+                        object_id,
+                        backend.id,
+                        record.env.cr.dbname
+                    )
+                )
+
+            self.__set__(record, object_id)
+
+    def get_create_parents(self, records, backend):
+        """return the cmis:objectId of the cmis folder to use as parent of the
+        new folder.
+        :rtype: dict
+        :return: a dictionay with an entry for each record with the following
+        structure ::
+
+            {record.id: 'cmis:objectId'}
+
+        """
+        if self.create_parent_get:
+            fct = self.create_parent_get
+            if not callable(fct):
+                fct = getattr(records, fct)
+            return fct(self, backend)
+        path_parts = self.get_default_parent_path_parts(records, backend)
+        parent_cmis_object = backend.get_folder_by_path_parts(
+            path_parts, create_if_not_found=True)
+        return dict.fromkeys(records.ids, parent_cmis_object)
+
+    def get_default_parent_path_parts(self, records, backend):
+        """Return the default path parts into the cmis container to use as
+        parent on folder create. By default:
+        backend.initial_directory_write / record._name
+        """
+        path_parts = backend.initial_directory_write.split('/')
+        path_parts.append(records[0]._name.replace('.', '_'))
+        return path_parts
+
+    def get_create_properties(self, records, backend):
+        """Return the properties to use to created the folder into the CMIS
+        container.
+        :rtype: dict
+        :return: a dictionay with an entry for each record with the following
+        structure ::
+
+            {record.id: {'cmis:xxx': 'val1', ...}}
+
+        """
+        if self.create_properties_get:
+            fct = self.create_properties_get
+            if not callable(fct):
+                fct = getattr(records, fct)
+            return fct(self, backend)
+        return dict.fromkeys(records.ids, None)
+
+    def _check_null(self, record, raise_exception=True):
+        val = self.__get__(record, record)
+        if val and raise_exception:
+            raise UserError(_('A value is already assigned to %s') % self)
+        return val

cmis_field/models/ir_model_fields.py

@@ -9,6 +9,6 @@ class IrModelFields(models.Model):
     _inherit = "ir.model.fields"
 
     ttype = fields.Selection(
-        selection_add=[("cmis_folder", "CMIS Folder")],
-        ondelete={"cmis_folder": "cascade"},
+        selection_add=[('cmis_folder', 'CMIS Folder'), ('cmis_document', 'CMIS Document')],
+        ondelete = {"cmis_folder": "cascade", "cmis_document": "cascade"},
     )

cmis_web/CHANGES.rst

@@ -3,5 +3,5 @@ Changelog
 
 .. Future (?)
 .. ~~~~~~~~~~
-.. 
+..
 .. *

cmis_web/__init__.py

@@ -1,2 +1 @@
-# Copyright 2016-2023 ACSONE SA/NV (<http://acsone.eu>)
-# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from . import mixins

cmis_web/__manifest__.py

@@ -18,6 +18,9 @@
         "web.assets_backend": [
             "/cmis_web/static/lib/cmisjs/superagent.7.2.0.js",
             "/cmis_web/static/lib/cmisjs/cmis.0.3.1.js",
+            "/cmis_web/static/src/cmis_document/*",
+            "/cmis_web/static/src/cmis_document_link_existing/*",
+            "/cmis_web/static/src/cmis_document_search/*",
             "/cmis_web/static/src/cmis_folder/cmis_folder.js",
             "/cmis_web/static/src/cmis_folder/cmis_folder.scss",
             "/cmis_web/static/src/cmis_folder/cmis_folder.xml",
@@ -40,6 +43,7 @@
             "/cmis_web/static/src/cmis_attachment_viewer/cmis_attachment_viewer.js",
             "/cmis_web/static/src/cmis_attachment_viewer/cmis_attachment_viewer.xml",
             "/cmis_web/static/src/cmis_object_wrapper_service.js",
+            "/cmis_web/static/src/cmis_utils.js",
         ]
     },
 }