updates in user/project custom_fields

Author: Narek Mkhitaryan

docs/source/api_reference/api_team.rst

@@ -8,3 +8,5 @@ Team
 .. automethod:: superannotate.SAClient.invite_contributors_to_team
 .. automethod:: superannotate.SAClient.search_team_contributors
 .. automethod:: superannotate.SAClient.get_user_metadata
+.. automethod:: superannotate.SAClient.set_user_custom_field
+.. automethod:: superannotate.SAClient.list_users

src/superannotate/lib/app/interface/sdk_interface.py

@@ -32,7 +32,6 @@ class ItemFilters(BaseFilters):
 
 
 class ProjectFilters(BaseFilters):
-    # TODO finalize fields
     status: Literal["NotStarted", "InProgress", "Completed", "OnHold"]
     status__ne: Literal["NotStarted", "InProgress", "Completed", "OnHold"]
     status__in: List[Literal["NotStarted", "InProgress", "Completed", "OnHold"]]
@@ -48,8 +47,8 @@ class UserFilters(TypedDict, total=False):
     email__contains: Optional[str]
     email__starts: Optional[str]
     email__ends: Optional[str]
-    state: Optional[str]
-    state__in: Optional[List[str]]
-    role: Optional[str]
-    role__in: Optional[List[str]]
+    state: Optional[Literal["CONFIRMED", "PENDING"]]
+    state__in: Optional[List[Literal["CONFIRMED", "PENDING"]]]
+    role: Optional[Literal["admin", "contributor"]]
+    role__in: Optional[List[Literal["admin", "contributor"]]]
     custom_field: Optional[str]  # dummy field to pass first level validation

src/superannotate/lib/core/entities/filters.py

@@ -1,3 +1,4 @@
+from typing import List
 from typing import Optional
 
 from lib.core.entities.base import BaseItemEntity
@@ -26,7 +27,7 @@ class Config:
 
 
 class MultiModalItemEntity(BaseItemEntity):
-    categories: Optional[list[MultiModalItemCategoryEntity]]
+    categories: Optional[List[MultiModalItemCategoryEntity]]
 
     class Config:
         extra = Extra.ignore

src/superannotate/lib/core/entities/items.py

@@ -111,9 +111,22 @@ def build(self) -> str:
         return f"filter={self._build()}"
 
     def body_build(self) -> Tuple[str, List[Dict]]:
-        filter_value = [{self._key: {self._operator.value: self._value}}]
-        if self._key.startswith("customField.custom_field_values."):
-            filter_value.append({self._key: {"$notnull": True}})
+        filter_value: List[Dict] = []
+        if self._value is None and self._operator == OperatorEnum.EQ:
+            filter_value.append({self._key: {"$isnull": True}})
+        elif self._operator == OperatorEnum.NOTIN:
+            filter_value.append(
+                {
+                    "$or": [
+                        {self._key: {self._operator.value: self._value}},
+                        {self._key: {"$isnull": True}},
+                    ]
+                }
+            )
+        else:
+            filter_value.append({self._key: {self._operator.value: self._value}})
+            if self._key.startswith("customField.custom_field_values."):
+                filter_value.append({self._key: {"$notnull": True}})
         return "$and", filter_value
 
 

src/superannotate/lib/core/jsx_conditions.py

@@ -115,6 +115,7 @@ def list_custom_field_templates(
     ):
         raise NotImplementedError
 
+    @abstractmethod
     def create_project_custom_field_template(self, data: dict):
         raise NotImplementedError
 
@@ -123,11 +124,13 @@ def list_project_custom_entities(self, project_id: int):
         raise NotImplementedError
 
     @abstractmethod
-    def set_project_custom_field_value(self, project_id: int, data: dict):
+    def list_projects(
+        self, body_query: Query, chunk_size: int = 100
+    ) -> WMProjectListResponse:
         raise NotImplementedError
 
     @abstractmethod
-    def list_projects(
+    def search_projects(
         self, body_query: Query, chunk_size: int = 100
     ) -> WMProjectListResponse:
         raise NotImplementedError

src/superannotate/lib/core/serviceproviders.py

@@ -1,7 +1,6 @@
 import decimal
 import logging
 from collections import defaultdict
-from typing import Any
 from typing import List
 
 import lib.core as constances
@@ -194,49 +193,6 @@ def execute(self):
         return self._response
 
 
-class SetProjectCustomFieldUseCase(BaseUseCase):
-    def __init__(
-        self,
-        project: ProjectEntity,
-        service_provider: BaseServiceProvider,
-        custom_field_name: str,
-        value: Any,
-    ):
-        super().__init__()
-        self._project = project
-        self._service_provider = service_provider
-        self._custom_field_name = custom_field_name
-        self._value = value
-
-    def execute(self):
-        if (
-            self._custom_field_name
-            not in self._service_provider.list_custom_field_names(
-                entity=CustomFieldEntityEnum.PROJECT
-            )
-        ):
-            raise AppException("Invalid custom field name provided.")
-        custom_field_id = self._service_provider.get_custom_field_id(
-            self._custom_field_name, entity=CustomFieldEntityEnum.PROJECT
-        )
-        component_id = self._service_provider.get_custom_field_component_id(
-            custom_field_id, entity=CustomFieldEntityEnum.PROJECT
-        )
-        # timestamp: convert seconds to milliseconds
-        if component_id == CustomFieldType.DATE_PICKER.value:
-            try:
-                self._value = self._value * 1000
-            except Exception:
-                raise AppException("Invalid custom field value provided.")
-        patch_data = {custom_field_id: self._value}
-        # TODO add error handling
-        res = self._service_provider.work_management.set_project_custom_field_value(
-            project_id=self._project.id, data=patch_data
-        )
-        if res.error:
-            raise AppException(res.error)
-
-
 class CreateProjectUseCase(BaseUseCase):
     def __init__(
         self,

src/superannotate/lib/core/usecases/projects.py

@@ -124,6 +124,8 @@ def get_user_metadata(
         else:
             filters = {"email": pk}
         users = self.list_users(include=include, **filters)
+        if not users:
+            raise AppException("User not found.")
         return users[0]
 
     def set_custom_field_value(
@@ -132,14 +134,23 @@ def set_custom_field_value(
         entity: CustomFieldEntity,
         parent_entity: CustomFieldEntityEnum,
         field_name: str,
-        value: dict,
+        value: Any,
     ):
         _context = {}
         if entity == CustomFieldEntityEnum.PROJECT:
             _context["project_id"] = entity_id
         template_id = self.service_provider.get_custom_field_id(
             field_name, entity=entity
         )
+        component_id = self.service_provider.get_custom_field_component_id(
+            template_id, entity=entity
+        )
+        # timestamp: convert seconds to milliseconds
+        if component_id == CustomFieldType.DATE_PICKER.value:
+            try:
+                value = value * 1000
+            except Exception:
+                raise AppException("Invalid custom field value provided.")
         self.service_provider.work_management.set_custom_field_value(
             entity_id=entity_id,
             entity=entity,
@@ -220,17 +231,6 @@ def get_metadata(
         )
         return use_case.execute()
 
-    def set_project_custom_field(
-        self, project: ProjectEntity, custom_field_name: str, value: Any
-    ):
-        use_case = usecases.SetProjectCustomFieldUseCase(
-            project=project,
-            service_provider=self.service_provider,
-            custom_field_name=custom_field_name,
-            value=value,
-        )
-        return use_case.execute()
-
     def create(self, entity: ProjectEntity) -> Response:
         use_case = usecases.CreateProjectUseCase(
             project=entity, service_provider=self.service_provider
@@ -360,32 +360,36 @@ def list_projects(
         include: List[str] = None,
         **filters: Unpack[ProjectFilters],
     ) -> List[ProjectEntity]:
-        if include and "custom_fields" in include:
-            chain = QueryBuilderChain(
-                [
-                    FieldValidationHandler(ProjectFilters.__annotations__.keys()),
-                    ProjectFilterHandler(
-                        self.service_provider, entity=CustomFieldEntityEnum.PROJECT
-                    ),
-                ]
-            )
-            query = chain.handle(filters, EmptyQuery())
+        chain = QueryBuilderChain(
+            [
+                FieldValidationHandler(ProjectFilters.__annotations__.keys()),
+                ProjectFilterHandler(
+                    self.service_provider, entity=CustomFieldEntityEnum.PROJECT
+                ),
+            ]
+        )
+        query = chain.handle(filters, EmptyQuery())
+        include_custom_fields: bool = (
+            True if include and "custom_fields" in include else False
+        )
+        if include_custom_fields:
             response = self.service_provider.work_management.list_projects(
                 body_query=query
             )
         else:
-            # TODO add call after BED update
-            raise NotImplementedError
-        # set custom field names
+            response = self.service_provider.work_management.search_projects(
+                body_query=query
+            )
         if response.error:
             raise AppException(response.error)
         projects = response.data
-        custom_fields_list = [project.custom_fields for project in projects]
-        serialized_fields = serialize_custom_fields(
-            self.service_provider, custom_fields_list, CustomFieldEntityEnum.PROJECT
-        )
-        for project, serialized_custom_fields in zip(projects, serialized_fields):
-            project.custom_fields = serialized_custom_fields
+        if include_custom_fields:
+            custom_fields_list = [project.custom_fields for project in projects]
+            serialized_fields = serialize_custom_fields(
+                self.service_provider, custom_fields_list, CustomFieldEntityEnum.PROJECT
+            )
+            for project, serialized_custom_fields in zip(projects, serialized_fields):
+                project.custom_fields = serialized_custom_fields
         return projects
 
 

src/superannotate/lib/infrastructure/controller.py

@@ -11,7 +11,9 @@
 from lib.core.entities import ProjectEntity
 from lib.core.enums import ApprovalStatus
 from lib.core.enums import CustomFieldEntityEnum
+from lib.core.enums import CustomFieldType
 from lib.core.enums import ProjectStatus
+from lib.core.enums import UserRole
 from lib.core.exceptions import AppException
 from lib.core.jsx_conditions import EmptyQuery
 from lib.core.jsx_conditions import Filter
@@ -72,12 +74,12 @@ def __init__(self, valid_fields: Iterable[str]):
         self._valid_fields = valid_fields
 
     def handle(self, filters: Dict[str, Any], query: Query = None) -> Query:
-        if filters and not any(
-            filter_name.startswith(field)
-            for filter_name in filters
-            for field in self._valid_fields
-        ):
-            raise AppException("Invalid filter param provided.")
+        for param in filters.keys():
+            if (
+                not param.startswith("custom_field__")
+                and param not in self._valid_fields
+            ):
+                raise AppException("Invalid filter param provided.")
         return super().handle(filters, query)
 
 
@@ -218,23 +220,60 @@ def _handle_special_fields(self, keys: List[str], val):
 
 
 class UserFilterHandler(BaseCustomFieldHandler):
-    @staticmethod
-    def _handle_special_fields(keys: List[str], val):
+    def _handle_special_fields(self, keys: List[str], val):
+        """
+        Handle special fields like 'custom_fields__'.
+        """
+        if keys[0] == "custom_field":
+            component_id = self._service_provider.get_custom_field_component_id(
+                field_id=int(keys[1]), entity=self._entity
+            )
+            if component_id == CustomFieldType.DATE_PICKER.value:
+                try:
+                    val = val * 1000
+                except Exception:
+                    raise AppException("Invalid custom field value provided.")
+        elif keys[0] == "role":
+            try:
+                if isinstance(val, list):
+                    val = [UserRole.__getitem__(i.upper()).value for i in val]
+                elif isinstance(val, str):
+                    val = UserRole.__getitem__(val.upper()).value
+                else:
+                    raise AppException("Invalid user role provided.")
+            except (KeyError, AttributeError):
+                raise AppException("Invalid user role provided.")
+        elif keys[0] == "state":
+            valid_states = ["PENDING", "CONFIRMED"]
+            if isinstance(val, list):
+                for state in val:
+                    if state not in valid_states:
+                        raise AppException("Invalid user state provided.")
+            elif val not in valid_states:
+                raise AppException("Invalid user state provided.")
         return val
 
 
 class ProjectFilterHandler(BaseCustomFieldHandler):
-    @staticmethod
-    def _handle_special_fields(keys: List[str], val):
+    def _handle_special_fields(self, keys: List[str], val):
         """
-        Handle special fields like 'status'.
+        Handle special fields like 'status' and 'custom_fields__'.
         """
         if keys[0] == "status":
             val = (
                 [ProjectStatus(i).value for i in val]
                 if isinstance(val, (list, tuple, set))
                 else ProjectStatus(val).value
             )
+        elif keys[0] == "custom_field":
+            component_id = self._service_provider.get_custom_field_component_id(
+                field_id=int(keys[1]), entity=self._entity
+            )
+            if component_id == CustomFieldType.DATE_PICKER.value:
+                try:
+                    val = val * 1000
+                except Exception:
+                    raise AppException("Invalid custom field value provided.")
         return val