OP#2803 : fix - Changing a folder type only a user preferences

Author: tkeriven

app/config/settings/UserSettings.py

@@ -281,6 +281,7 @@ def get_all_user_settings_schema() -> list[Type[SogoSchema]]:
                    UserContactCategorySettings,
                    UserMailGeneralSettings,
                    UserMailCategorySettings,
+                   UserMailViewSettings,
                    UserExtraSettings]
     return all_schemas
 

app/interface/mail/InterfaceApiMailFolder.py

@@ -4,6 +4,7 @@
 
 from app.auth.User import User
 from app.module.mail.ModuleMail import ModuleMail
+from app.module.user.ModuleUserProfile import ModuleUserProfile
 from app.module.auth.ModuleUserSource import ModuleUserSource
 from app.config.settings.DomainSettings import MailSettings, MailSettingsObj
 from app.utils.exceptions import RequestException
@@ -29,6 +30,7 @@ def __init__(self, process_setting: ProcessSetting, user_domain_settings: dict,
         self.user = user
 
         self.mail_module = ModuleMail(self.user, self.mail_settings)
+        self.user_module = ModuleUserProfile(process_setting, user_domain_settings)
 
     def get_folder_list(self, account_id: str) -> tuple[dict[str, Any], int]:
         """Retrieve the list of mail folders for a given account and return an ApiBaseResponse.
@@ -160,7 +162,7 @@ def change_folder_type(self, account_id: str, folder_path: str, new_type: str) -
         :rtype: tuple[dict[str, Any], int]
         """
         try:
-            updated_folder = self.mail_module.change_folder_type(account_id, folder_path, new_type)
+            updated_folder = self.user_module.change_folder_type(self.user, self.mail_settings, folder_path, new_type)
             return create_api_base_response(updated_folder)
         except RequestException as ex:
             logger_api.error("Request exception in change_folder_type: %s", str(ex))

app/module/user/ModuleUserProfile.py

@@ -4,7 +4,7 @@
 from marshmallow import EXCLUDE, ValidationError
 
 from app.config.db import tables as tbl
-from app.config.settings.UserSettings import get_all_user_settings_schema, user_settings_dict
+from app.config.settings.UserSettings import get_all_user_settings_schema, user_settings_dict, UserMailViewSettings, UserMailViewSettingsObj
 from app.config.settings.SogoSchema import check_data_for_sogo_schemas
 from app.config.settings.DomainSettings import UserModuleSettingsObj, UserModuleSettings
 from app.utils import constants as cs
@@ -19,6 +19,7 @@
 
 if TYPE_CHECKING:
     from app.config.settings.ProcessSetting import ProcessSetting
+    from app.config.settings.DomainSettings import MailSettingsObj
     from app.manager.db.ClientSQL import ClientSQL
     from app.auth.User import User
 
@@ -642,6 +643,77 @@ def update_user_preferences(self, uid:str, new_data:dict, subparent:str|None = N
             return new_data[real_subparent]
         return new_data
 
+    #Map a folder "type" to the domain setting (fixed by admin) and user setting (override by user)
+    #that hold the actual name of the corresponding special folder.
+    _SPECIAL_FOLDER_SETTINGS_MAP: dict[str, tuple[str, str]] = {
+        cs.MAIL_FOLDER_SENT: ("SOGO_D_MAIL_SENT", "SOGO_U_SENT_FOLDER_NAME"),
+        cs.MAIL_FOLDER_DRAFT: ("SOGO_D_MAIL_DRAFT", "SOGO_U_DRAFT_FOLDER_NAME"),
+        cs.MAIL_FOLDER_JUNK: ("SOGO_D_MAIL_JUNK", "SOGO_U_JUNK_FOLDER_NAME"),
+        cs.MAIL_FOLDER_TRASH: ("SOGO_D_MAIL_TRASH", "SOGO_U_TRASH_FOLDER_NAME"),
+        cs.MAIL_FOLDER_TEMPLATE: ("SOGO_D_MAIL_TEMPLATE", "SOGO_U_TEMPLATE_FOLDER_NAME"),
+    }
+
+    def change_folder_type(self, user: User, mail_settings: MailSettingsObj, folder_path: str, new_type: str) -> dict[str, Any]:
+        """Change the type of a mail folder.
+
+        Assigns the folder ``folder_path`` as the special folder for the given type (SENT, DRAFT, etc).
+        This updates the user's preference to associate that folder name with the special type.
+
+        :param user: The current user
+        :type user: User
+        :param mail_settings: The domain mail settings (holds admin-fixed folder names)
+        :type mail_settings: MailSettingsObj
+        :param folder_path: The path/name of the folder to assign as the special folder
+        :type folder_path: str
+        :param new_type: The new type for the folder (SENT, DRAFT, JUNK, TRASH, TEMPLATE)
+        :type new_type: str
+        :return: The updated folder data
+        :rtype: dict[str, Any]
+        :raises RequestException: If the type is invalid or the folder is already assigned to another special type
+        """
+        new_type_upper = new_type.upper()
+        setting_names = self._SPECIAL_FOLDER_SETTINGS_MAP.get(new_type_upper)
+        if setting_names is None:
+            logger_user_profile.error("Invalid folder type requested in change_folder_type: %s", new_type)
+            raise RequestException(err.ERROR_FOLDER_TYPE_INVALID.m, err.ERROR_FOLDER_TYPE_INVALID)
+        _, user_setting_name = setting_names
+
+        # Get the current user mail view settings
+        user_mail_view_prefs: dict = user.profile.preferences.get(UserMailViewSettings.subparent, {})
+        # Create a UserMailViewSettingsObj to access the current special folder names
+        user_mail_view_settings = UserMailViewSettingsObj(user_mail_view_prefs)
+
+        # Check that this folder is not already assigned to another special type
+        for other_type, (other_domain_setting, other_user_setting) in self._SPECIAL_FOLDER_SETTINGS_MAP.items():
+            if other_type == new_type_upper:
+                continue  # Skip the type we're trying to assign
+
+            # Get the current name for this other type, either from user settings or domain settings
+            other_current_name = getattr(user_mail_view_settings, other_user_setting) or getattr(mail_settings, other_domain_setting)
+
+            # If folder_path is already assigned to another special type, reject it
+            if folder_path == other_current_name:
+                logger_user_profile.error(
+                    "Folder '%s' is already assigned as '%s' type, cannot assign it to '%s'",
+                    folder_path, other_type, new_type_upper
+                )
+                raise RequestException(err.ERROR_FOLDER_TYPE_CANNOT_CHANGE.m, err.ERROR_FOLDER_TYPE_CANNOT_CHANGE)
+
+        # Update user preference to assign this folder as the special type
+        self.update_user_preferences(
+            user.uid,
+            {user_setting_name: folder_path},
+            subparent=UserMailViewSettings.subparent.lower()
+        )
+
+        logger_user_profile.info("Changed folder '%s' type to '%s' for uid: %s", folder_path, new_type_upper, user.uid)
+
+        return {
+            "name": folder_path,
+            "path": folder_path,
+            "type": new_type_upper,
+        }
+
     def get_delegations_given(self, user: User) -> list[str]:
         """
         Get all delegations given by the user

tests/test_interface/test_mail/test_InterfaceApiMailFolder.py

@@ -51,17 +51,19 @@ def __init__(self, login_mail_server="test@example.com"):
 
 class InterfaceApiMailFolderWithInjectedConf(InterfaceApiMailFolder):
     """Subclass of InterfaceApiMailFolder that allows injecting user configuration directly for testing."""
-    def __init__(self, user_conf, mail_module=None):
+    def __init__(self, user_conf, mail_module=None, user_module=None):
         """Initialize with injected user configuration for testing.
         
         Does not call the parent __init__ to avoid requiring process_setting,
-        user_domain_settings and user. Sets mail_module directly if provided.
+        user_domain_settings and user. Sets mail_module and user_module directly if provided.
         """
         # Does not call the parent __init__ to avoid requiring all the parameters it needs
         self._user_conf = user_conf  # noqa: SLF001
         self.mail_module = mail_module
+        self.user_module = user_module
         self.user = FakeUser()
         self.user_domain_settings = {}
+        self.mail_settings = {}  # Empty dict for testing
 
 
 class FakeModuleMail:
@@ -167,15 +169,31 @@ def change_folder_type(self, account_id, folder_path, new_type):
         return self.change_folder_type_result
 
 
-def make_interface(monkeypatch, fake_module, user_conf=None):
+class FakeModuleUserProfile:
+    """Fake ModuleUserProfile for testing InterfaceApiMailFolder.
+    
+    Provides a mock implementation of change_folder_type.
+    """
+    def __init__(self):
+        self.change_folder_type_args = None
+        self.change_folder_type_result = {"name": "Folder", "path": "Folder", "type": "SENT"}
+    
+    def change_folder_type(self, user, mail_settings, folder_path, new_type):
+        """Simulate changing folder type."""
+        self.change_folder_type_args = (folder_path, new_type)
+        return self.change_folder_type_result
+
+def make_interface(monkeypatch, fake_module, user_conf=None, fake_user_module=None):
     """Create an InterfaceApiMailFolderWithInjectedConf with the fake module injected."""
     if user_conf is None:
         user_conf = {"username": "test@example.com", "password": "pass", "type": "imap"}
+    if fake_user_module is None:
+        fake_user_module = FakeModuleUserProfile()
     monkeypatch.setattr(
         "app.interface.mail.InterfaceApiMailFolder.ModuleMail",
         lambda *args, **kwargs: fake_module
     )
-    return InterfaceApiMailFolderWithInjectedConf(user_conf, mail_module=fake_module)
+    return InterfaceApiMailFolderWithInjectedConf(user_conf, mail_module=fake_module, user_module=fake_user_module)
 
 
 def patch_module_on_interface(monkeypatch, fake_module):
@@ -519,22 +537,24 @@ def test_rename_folder_module_error(monkeypatch):
 
 def test_change_folder_type_success(monkeypatch):
     """Test changing folder type for a valid account."""
+    fake_user_module = FakeModuleUserProfile()
+    fake_user_module.change_folder_type_result = {"name": "Archive", "type": "JUNK"}
     fake_module = FakeModuleMail()
-    fake_module.change_folder_type_result = {"name": "Archive", "type": "JUNK"}
-    interface = make_interface(monkeypatch, fake_module)
+    interface = make_interface(monkeypatch, fake_module, fake_user_module=fake_user_module)
 
     result, status_code = interface.change_folder_type(account_id=0, folder_path="Archive", new_type="JUNK")
 
     assert status_code == 200
     assert result["data"]["type"] == "JUNK"
-    assert fake_module.change_folder_type_args == ("Archive", "JUNK")
+    assert fake_user_module.change_folder_type_args == ("Archive", "JUNK")
 
 
 def test_change_folder_type_module_error(monkeypatch):
     """Test error handling when folder type change fails."""
+    fake_user_module = FakeModuleUserProfile()
+    fake_user_module.change_folder_type = lambda *args, **kwargs: (_ for _ in ()).throw(RequestException("Cannot change type", err.ERROR_VALIDATION_ERROR))
     fake_module = FakeModuleMail()
-    fake_module.change_folder_type = lambda *args: (_ for _ in ()).throw(RequestException("Cannot change type", err.ERROR_VALIDATION_ERROR))
-    interface = make_interface(monkeypatch, fake_module)
+    interface = make_interface(monkeypatch, fake_module, fake_user_module=fake_user_module)
 
     result, status_code = interface.change_folder_type(account_id=0, folder_path="INBOX", new_type="JUNK")