odoo-addon-dms 16.0.1.8.0.5__py3-none-any.whl → 17.0.1.0.0.3__py3-none-any.whl

odoo/addons/dms/tests/test_storage_attachment.py

@@ -1,5 +1,6 @@
 # Copyright 2021-2022 Tecnativa - Víctor Martínez
 # Copyright 2021 Tecnativa - João Marques
+# Copyright 2024 Subteno - Timothée Vannier (https://www.subteno.com).
 # License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
 
 from odoo.tests.common import users
@@ -14,20 +15,25 @@ class StorageAttachmentTestCase(StorageAttachmentBaseCase):
     def test_storage_attachment(self):
         self._create_attachment("demo.txt")
         self.assertTrue(
-            self.storage.storage_file_ids.filtered(lambda x: x.name == "demo.txt")
+            self.storage.storage_file_ids.filtered(lambda x: x.name == "demo.txt"),
+            "File should be created",
         )
         directory = self._get_partner_directory()
-        self.assertEqual(directory.count_files, 1)
-        self.assertEqual(directory.file_ids[0].name, "demo.txt")
+        self.assertEqual(directory.count_files, 1, "Directory should have 1 file")
+        self.assertEqual(
+            directory.file_ids[0].name, "demo.txt", "File should be demo.txt"
+        )
         file_01 = self.create_file(directory=directory)
-        self.assertEqual(file_01.storage_id, self.storage)
-        self.assertEqual(file_01.storage_id.save_type, "attachment")
-        self.assertEqual(file_01.save_type, "database")
-        self.assertEqual(directory.count_files, 2)
+        self.assertEqual(file_01.storage_id, self.storage, "Storage should be the same")
+        self.assertEqual(
+            file_01.storage_id.save_type, "attachment", "Save type should be attachment"
+        )
+        self.assertEqual(file_01.save_type, "database", "Save type should be database")
+        self.assertEqual(directory.count_files, 2, "Directory should have 2 files")
         # Assert cascade removal
         self.partner.unlink()
-        self.assertFalse(file_01.exists())
-        self.assertFalse(directory.exists())
+        self.assertFalse(file_01.exists(), "File should not exist")
+        self.assertFalse(directory.exists(), "Directory should not exist")
 
     @users("dms-manager")
     def test_storage_attachment_misc(self):
@@ -35,81 +41,97 @@ class StorageAttachmentTestCase(StorageAttachmentBaseCase):
         root_directory = self.storage.root_directory_ids.filtered(
             lambda x: x.is_root_directory
         )
-        self.assertEqual(root_directory.count_directories, 1)
-        self.assertEqual(len(root_directory.child_directory_ids), 1)
+        self.assertEqual(
+            root_directory.count_directories,
+            1,
+            "Root directory should have 1 directory",
+        )
+        self.assertEqual(
+            len(root_directory.child_directory_ids),
+            1,
+            "Root directory should have 1 child directory",
+        )
         child_directory = root_directory.child_directory_ids[0]
-        self.assertEqual(child_directory.res_model, self.partner_model._name)
-        self.assertEqual(child_directory.res_id, self.partner.id)
-        self.assertEqual(len(root_directory.child_directory_ids.file_ids), 1)
+        self.assertEqual(
+            child_directory.res_model,
+            self.partner_model._name,
+            "Model should be res.partner",
+        )
+        self.assertEqual(
+            child_directory.res_id, self.partner.id, "Record ID should be partner ID"
+        )
+        self.assertEqual(
+            len(root_directory.child_directory_ids.file_ids),
+            1,
+            "Root directory should have 1 file",
+        )
         dms_file = root_directory.child_directory_ids.file_ids[0]
-        self.assertEqual(dms_file.attachment_id, attachment)
-        self.assertEqual(dms_file.name, "demo.txt")
-        self.assertEqual(dms_file.res_model, self.partner_model._name)
-        self.assertEqual(dms_file.res_id, self.partner.id)
+        self.assertEqual(
+            dms_file.attachment_id, attachment, "Attachment should be the same"
+        )
+        self.assertEqual(dms_file.name, "demo.txt", "Name should be demo.txt")
+        self.assertEqual(
+            dms_file.res_model, self.partner_model._name, "Model should be res.partner"
+        )
+        self.assertEqual(
+            dms_file.res_id, self.partner.id, "Record ID should be partner ID"
+        )
         directory = self._get_partner_directory()
         file_01 = self.create_file(directory=directory)
-        self.assertEqual(file_01.res_model, self.partner_model._name)
-        self.assertEqual(file_01.res_id, self.partner.id)
-        self.assertEqual(file_01.storage_id, self.storage)
-        self.assertEqual(file_01.storage_id.save_type, "attachment")
-        self.assertEqual(file_01.save_type, "database")
-        self.assertEqual(self.storage.count_storage_files, 2)
+        self.assertEqual(
+            file_01.res_model, self.partner_model._name, "Model should be res.partner"
+        )
+        self.assertEqual(
+            file_01.res_id, self.partner.id, "Record ID should be partner ID"
+        )
+        self.assertEqual(file_01.storage_id, self.storage, "Storage should be the same")
+        self.assertEqual(
+            file_01.storage_id.save_type, "attachment", "Save type should be attachment"
+        )
+        self.assertEqual(file_01.save_type, "database", "Save type should be database")
+        self.assertEqual(
+            self.storage.count_storage_files, 2, "Storage should have 2 files"
+        )
 
     @users("dms-manager")
     def test_storage_attachment_directory_record_ref_access_dms_manager(self):
         self._create_attachment("demo.txt")
         directory = self._get_partner_directory()
-        self.assertTrue(directory.permission_read)
-        self.assertEqual(self.partner.type, "contact")
-        self.partner.sudo().write({"type": "private"})
-        self.assertEqual(self.partner.type, "private")
-        self.assertTrue(directory.sudo().permission_read)
-        directory.invalidate_recordset()
-        self.assertFalse(directory.with_user(self.dms_manager_user).permission_read)
+        self.assertTrue(directory.permission_read, "Permission read should be True")
+        self.assertEqual(self.partner.type, "contact", "Type should be contact")
+        self.assertTrue(
+            directory.sudo().permission_read, "Permission read should be True"
+        )
 
     @users("dms-user")
     def test_storage_attachment_directory_record_ref_access_dms_user(self):
         self._create_attachment("demo.txt")
         directory = self._get_partner_directory()
-        self.assertTrue(directory.permission_read)
-        self.assertEqual(self.partner.type, "contact")
-        self.partner.sudo().write({"type": "private"})
-        self.assertEqual(self.partner.type, "private")
-        self.assertTrue(directory.sudo().permission_read)
+        self.assertTrue(directory.permission_read, "Permission read should be True")
+        self.assertEqual(self.partner.type, "contact", "Type should be contact")
+        self.assertTrue(
+            directory.sudo().permission_read, "Permission read should be True"
+        )
         directory.invalidate_recordset()
-        self.assertFalse(directory.with_user(self.dms_user).permission_read)
-        # user can access self.partner
-        self.dms_user.write(
-            {
-                "groups_id": [
-                    (
-                        6,
-                        0,
-                        [
-                            self.browse_ref("base.group_private_addresses").id,
-                            self.browse_ref("base.group_user").id,
-                        ],
-                    )
-                ]
-            }
-        )
-        self.assertTrue(directory.permission_read)
+        self.assertTrue(
+            directory.permission_read, "Permission read should still be True"
+        )
 
     @users("basic-user")
     def test_storage_attachment_directory_record_ref_access_basic_user(self):
         self._create_attachment("demo.txt")
         directory = self._get_partner_directory()
-        self.assertTrue(directory.permission_read)
-        self.assertTrue(directory.permission_read)
-        self.assertEqual(self.partner.type, "contact")
-        self.partner.sudo().write({"type": "private"})
-        self.assertEqual(self.partner.type, "private")
-        self.assertTrue(directory.sudo().permission_read)
-        directory.invalidate_recordset()
-        self.assertFalse(directory.with_user(self.user).permission_read)
+        self.assertTrue(directory.permission_read, "Permission read should be True")
+        self.assertTrue(directory.permission_read, "Permission read should be True")
+        self.assertEqual(self.partner.type, "contact", "Type should be contact")
+        self.partner.sudo().write({"type": "other"})
+        self.assertEqual(self.partner.type, "other", "Type should now be other")
+        self.assertTrue(
+            directory.sudo().permission_read, "Permission read should be True"
+        )
 
     @users("basic-user")
     def test_create_attachment_basic_user(self):
         attachment = self._create_attachment("Test file")
-        self.assertEqual(attachment.name, "Test file")
-        self.assertTrue(self._get_partner_directory())
+        self.assertEqual(attachment.name, "Test file", "Name should be Test file")
+        self.assertTrue(self._get_partner_directory(), "Directory should exist")

odoo/addons/dms/tests/test_storage_database.py

@@ -16,11 +16,13 @@ class StorageDatabaseTestCase(StorageDatabaseBaseCase):
 
     @users("dms-manager", "dms-user")
     def test_count_storage_directories(self):
-        self.assertTrue(self.storage.count_storage_directories)
+        self.assertTrue(
+            self.storage.count_storage_directories, "Storage should have directories"
+        )
 
     @users("dms-manager", "dms-user")
     def test_count_storage_files(self):
-        self.assertTrue(self.storage.count_storage_files)
+        self.assertTrue(self.storage.count_storage_files, "Storage should have files")
 
     @users("dms-manager")
     @mute_logger("odoo.models.unlink")
@@ -29,33 +31,61 @@ class StorageDatabaseTestCase(StorageDatabaseBaseCase):
             lambda x: x.is_root_directory
         )
         file_01 = self.create_file(directory=root_directory)
-        self.assertEqual(file_01.storage_id, self.storage)
-        self.assertEqual(file_01.storage_id.save_type, "database")
-        self.assertEqual(file_01.save_type, "database")
+        self.assertEqual(
+            file_01.storage_id, self.storage, "File should be in the storage"
+        )
+        self.assertEqual(
+            file_01.storage_id.save_type, "database", "Storage should be database"
+        )
+        self.assertEqual(
+            file_01.save_type, "database", "File savetype should be database"
+        )
         self.storage.write({"save_type": "file"})
         directory = self.create_directory(storage=self.storage)
         file_02 = self.create_file(directory=directory)
-        self.assertEqual(file_01.storage_id, self.storage)
-        self.assertEqual(file_01.storage_id.save_type, "file")
-        self.assertEqual(file_01.save_type, "database")
-        self.assertEqual(file_02.storage_id, self.storage)
-        self.assertEqual(file_02.storage_id.save_type, "file")
-        self.assertEqual(file_02.save_type, "file")
+        self.assertEqual(
+            file_01.storage_id, self.storage, "File should be in the storage"
+        )
+        self.assertEqual(file_01.storage_id.save_type, "file", "Storage should be file")
+        self.assertEqual(
+            file_01.save_type, "database", "File savetype should be database"
+        )
+        self.assertEqual(
+            file_02.storage_id, self.storage, "File should be in the storage"
+        )
+        self.assertEqual(file_02.storage_id.save_type, "file", "Storage should be file")
+        self.assertEqual(file_02.save_type, "file", "File savetype should be file")
         self.storage.action_storage_migrate()
-        self.assertEqual(file_01.storage_id, self.storage)
-        self.assertEqual(file_01.storage_id.save_type, "file")
-        self.assertEqual(file_01.save_type, "file")
-        self.assertEqual(file_02.storage_id, self.storage)
-        self.assertEqual(file_02.storage_id.save_type, "file")
-        self.assertEqual(file_02.save_type, "file")
+        self.assertEqual(
+            file_01.storage_id, self.storage, "File should be in the storage"
+        )
+        self.assertEqual(file_01.storage_id.save_type, "file", "Storage should be file")
+        self.assertEqual(file_01.save_type, "file", "File savetype should be file")
+        self.assertEqual(
+            file_02.storage_id, self.storage, "File should be in the storage"
+        )
+        self.assertEqual(file_02.storage_id.save_type, "file", "Storage should be file")
+        self.assertEqual(file_02.save_type, "file", "File savetype should be file")
         self.storage.write({"save_type": "database"})
         self.storage.action_storage_migrate()
-        self.assertEqual(file_01.storage_id, self.storage)
-        self.assertEqual(file_01.storage_id.save_type, "database")
-        self.assertEqual(file_01.save_type, "database")
-        self.assertEqual(file_02.storage_id, self.storage)
-        self.assertEqual(file_02.storage_id.save_type, "database")
-        self.assertEqual(file_02.save_type, "database")
+        self.assertEqual(
+            file_01.storage_id, self.storage, "File should be in the storage"
+        )
+        self.assertEqual(
+            file_01.storage_id.save_type, "database", "Storage should be database"
+        )
+        self.assertEqual(
+            file_01.save_type, "database", "File savetype should be database"
+        )
+        self.assertEqual(
+            file_02.storage_id, self.storage, "File should be in the storage"
+        )
+        self.assertEqual(
+            file_02.storage_id.save_type, "database", "Storage should be database"
+        )
+        self.assertEqual(
+            file_02.save_type, "database", "File savetype should be database"
+        )
         self.storage.write({"save_type": "attachment"})
         model_partner = self.env.ref("base.model_res_partner")
         partner = self.partner_model.create({"name": "Test partner"})
@@ -69,16 +99,40 @@ class StorageDatabaseTestCase(StorageDatabaseBaseCase):
             }
         )
         file_03 = self.create_file(directory=directory)
-        self.assertEqual(file_02.storage_id, self.storage)
-        self.assertEqual(file_02.storage_id.save_type, "attachment")
-        self.assertEqual(file_02.save_type, "database")
-        self.assertEqual(file_03.storage_id, self.storage)
-        self.assertEqual(file_03.storage_id.save_type, "attachment")
-        self.assertEqual(file_03.save_type, "database")
+        self.assertEqual(
+            file_02.storage_id, self.storage, "File should be in the storage"
+        )
+        self.assertEqual(
+            file_02.storage_id.save_type, "attachment", "Storage should be attachment"
+        )
+        self.assertEqual(
+            file_02.save_type, "database", "File savetype should be database"
+        )
+        self.assertEqual(
+            file_03.storage_id, self.storage, "File should be in the storage"
+        )
+        self.assertEqual(
+            file_03.storage_id.save_type, "attachment", "Storage should be attachment"
+        )
+        self.assertEqual(
+            file_03.save_type, "database", "File savetype should be database"
+        )
         self.storage.action_storage_migrate()
-        self.assertEqual(file_02.storage_id, self.storage)
-        self.assertEqual(file_02.storage_id.save_type, "attachment")
-        self.assertEqual(file_02.save_type, "database")
-        self.assertEqual(file_03.storage_id, self.storage)
-        self.assertEqual(file_03.storage_id.save_type, "attachment")
-        self.assertEqual(file_03.save_type, "database")
+        self.assertEqual(
+            file_02.storage_id, self.storage, "File should be in the storage"
+        )
+        self.assertEqual(
+            file_02.storage_id.save_type, "attachment", "Storage should be attachment"
+        )
+        self.assertEqual(
+            file_02.save_type, "database", "File savetype should be database"
+        )
+        self.assertEqual(
+            file_03.storage_id, self.storage, "File should be in the storage"
+        )
+        self.assertEqual(
+            file_03.storage_id.save_type, "attachment", "Storage should be attachment"
+        )
+        self.assertEqual(
+            file_03.save_type, "database", "File savetype should be database"
+        )

odoo/addons/dms/tools/file.py

@@ -1,9 +1,11 @@
 # Copyright 2020 Antoni Romera
 # Copyright 2017-2019 MuK IT GmbH
+# Copyright 2024 Subteno - Timothée Vannier (https://www.subteno.com).
 # License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
 
 import mimetypes
 import os
+import re
 import shutil
 import tempfile
 
@@ -11,10 +13,17 @@ from odoo.tools.mimetypes import guess_mimetype
 
 
 def check_name(name):
+    """
+    Check if a file name is valid.
+
+    :param str name: The file name to check.
+    :return: True if the file name is valid, False otherwise.
+    :rtype: bool
+    """
     tmp_dir = tempfile.mkdtemp()
     try:
         open(os.path.join(tmp_dir, name), "a").close()
-    except IOError:
+    except OSError:
         return False
     finally:
         shutil.rmtree(tmp_dir)
@@ -22,26 +31,69 @@ def check_name(name):
 
 
 def compute_name(name, suffix, escape_suffix):
+    """
+    Compute a new name by adding a suffix to the original name.
+
+    :param str name: The original name.
+    :param int suffix: The suffix to add.
+    :param bool escape_suffix: If True, the suffix is added in between the name and
+    the file extension.
+    :return: The new name.
+    :rtype: str
+    """
     if escape_suffix:
         name, extension = os.path.splitext(name)
-        return "{}({}){}".format(name, suffix, extension)
-    else:
-        return "{}({})".format(name, suffix)
+        return f"{name}({suffix}){extension}"
+
+    return f"{name}({suffix})"
 
 
 def unique_name(name, names, escape_suffix=False):
+    """
+    Generate a unique name by adding a suffix to the original name.
+
+    :param str name: The original name.
+    :param list names: The list of existing names.
+    :param bool escape_suffix: If True, the suffix is added in between the name and
+    the file extension.
+    :return: The unique name.
+    :rtype: str
+    """
     if name not in names:
         return name
-    else:
-        suffix = 1
-        name = compute_name(name, suffix, escape_suffix)
-        while name in names:
-            suffix += 1
-            name = compute_name(name, suffix, escape_suffix)
-        return name
+
+    # Extract the suffix from the name
+    # e.g: "file(1).txt" -> "1"
+    #      "Directory (1)(2)" -> "2"
+    digits = re.compile(r"\((\d+)\)(\.\w+)?$")
+    match = digits.search(name)
+    suffix = 1
+    if match:
+        suffix = int(match.group(1)) + 1
+        # get the name without the suffix and append the extension
+        name = name[: match.span()[0]] + (match.group(2) or "")
+
+    name = compute_name(name, suffix, escape_suffix)
+    while name in names:
+        # has to check recursively if the new name is unique because the user can
+        # rename the file with suffix n+1
+        # and then duplicate the file n, leading to a new file with suffix n+1 which
+        # is already used.
+        return unique_name(name, names, escape_suffix)
+    return name
 
 
 def guess_extension(filename=None, mimetype=None, binary=None):
+    """
+    Guess the extension of a file.
+
+    :param str filename: The name of the file.
+    :param str mimetype: The mimetype of the file.
+    :param str binary: The binary content of the file.
+
+    :return: The extension of the file.
+    :rtype: str
+    """
     extension = filename and os.path.splitext(filename)[1][1:].strip().lower()
     if not extension and mimetype and mimetype != "application/x-empty":
         extension = mimetypes.guess_extension(mimetype)[1:].strip().lower()

odoo/addons/dms/views/dms_access_groups_views.xml

@@ -2,6 +2,7 @@
 <!--
 
     Copyright 2017-2019 MuK IT GmbH
+    Copyright 2024 Subteno - Timothée Vannier (https://www.subteno.com).
     License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
 
   -->
@@ -90,17 +91,7 @@
                             </field>
                         </page>
                         <page string="Directories">
-                            <field name="directory_ids">
-                                <tree>
-                                    <field name="name" />
-                                    <field
-                                        name="count_directories"
-                                        string="Directories"
-                                    />
-                                    <field name="count_files" string="Files" />
-                                    <field name="size" widget="binary_size" />
-                                </tree>
-                            </field>
+                            <field name="directory_ids" />
                         </page>
                     </notebook>
                 </sheet>
@@ -118,10 +109,4 @@
             (0, 0, {'view_mode': 'form', 'view_id': ref('view_dms_access_groups_form')})]"
         />
     </record>
-    <menuitem
-        id="menu_dms_access_groups"
-        name="Access Groups"
-        parent="dms.cat_menu_dms_config_system"
-        action="action_dms_access_groups"
-    />
 </odoo>

odoo/addons/dms/views/{category.xml → dms_category.xml}

@@ -2,6 +2,7 @@
 <!--
 
     Copyright 2017-2019 MuK IT GmbH
+    Copyright 2024 Subteno - Timothée Vannier (https://www.subteno.com).
     License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
 
   -->
@@ -44,7 +45,7 @@
                         name="web_ribbon"
                         title="Archived"
                         bg_color="bg-danger"
-                        attrs="{'invisible': [('active', '=', True)]}"
+                        invisible="active"
                     />
                     <div class="oe_button_box" name="button_box" />
                     <div class="oe_title">
@@ -76,7 +77,7 @@
                             <field
                                 name="tag_ids"
                                 mode="kanban"
-                                context="{'default_category_id': active_id}"
+                                context="{'default_category_id': id}"
                             />
                         </page>
                         <page string="Subcategories">
@@ -84,7 +85,7 @@
                                 name="child_category_ids"
                                 widget="one2many"
                                 mode="tree"
-                                context="{'default_parent_id': active_id}"
+                                context="{'default_parent_id': id}"
                             />
                         </page>
                     </notebook>
@@ -106,10 +107,4 @@
             </p>
         </field>
     </record>
-    <menuitem
-        id="menu_dms_category"
-        name="Categories"
-        parent="cat_menu_dms_config_organizing"
-        action="action_dms_category"
-    />
 </odoo>