Fix user resource API inconsistencies (#346)

Author: IgorChvyrov-sm

src/conductor/asyncio_client/adapters/api/user_resource_api.py

@@ -1,4 +1,51 @@
+from pydantic import StrictStr
+
 from conductor.asyncio_client.http.api import UserResourceApi
+from conductor.asyncio_client.adapters.models import UpsertUserRequestAdapter as UpsertUserRequest
+
+
+class UserResourceApiAdapter(UserResourceApi):
+    async def get_granted_permissions(
+        self,
+        user_id: StrictStr,
+        *args,
+        **kwargs,
+    ) -> object:
+        # Convert empty user_id to None to prevent sending invalid data to server
+        if not user_id:
+            user_id = None
+        return await super().get_granted_permissions(user_id=user_id, *args, **kwargs)
+
+    async def get_user(
+        self,
+        id: StrictStr,
+        *args,
+        **kwargs,
+    ) -> object:
+        # Convert empty user id to None to prevent sending invalid data to server
+        if not id:
+            id = None
+        return await super().get_user(id=id, *args, **kwargs)
 
+    async def upsert_user(
+        self,
+        id: StrictStr,
+        upsert_user_request: UpsertUserRequest,
+        *args,
+        **kwargs,
+    ) -> object:
+        # Convert empty user id to None to prevent sending invalid data to server
+        if not id:
+            id = None
+        return await super().upsert_user(id=id, upsert_user_request=upsert_user_request, *args, **kwargs)
 
-class UserResourceApiAdapter(UserResourceApi): ...
+    async def delete_user(
+        self,
+        id: StrictStr,
+        *args,
+        **kwargs,
+    ) -> object:
+        # Convert empty user id to None to prevent sending invalid data to server
+        if not id:
+            id = None
+        return await super().delete_user(id=id, *args, **kwargs)

src/conductor/asyncio_client/adapters/models/conductor_user_adapter.py

@@ -2,6 +2,7 @@
 
 from typing import Any, Dict, List, Optional
 
+from pydantic import Field, StrictBool
 from typing_extensions import Self
 
 from conductor.asyncio_client.http.models import ConductorUser
@@ -10,6 +11,9 @@
 class ConductorUserAdapter(ConductorUser):
     groups: Optional[List["GroupAdapter"]] = None
     roles: Optional[List["RoleAdapter"]] = None
+    orkes_app: Optional[StrictBool] = Field(default=None, alias="orkesApp")
+    orkes_api_gateway: Optional[StrictBool] = Field(default=None, alias="orkesApiGateway")
+    contact_information: Optional[Dict[Any, str]] = Field(default=None, alias="contactInformation")
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
@@ -39,12 +43,19 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
                     else None
                 ),
                 "uuid": obj.get("uuid"),
+                "orkesApp": obj.get("orkesApp"),
+                "orkesApiGateway": obj.get("orkesApiGateway"),
+                "contactInformation": obj.get("contactInformation"),
             }
         )
         return _obj
 
 
-from conductor.asyncio_client.adapters.models.group_adapter import GroupAdapter  # noqa: E402
-from conductor.asyncio_client.adapters.models.role_adapter import RoleAdapter  # noqa: E402
+from conductor.asyncio_client.adapters.models.group_adapter import (  # noqa: E402
+    GroupAdapter,
+)
+from conductor.asyncio_client.adapters.models.role_adapter import (  # noqa: E402
+    RoleAdapter,
+)
 
 ConductorUserAdapter.model_rebuild(raise_errors=False)

src/conductor/asyncio_client/orkes/orkes_authorization_client.py

@@ -51,7 +51,6 @@ async def update_user(
     async def get_user(self, user_id: str) -> ConductorUser:
         """Get user by ID"""
         user = await self.user_api.get_user(id=user_id)
-        print(user)
 
         return ConductorUser.from_dict(user)
 

src/conductor/client/adapters/api/user_resource_api_adapter.py

@@ -1,4 +1,27 @@
 from conductor.client.codegen.api.user_resource_api import UserResourceApi
 
 
-class UserResourceApiAdapter(UserResourceApi): ...
+class UserResourceApiAdapter(UserResourceApi):
+    def get_granted_permissions(self, user_id, **kwargs):
+        # Convert empty user_id to None to prevent sending invalid data to server
+        if not user_id:
+            user_id = None
+        return super().get_granted_permissions(user_id=user_id, **kwargs)
+
+    def get_user(self, id, **kwargs):
+        # Convert empty user id to None to prevent sending invalid data to server
+        if not id:
+            id = None
+        return super().get_user(id=id, **kwargs)
+
+    def upsert_user(self, upsert_user_request, id, **kwargs):
+        # Convert empty user id to None to prevent sending invalid data to server
+        if not id:
+            id = None
+        return super().upsert_user(id=id, body=upsert_user_request, **kwargs)
+
+    def delete_user(self, id, **kwargs):
+        # Convert empty user id to None to prevent sending invalid data to server
+        if not id:
+            id = None
+        return super().delete_user(id=id, **kwargs)

src/conductor/client/adapters/models/conductor_user_adapter.py

@@ -1,4 +1,78 @@
 from conductor.client.codegen.models import ConductorUser
 
 
-class ConductorUserAdapter(ConductorUser): ...
+class ConductorUserAdapter(ConductorUser):
+    swagger_types = {
+        **ConductorUser.swagger_types,
+        "orkes_app": "bool",
+        "orkes_api_gateway": "bool",
+        "contact_information": "dict(str, str)",
+    }
+
+    attribute_map = {
+        **ConductorUser.attribute_map,
+        "orkes_app": "orkesApp",
+        "orkes_api_gateway": "orkesApiGateway",
+        "contact_information": "contactInformation",
+    }
+
+    def __init__(
+        self,
+        application_user=None,
+        encrypted_id=None,
+        encrypted_id_display_value=None,
+        groups=None,
+        id=None,
+        name=None,
+        orkes_workers_app=None,
+        roles=None,
+        uuid=None,
+        orkes_app=None,
+        orkes_api_gateway=None,
+        contact_information=None,
+    ):
+        super().__init__(
+            application_user,
+            encrypted_id,
+            encrypted_id_display_value,
+            groups,
+            id,
+            name,
+            orkes_workers_app,
+            roles,
+            uuid,
+        )
+        self._orkes_app = None
+        self._orkes_api_gateway = None
+        self._contact_information = None
+
+        if orkes_app is not None:
+            self.orkes_app = orkes_app
+        if orkes_api_gateway is not None:
+            self.orkes_api_gateway = orkes_api_gateway
+        if contact_information is not None:
+            self.contact_information = contact_information
+
+    @property
+    def orkes_app(self):
+        return self._orkes_app
+
+    @orkes_app.setter
+    def orkes_app(self, orkes_app):
+        self._orkes_app = orkes_app
+
+    @property
+    def orkes_api_gateway(self):
+        return self._orkes_api_gateway
+
+    @orkes_api_gateway.setter
+    def orkes_api_gateway(self, orkes_api_gateway):
+        self._orkes_api_gateway = orkes_api_gateway
+
+    @property
+    def contact_information(self):
+        return self._contact_information
+
+    @contact_information.setter
+    def contact_information(self, contact_information):
+        self._contact_information = contact_information

src/conductor/client/adapters/models/task_result_adapter.py

@@ -1,7 +1,7 @@
 from conductor.client.adapters.models.task_exec_log_adapter import \
     TaskExecLogAdapter
 from conductor.client.codegen.models.task_result import TaskResult
-from conductor.client.http.models.task_result_status import TaskResultStatus
+from conductor.shared.http.enums.task_result_status import TaskResultStatus
 
 
 class TaskResultAdapter(TaskResult):

src/conductor/client/helpers/helper.py

@@ -7,7 +7,6 @@
 import six
 from requests.structures import CaseInsensitiveDict
 
-import conductor.client.http.models as http_models
 from conductor.client.configuration.configuration import Configuration
 from conductor.client.codegen import rest
 
@@ -84,6 +83,7 @@ def __deserialize(self, data, klass):
             if klass in self.NATIVE_TYPES_MAPPING:
                 klass = self.NATIVE_TYPES_MAPPING[klass]
             else:
+                import conductor.client.http.models as http_models
                 klass = getattr(http_models, klass)
 
         if klass in self.PRIMITIVE_TYPES:

tests/unit/orkes/test_async_authorization_client.py

@@ -258,13 +258,30 @@ async def test_get_user(mocker, authorization_client, conductor_user_adapter):
     assert user.uuid == USER_UUID
 
 
+@pytest.mark.asyncio
+async def test_get_user_with_empty_string(mocker, authorization_client, conductor_user_adapter):
+    from conductor.asyncio_client.http.api import UserResourceApi
+    mock = mocker.patch.object(UserResourceApi, "get_user")
+    mock.return_value = conductor_user_adapter
+    await authorization_client.get_user("")
+    mock.assert_called_with(id=None)
+
+
 @pytest.mark.asyncio
 async def test_delete_user(mocker, authorization_client):
     mock = mocker.patch.object(UserResourceApiAdapter, "delete_user")
     await authorization_client.delete_user(USER_ID)
     mock.assert_called_with(id=USER_ID)
 
 
+@pytest.mark.asyncio
+async def test_delete_user_with_empty_string(mocker, authorization_client):
+    from conductor.asyncio_client.http.api import UserResourceApi
+    mock = mocker.patch.object(UserResourceApi, "delete_user")
+    await authorization_client.delete_user("")
+    mock.assert_called_with(id=None)
+
+
 @pytest.mark.asyncio
 async def test_list_users_with_apps(mocker, authorization_client, conductor_user_adapter):
     mock = mocker.patch.object(UserResourceApiAdapter, "list_users")
@@ -295,6 +312,16 @@ async def test_upsert_user(mocker, authorization_client, conductor_user_adapter)
     assert user.uuid == USER_UUID
 
 
+@pytest.mark.asyncio
+async def test_upsert_user_with_empty_string(mocker, authorization_client, conductor_user_adapter):
+    from conductor.asyncio_client.http.api import UserResourceApi
+    mock = mocker.patch.object(UserResourceApi, "upsert_user")
+    upsert_req = UpsertUserRequestAdapter(name=USER_NAME, roles=["ADMIN"])
+    mock.return_value = conductor_user_adapter
+    await authorization_client.upsert_user("", upsert_req)
+    mock.assert_called_with(id=None, upsert_user_request=upsert_req)
+
+
 @pytest.mark.asyncio
 async def test_create_group(mocker, authorization_client, group_adapter):
     mock = mocker.patch.object(GroupResourceApiAdapter, "upsert_group")
@@ -484,6 +511,15 @@ async def test_get_group_permissions(mocker, authorization_client: OrkesAuthoriz
     }
 
 
+@pytest.mark.asyncio
+async def test_get_granted_permissions_for_user_with_empty_string(mocker, authorization_client):
+    from conductor.asyncio_client.http.api import UserResourceApi
+    mock = mocker.patch.object(UserResourceApi, "get_granted_permissions")
+    mock.return_value = {"grantedAccess": []}
+    await authorization_client.get_granted_permissions_for_user("")
+    mock.assert_called_with(user_id=None)
+
+
 @pytest.mark.asyncio
 async def test_create_access_key_empty_string_converts_to_none(mocker, authorization_client):
     from conductor.asyncio_client.http.api.application_resource_api import (

tests/unit/orkes/test_authorization_client.py

@@ -312,6 +312,15 @@ def test_upsert_user(mocker, authorization_client, conductor_user, roles):
     assert user.roles == roles
 
 
+def test_upsert_user_with_empty_string(mocker, authorization_client, conductor_user, roles):
+    from conductor.client.codegen.api.user_resource_api import UserResourceApi
+    mock = mocker.patch.object(UserResourceApi, "upsert_user")
+    upsert_req = UpsertUserRequest(USER_NAME, ["ADMIN"])
+    mock.return_value = conductor_user.to_dict()
+    authorization_client.upsert_user(upsert_req, "")
+    mock.assert_called_with(id=None, body=upsert_req)
+
+
 def test_get_user(mocker, authorization_client, conductor_user, roles):
     mock = mocker.patch.object(UserResourceApi, "get_user")
     mock.return_value = conductor_user.to_dict()
@@ -323,6 +332,14 @@ def test_get_user(mocker, authorization_client, conductor_user, roles):
     assert user.roles == roles
 
 
+def test_get_user_with_empty_string(mocker, authorization_client, conductor_user):
+    from conductor.client.codegen.api.user_resource_api import UserResourceApi
+    mock = mocker.patch.object(UserResourceApi, "get_user")
+    mock.return_value = conductor_user.to_dict()
+    authorization_client.get_user("")
+    mock.assert_called_with(id=None)
+
+
 def test_list_users_with_apps(mocker, authorization_client, conductor_user):
     mock = mocker.patch.object(UserResourceApi, "list_users")
     mock.return_value = [conductor_user]
@@ -345,6 +362,13 @@ def test_delete_user(mocker, authorization_client):
     mock.assert_called_with(USER_ID)
 
 
+def test_delete_user_with_empty_string(mocker, authorization_client):
+    from conductor.client.codegen.api.user_resource_api import UserResourceApi
+    mock = mocker.patch.object(UserResourceApi, "delete_user")
+    authorization_client.delete_user("")
+    mock.assert_called_with(id=None)
+
+
 def test_upsert_group(mocker, authorization_client, conductor_group, group_roles):
     mock = mocker.patch.object(GroupResourceApi, "upsert_group")
     upsertReq = UpsertGroupRequest(GROUP_NAME, ["USER"])
@@ -453,6 +477,14 @@ def test_get_granted_permissions_for_user(mocker, authorization_client):
     assert perms == [expected_perm]
 
 
+def test_get_granted_permissions_for_user_with_empty_string(mocker, authorization_client):
+    from conductor.client.codegen.api.user_resource_api import UserResourceApi
+    mock = mocker.patch.object(UserResourceApi, "get_granted_permissions")
+    mock.return_value = {"grantedAccess": []}
+    authorization_client.get_granted_permissions_for_user("")
+    mock.assert_called_with(user_id=None)
+
+
 def test_get_permissions(mocker, authorization_client):
     mock = mocker.patch.object(AuthorizationResourceApi, "get_permissions")
     mock.return_value = {