Tapi 0.1.2__py3-none-any.whl

tapi/api/admin/user.py

@@ -0,0 +1,104 @@
+from tapi.client import Client
+from datetime    import datetime
+from typing      import Optional, List, Literal, Union
+
+
+class UsersAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "admin"
+
+    def create(
+            self,
+            email:              str,
+            first_name:         Optional[str]                                                                     = None,
+            last_name:          Optional[str]                                                                     = None,
+            admin:              bool                                                                              = False,
+            tenant_permissions: Optional[List[Literal["AUDIT_LOG_READ", "FEATURE_FLAG_MANAGE", "TUNNEL_MANAGE"]]] = None,
+            is_active:          bool                                                                              = True
+    ):
+        return self._http_request(
+            "POST",
+            f"{self.base_endpoint}/users",
+            json = {key: value for key, value in locals().items() if value is not None and key != "self"}
+        )
+
+    def get(
+            self,
+            user_id: int
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/users/{user_id}"
+        )
+
+    def sign_in_activity(
+            self,
+            user_id:  int,
+            before:   Optional[Union[datetime, str]] = None,
+            after:    Optional[Union[datetime, str]] = None,
+            per_page: int                            = 10,
+            page:     int                            = 1
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/users/{user_id}/signin_activities",
+            params = {key: value for key, value in locals().items()
+                      if value is not None and key not in ("self", "user_id")}
+        )
+
+    def update(
+            self,
+            user_id:            int,
+            email:              Optional[str]                                                                     = None,
+            first_name:         Optional[str]                                                                     = None,
+            last_name:          Optional[str]                                                                     = None,
+            admin:              Optional[bool]                                                                    = None,
+            tenant_permissions: Optional[List[Literal["AUDIT_LOG_READ", "FEATURE_FLAG_MANAGE", "TUNNEL_MANAGE"]]] = None,
+            is_active:          Optional[bool]                                                                    = None
+    ):
+        return self._http_request(
+            "PUT",
+            f"{self.base_endpoint}/users/{user_id}",
+            json = {key: value for key, value in locals().items()
+                    if value is not None and key not in ("self", "user_id")}
+        )
+
+    def list(
+            self,
+            per_page: int                               = 10,
+            page:     int                               = 1,
+            filter:   Optional[Literal["TENANT_OWNER"]] = None
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/users",
+            params = {key: value for key, value in locals().items() if value is not None and key != "self"}
+        )
+
+    def delete(
+            self,
+            user_id: int
+    ):
+        return self._http_request(
+            "DELETE",
+            f"{self.base_endpoint}/users/{user_id}"
+        )
+
+    def resend_invitation(
+            self,
+            user_id: int
+    ):
+        return self._http_request(
+            "POST",
+            f"{self.base_endpoint}/users/{user_id}/resend_invitation"
+        )
+
+    def expire_session(
+            self,
+            user_id: int
+    ):
+        return self._http_request(
+            "POST",
+            f"{self.base_endpoint}/users/{user_id}/expire_session"
+        )

tapi/api/audit_log/__init__.py

@@ -0,0 +1,5 @@
+from .audit_logs import AuditLogsAPI
+
+__all__ = [
+    "AuditLogsAPI"
+]

tapi/api/audit_log/audit_logs.py

@@ -0,0 +1,24 @@
+from tapi.client      import Client
+from tapi.utils.types import AuditLogType
+from typing           import Optional, List, Union
+
+
+class AuditLogsAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "audit_logs"
+
+    def list(
+            self,
+            before:         Optional[int]                            = None,
+            after:          Optional[int]                            = None,
+            user_id:        Optional[List[int]]                      = None,
+            operation_name: Optional[List[Union[AuditLogType, str]]] = None,
+            per_page:       int                                      = 10,
+            page:           int                                      = 1
+    ):
+        return self._http_request(
+            "GET",
+            self.base_endpoint,
+            params = {key: value for key, value in locals().items() if value is not None and key != "self"}
+        )

tapi/api/case/__init__.py

@@ -0,0 +1,20 @@
+from .cases        import CasesAPI
+from .notes        import CaseNotesAPI
+from .files        import CaseFilesAPI
+from .fields       import CaseFieldsAPI
+from .records      import CaseRecordsAPI
+from .actions      import CaseActionsAPI
+from .linked_cases import LinkedCasesAPI
+from .metadata     import CaseMetadataAPI
+from .assignees    import CaseAssigneesAPI
+from .activities   import CaseActivitiesAPI
+from .subscribers  import CaseSubscribersAPI
+from .inputs       import CaseInputsAPI, CaseInputsFieldsAPI
+from .blocks       import CaseBlocksAPI, CaseBlockElementsAPI
+from .comments     import CaseCommentsAPI, CaseCommentsReactionsAPI
+
+__all__ = [
+    "CasesAPI", "CaseActionsAPI", "CaseAssigneesAPI", "CaseActivitiesAPI", "CaseInputsAPI", "CaseInputsFieldsAPI",
+    "CaseCommentsAPI", "CaseCommentsReactionsAPI", "CaseFieldsAPI", "CaseFilesAPI", "LinkedCasesAPI", "CaseMetadataAPI",
+    "CaseNotesAPI", "CaseRecordsAPI", "CaseSubscribersAPI", "CaseBlocksAPI", "CaseBlockElementsAPI"
+]

tapi/api/case/actions.py

@@ -0,0 +1,90 @@
+from tapi.client      import Client
+from tapi.utils.types import CaseActionType
+from typing           import List, Optional, Dict, Any, Union
+
+
+class CaseActionsAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "cases"
+
+    def create(
+            self,
+            case_id:     int,
+            url:         str,
+            label:       str,
+            action_type: Union[CaseActionType, str],
+            action_text: Optional[str] = None
+    ):
+        return self._http_request(
+            "POST",
+            f"{self.base_endpoint}/{case_id}/actions",
+            "v2",
+            json={key: value for key, value in locals().items() if
+                  value is not None and key not in ("self", "case_id")}
+        )
+
+    def get(
+            self,
+            case_id: int,
+            id:      int
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{case_id}/actions/{id}",
+            "v2"
+        )
+
+    def update(
+            self,
+            case_id:     int,
+            id:          int,
+            url:         Optional[str]                        = None,
+            label:       Optional[str]                        = None,
+            action_type: Optional[Union[CaseActionType, str]] = None,
+            action_text: Optional[str]                        = None
+    ):
+        return self._http_request(
+            "PUT",
+            f"{self.base_endpoint}/{case_id}/actions/{id}",
+            "v2",
+            json={key: value for key, value in locals().items() if
+                  value is not None and key not in ("self", "case_id", "id")}
+        )
+
+    def list(
+            self,
+            case_id:  int,
+            per_page: int = 10,
+            page:     int = 1,
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{case_id}/actions",
+            "v2",
+            json={key: value for key, value in locals().items() if
+                  value is not None and key not in ("self", "case_id")}
+        )
+
+    def delete(
+            self,
+            case_id: int,
+            id:      int
+    ):
+        return self._http_request(
+            "DELETE",
+            f"{self.base_endpoint}/{case_id}/actions/{id}",
+            "v2"
+        )
+
+    def batch_update(
+            self,
+            case_id: int,
+            actions: List[Dict[str, Any]]
+    ):
+        return self._http_request(
+            "PUT",
+            f"{self.base_endpoint}/{case_id}/actions/batch",
+            "v2",
+            json={"actions": actions}
+        )

tapi/api/case/activities.py

@@ -0,0 +1,35 @@
+from tapi.client      import Client
+from typing           import Optional, Union
+from tapi.utils.types import CaseActivityType
+
+
+class CaseActivitiesAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "cases"
+
+    def get(
+            self,
+            case_id:     int,
+            activity_id: int
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{case_id}/activities/{activity_id}",
+            "v2"
+        )
+
+    def list(
+            self,
+            case_id:       int,
+            activity_type: Optional[Union[CaseActivityType, str]] = None,
+            per_page:      int                                    = 10,
+            page:          int                                    = 1
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{case_id}/activities",
+            "v2",
+            params = {"activity_type": activity_type},
+            json   = {"per_page": per_page, "page": page}
+        )

tapi/api/case/assignees.py

@@ -0,0 +1,21 @@
+from tapi.client import Client
+
+
+class CaseAssigneesAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "cases"
+
+    def list(
+            self,
+            case_id:  int,
+            per_page: int = 10,
+            page:     int = 1,
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{case_id}/assignees",
+            "v2",
+            json = {key: value for key, value in locals().items() if
+                    value is not None and key not in ("self", "case_id")}
+        )

tapi/api/case/blocks.py

@@ -0,0 +1,112 @@
+from tapi.client import Client
+from typing      import Union, Literal, List, Dict, Optional
+
+
+class CaseBlocksAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "cases"
+        self.elements      = CaseBlockElementsAPI(domain, apiKey)
+
+    def create(
+            self,
+            case_id:    int,
+            title:      str,
+            block_type: Union[Literal["note", "file"]],
+            elements:   List[Dict[str, str]],
+            position:   int                        = 0,
+    ):
+        return self._http_request(
+            "POST",
+            f"{self.base_endpoint}/{case_id}/blocks",
+            "v2",
+            json = {key: value for key, value in locals().items() if
+                    value is not None and key not in ("self", "case_id")}
+        )
+
+    def get(
+            self,
+            case_id:  int,
+            block_id: int
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{case_id}/blocks/{block_id}",
+            "v2",
+        )
+
+    def update(
+            self,
+            case_id:  int,
+            block_id: int,
+            title:    Optional[str] = None,
+            position: Optional[str] = None
+    ):
+        return self._http_request(
+            "PUT",
+            f"{self.base_endpoint}/{case_id}/blocks/{block_id}",
+            "v2",
+            json = {key: value for key, value in locals().items() if
+                    value is not None and key not in ("self", "case_id", "block_id")}
+        )
+
+    def list(
+            self,
+            case_id:    int,
+            block_type: Optional[Literal["note", "file"]] = None,
+            per_page:   int = 10,
+            page:       int = 1
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{case_id}/blocks",
+            "v2",
+            params = {key: value for key, value in locals().items() if
+                    value is not None and key not in ("self", "case_id")}
+        )
+
+    def delete(
+            self,
+            case_id:  int,
+            block_id: int
+    ):
+        return self._http_request(
+            "DELETE",
+            f"{self.base_endpoint}/{case_id}/blocks/{block_id}",
+            "v2"
+        )
+
+
+class CaseBlockElementsAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "cases"
+
+    def get(
+            self,
+            case_id:    int,
+            block_id:   int,
+            element_id: int,
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{case_id}/blocks/{block_id}/elements/{element_id}",
+            "v2"
+        )
+
+    def update(
+            self,
+            case_id:    int,
+            block_id:   int,
+            element_id: int,
+            content:    Optional[str]                                                   = None,
+            color:      Optional[Literal[ "white", "gold", "magenta", "green", "blue"]] = None
+    ):
+        return self._http_request(
+            "PUT",
+            f"{self.base_endpoint}/{case_id}/blocks/{block_id}/elements/{element_id}",
+            "v2",
+            json = {key: value for key, value in locals().items() if
+                    value is not None and key not in ("self", "case_id", "block_id", "element_id")}
+        )
+

tapi/api/case/cases.py

@@ -0,0 +1,132 @@
+from tapi.client      import Client
+from .notes           import CaseNotesAPI
+from .files           import CaseFilesAPI
+from .fields          import CaseFieldsAPI
+from .inputs          import CaseInputsAPI
+from .blocks          import CaseBlocksAPI
+from .actions         import CaseActionsAPI
+from .linked_cases    import LinkedCasesAPI
+from .records         import CaseRecordsAPI
+from .metadata        import CaseMetadataAPI
+from .comments        import CaseCommentsAPI
+from .assignees       import CaseAssigneesAPI
+from .activities      import CaseActivitiesAPI
+from .subscribers     import CaseSubscribersAPI
+from typing           import List, Any, Dict, Optional, Union
+from tapi.utils.types import CasePriority, CaseStatus, CaseReturnOrder
+
+class CasesAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "cases"
+        self.files         = CaseFilesAPI(domain, apiKey)
+        self.notes         = CaseNotesAPI(domain, apiKey)
+        self.inputs        = CaseInputsAPI(domain, apiKey)
+        self.fields        = CaseFieldsAPI(domain, apiKey)
+        self.blocks        = CaseBlocksAPI(domain, apiKey)
+        self.linked_cases  = LinkedCasesAPI(domain, apiKey)
+        self.actions       = CaseActionsAPI(domain, apiKey)
+        self.records       = CaseRecordsAPI(domain, apiKey)
+        self.comments      = CaseCommentsAPI(domain, apiKey)
+        self.metadata      = CaseMetadataAPI(domain, apiKey)
+        self.assignees     = CaseAssigneesAPI(domain, apiKey)
+        self.activities    = CaseActivitiesAPI(domain, apiKey)
+        self.subscribers   = CaseSubscribersAPI(domain, apiKey)
+
+    def create(
+            self,
+            team_id:            int,
+            name:               str,
+            description:        Optional[str]                  = None,
+            priority:           Union[CasePriority, str]       = CasePriority.LOW,
+            status:             Union[CaseStatus, str]         = CaseStatus.OPEN,
+            sub_status_id:      Optional[int]                  = None,
+            author_email:       Optional[str]                  = None,
+            assignee_emails:    Optional[List[str]]            = None,
+            tag_names:          Optional[List[str]]            = None,
+            opened_at:          Optional[str]                  = None,
+            resolved_at:        Optional[str]                  = None,
+            metadata:           Optional[Dict[str, str]]       = None,
+            closure_conditions: Optional[List[Dict[str, Any]]] = None,
+            field_values:       Optional[Dict[str, Any]]       = None
+        ):
+        return self._http_request(
+            "POST",
+            self.base_endpoint,
+            "v2",
+            json = {key: value for key, value in locals().items() if
+                    value is not None and key != "self"}
+        )
+
+    def get(
+            self,
+            case_id: int    
+        ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{case_id}",
+            "v2"
+        )
+
+    def download(
+            self,
+            case_id: int
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{case_id}/pdf",
+            "v2"
+        )
+
+    def update(
+            self,
+            case_id:                int,
+            name:                   Optional[str]                      = None,
+            team_id:                Optional[int]                      = None,
+            description:            Optional[str]                      = None,
+            priority:               Optional[Union[CasePriority, str]] = None,
+            status:                 Optional[Union[CaseStatus, str]]   = None,
+            sub_status_id:          Optional[int]                      = None,
+            author_email:           Optional[str]                      = None,
+            assignee_emails:        Optional[List[str]]                = None,
+            add_assignee_emails:    Optional[List[str]]                = None,
+            remove_assignee_emails: Optional[List[str]]                = None,
+            add_tag_names:          Optional[List[str]]                = None,
+            remove_tag_names:       Optional[List[str]]                = None,
+            opened_at:              Optional[str]                      = None,
+            resolved_at:            Optional[str]                      = None,
+            closure_conditions:     Optional[List[Dict[str, Any]]]     = None
+        ):
+        return self._http_request(
+            "PUT",
+            f"{self.base_endpoint}/{case_id}",
+            "v2",
+            json = {key: value for key, value in locals().items() if
+                    value is not None and key not in ("self", "case_id")}
+        )
+
+    def list(
+            self,
+            team_id:  Optional[int]                         = None,
+            filters:  Optional[Dict[str, Any]]              = None,
+            order:    Optional[Union[CaseReturnOrder, str]] = None,
+            per_page: int                                   = 10,
+            page:     int                                   = 1
+        ):
+        return self._http_request(
+            "GET",
+            self.base_endpoint,
+            "v2",
+            json = {key: value for key, value in locals().items() if
+                    value is not None and key != "self"}
+        )
+
+    def delete(
+            self,
+            case_id: int
+        ):
+        return self._http_request(
+            "DELETE",
+            f"{self.base_endpoint}/{case_id}",
+            "v2"
+        )

tapi/api/case/comments.py

@@ -0,0 +1,102 @@
+from tapi.client      import Client
+from tapi.utils.types import ReactionType
+from typing           import Optional, Union
+
+
+class CaseCommentsAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "cases"
+        self.reactions     = CaseCommentsReactionsAPI(domain, apiKey)
+
+    def create(
+            self,
+            case_id:      int,
+            value:        str,
+            author_email: Optional[str] = None
+    ):
+        return self._http_request(
+            "POST",
+            f"{self.base_endpoint}/{case_id}/comments",
+            "v2",
+            json = {"value": value, "author_email": author_email}
+        )
+
+    def get(
+            self,
+            case_id:    int,
+            comment_id: int
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{case_id}/comments/{comment_id}",
+            "v2"
+        )
+
+    def update(
+            self,
+            case_id:    int,
+            comment_id: int,
+            value:      str
+    ):
+        return self._http_request(
+            "PUT",
+            f"{self.base_endpoint}/{case_id}/comments/{comment_id}",
+            "v2",
+            json = {"value": value}
+        )
+
+    def list(
+            self,
+            case_id:  int,
+            per_page: int = 10,
+            page:     int = 1
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{case_id}/comments",
+            "v2",
+            json = {"per_page": per_page, "page": page}
+        )
+
+    def delete(
+            self,
+            case_id:    int,
+            comment_id: int
+    ):
+        return self._http_request(
+            "DELETE",
+            f"{self.base_endpoint}/{case_id}/comments/{comment_id}",
+            "v2"
+        )
+
+class CaseCommentsReactionsAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "cases"
+
+    def add(
+            self,
+            case_id:    int,
+            comment_id: int,
+            value:      Union[ReactionType, str]
+    ):
+        return self._http_request(
+            "POST",
+            f"{self.base_endpoint}/{case_id}/comments/{comment_id}/reactions",
+            "v2",
+            json = {"value": value}
+        )
+
+    def remove(
+            self,
+            case_id:    int,
+            comment_id: int,
+            value:      Union[ReactionType, str]
+    ):
+        return self._http_request(
+            "DELETE",
+            f"{self.base_endpoint}/{case_id}/comments/{comment_id}/reactions",
+            "v2",
+            json={"value": value}
+        )