fluidattacks_zoho_sdk 1.0.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

fluidattacks_zoho_sdk/zoho_desk/__init__.py

@@ -0,0 +1,51 @@
+from dataclasses import dataclass
+
+from fluidattacks_zoho_sdk._http_client import ClientFactory, HttpJsonClient, TokenManager
+from fluidattacks_zoho_sdk.auth import Credentials
+from fluidattacks_zoho_sdk.bulk_export import BulkApiFactory
+from fluidattacks_zoho_sdk.bulk_export.core import BulkClient
+from fluidattacks_zoho_sdk.ids import OrgId
+
+from . import _client
+from .core import AgentObj, ContactObj, DeskClient, UserObj
+
+
+def _bulk_client(creds: Credentials, org_id: OrgId, token_manager: TokenManager) -> BulkClient:
+    return BulkApiFactory.new(creds, org_id, token_manager)
+
+
+def _from_client(
+    client: HttpJsonClient,
+    creds: Credentials,
+    org_id: OrgId,
+    token: TokenManager,
+) -> DeskClient:
+    bulk_client = _bulk_client(creds, org_id, token)
+
+    return DeskClient(
+        get_teams=_client.get_teams(client),
+        fetch_bulk_agents=_client.fetch_bulk_export_agents(bulk_client),
+        fetch_bulk_tickets=_client.fetch_bulk_export_tickets(bulk_client),
+        fetch_bulk_contacts=_client.fetch_bulk_contacts(bulk_client),
+    )
+
+
+@dataclass(frozen=True)
+class DeskClientFactory:
+    @staticmethod
+    def new(creds: Credentials, org_id: OrgId, token_manager: TokenManager) -> DeskClient:
+        return _from_client(
+            ClientFactory.new(creds, org_id, token_manager),
+            creds,
+            org_id,
+            token_manager,
+        )
+
+
+__all__ = [
+    "AgentObj",
+    "ContactObj",
+    "DeskClient",
+    "DeskClientFactory",
+    "UserObj",
+]

fluidattacks_zoho_sdk/zoho_desk/_client.py

@@ -0,0 +1,88 @@
+import inspect
+import logging
+
+from fa_purity import Cmd, FrozenList, ResultE, cast_exception
+from fa_purity.json import Primitive, UnfoldedFactory
+from fluidattacks_etl_utils.bug import Bug
+
+from fluidattacks_zoho_sdk._decoders import assert_single
+from fluidattacks_zoho_sdk._http_client import HttpJsonClient, RelativeEndpoint
+from fluidattacks_zoho_sdk.bulk_export import BulkClient, BulkEndpoint, FileName, ModuleName
+
+from ._decode import decode_agents, decode_contacts, decode_teams, decode_tickets
+from .core import AgentObj, ContactObj, DerivedAgent, TeamObj, TicketObj
+
+LOG = logging.getLogger(__name__)
+
+
+def fetch_bulk_contacts(
+    client: BulkClient,
+) -> Cmd[ResultE[FrozenList[ContactObj]]]:
+    endpoint_bulk = BulkEndpoint("bulkExport")
+    module_name = ModuleName("contacts")
+    file_name = FileName("Contacts__1.csv")
+
+    return client.fetch_bulk(module_name, endpoint_bulk, file_name).map(
+        lambda result: (
+            result.alt(
+                lambda e: cast_exception(
+                    Bug.new("_generate_bulk_export_contacts", inspect.currentframe(), e, ()),
+                ),
+            ).bind(decode_contacts)
+        ),
+    )
+
+
+def fetch_bulk_export_tickets(
+    client: BulkClient,
+) -> Cmd[ResultE[FrozenList[TicketObj]]]:
+    endpoint_bulk = BulkEndpoint("bulkExport")
+    module_name = ModuleName("tickets")
+    file_name = FileName("Cases__1.csv")
+
+    return client.fetch_bulk(module_name, endpoint_bulk, file_name).map(
+        lambda result: (
+            result.alt(
+                lambda e: cast_exception(
+                    Bug.new("_generate_bulk_export_tickets", inspect.currentframe(), e, ()),
+                ),
+            ).bind(decode_tickets)
+        ),
+    )
+
+
+def get_teams(
+    client: HttpJsonClient,
+) -> Cmd[ResultE[FrozenList[tuple[TeamObj, FrozenList[DerivedAgent]]]]]:
+    endpoint = RelativeEndpoint.new("teams")
+    params: dict[str, Primitive] = {}
+    return client.get(
+        endpoint,
+        UnfoldedFactory.from_dict(params),
+    ).map(
+        lambda result: (
+            result.alt(
+                lambda e: cast_exception(Bug.new("_get_teams", inspect.currentframe(), e, ())),
+            )
+            .bind(assert_single)
+            .bind(lambda teams: decode_teams(teams))
+        ),
+    )
+
+
+def fetch_bulk_export_agents(
+    client: BulkClient,
+) -> Cmd[ResultE[FrozenList[AgentObj]]]:
+    endpoint_bulk = BulkEndpoint("bulkExport")
+    module_name = ModuleName("agents")
+    file_name = FileName("Agents__1.csv")
+
+    return client.fetch_bulk(module_name, endpoint_bulk, file_name).map(
+        lambda result: (
+            result.alt(
+                lambda e: cast_exception(
+                    Bug.new("_generate_bulk_export_agent", inspect.currentframe(), e, ()),
+                ),
+            ).bind(decode_agents)
+        ),
+    )

fluidattacks_zoho_sdk/zoho_desk/_decode.py

@@ -1,35 +1,40 @@
-from fa_purity import ResultE
-from fa_purity.json import (
-    JsonObj,
-    JsonUnfolder,
+from fa_purity import (
+    FrozenList,
+    Maybe,
+    PureIterFactory,
+    Result,
+    ResultE,
+    ResultTransform,
+    Unsafe,
 )
+from fa_purity.json import JsonObj, JsonPrimitiveUnfolder, JsonUnfolder, Unfolder
 from fluidattacks_etl_utils import smash
 from fluidattacks_etl_utils.decode import DecodeUtils
-from fluidattacks_etl_utils.natural import Natural
+from fluidattacks_etl_utils.natural import Natural, NaturalOperations
 
 from fluidattacks_zoho_sdk._decoders import (
-    decode_account_id,
-    decode_account_id_ticket,
     decode_contact_id,
-    decode_crm_id,
-    decode_deparment_id,
+    decode_contact_id_bulk,
+    decode_department_id,
+    decode_department_id_team,
+    decode_id_team,
+    decode_list_objs,
     decode_maybe_str,
-    decode_optional_date,
-    decode_product_id,
-    decode_profile_id,
-    decode_require_date,
-    decode_rol_id,
-    decode_team_id,
+    decode_opt_date_to_utc,
+    decode_optional_id,
     decode_ticket_id,
     decode_user_id,
+    decode_user_id_bulk,
 )
-from fluidattacks_zoho_sdk.ids import UserId
+from fluidattacks_zoho_sdk.ids import AccountId, ProductId, UserId
 from fluidattacks_zoho_sdk.zoho_desk.core import (
     AgentObj,
     ContactAddres,
     ContactDates,
     ContactInfo,
     ContactObj,
+    DerivedAgent,
+    TeamObj,
     TicketDates,
     TicketObj,
     TicketProperties,
@@ -37,44 +42,45 @@ from fluidattacks_zoho_sdk.zoho_desk.core import (
 )
 
 
+def parse_bool(v: str) -> bool:
+    lv = v.lower().strip()
+    if lv == "true":
+        return True
+    if lv == "false":
+        return False
+    msg = f"Invalid boolean string: {v}"
+    raise ValueError(msg)
+
+
 def decode_user(raw: JsonObj) -> ResultE[UserObj]:
     return smash.smash_result_3(
         decode_user_id(raw),
-        JsonUnfolder.require(raw, "firstName", DecodeUtils.to_str),
+        JsonUnfolder.optional(raw, "firstName", DecodeUtils.to_opt_str).map(
+            lambda v: v.bind(lambda j: j),
+        ),
         JsonUnfolder.require(raw, "lastName", DecodeUtils.to_str),
     ).map(lambda obj: UserObj(*obj))
 
 
-def decode_agent(raw: JsonObj) -> ResultE[AgentObj]:
-    values = smash.smash_result_5(
-        decode_user(raw),
-        JsonUnfolder.require(raw, "isConfirmed", DecodeUtils.to_bool),
-        JsonUnfolder.require(raw, "emailId", DecodeUtils.to_str),
-        decode_profile_id(raw),
-        decode_rol_id(raw),
-    )
-
-    return (
-        smash.bind_chain(
-            values,
-            lambda vals: JsonUnfolder.require(raw, "status", DecodeUtils.to_str).map(
-                lambda status: (*vals, status),
-            ),
-        )
-        .alt(lambda v: v.map(lambda le: le, lambda r: r))
-        .map(lambda obj: AgentObj(*obj))
-    )
+def decode_user_bulk(raw: JsonObj) -> ResultE[UserObj]:
+    return smash.smash_result_3(
+        decode_user_id_bulk(raw),
+        JsonUnfolder.optional(raw, "First Name", DecodeUtils.to_opt_str).map(
+            lambda v: v.bind(lambda j: j),
+        ),
+        JsonUnfolder.require(raw, "Last Name", DecodeUtils.to_str),
+    ).map(lambda v: UserObj(*v))
 
 
 def decode_contact_addres(raw: JsonObj) -> ResultE[ContactAddres]:
     return smash.smash_result_3(
-        JsonUnfolder.optional(raw, "city", DecodeUtils.to_opt_str).map(
+        JsonUnfolder.optional(raw, "City", DecodeUtils.to_opt_str).map(
             lambda v: v.bind(lambda x: x),
         ),
-        JsonUnfolder.optional(raw, "country", DecodeUtils.to_opt_str).map(
+        JsonUnfolder.optional(raw, "Country", DecodeUtils.to_opt_str).map(
             lambda v: v.bind(lambda x: x),
         ),
-        JsonUnfolder.optional(raw, "street", DecodeUtils.to_opt_str).map(
+        JsonUnfolder.optional(raw, "Street", DecodeUtils.to_opt_str).map(
             lambda v: v.bind(lambda x: x),
         ),
     ).map(lambda obj: ContactAddres(*obj))
@@ -82,57 +88,52 @@ def decode_contact_addres(raw: JsonObj) -> ResultE[ContactAddres]:
 
 def decode_contact_dates(raw: JsonObj) -> ResultE[ContactDates]:
     return smash.smash_result_2(
-        JsonUnfolder.require(raw, "createdTime", DecodeUtils.to_date_time),
-        JsonUnfolder.require(raw, "modifiedTime", DecodeUtils.to_date_time),
+        decode_opt_date_to_utc(raw, "Created Time"),
+        decode_opt_date_to_utc(raw, "Modified Time"),
     ).map(lambda obj: ContactDates(*obj))
 
 
 def decode_contact_info(raw: JsonObj) -> ResultE[ContactInfo]:
     return smash.smash_result_5(
-        JsonUnfolder.require(raw, "email", DecodeUtils.to_str),
-        JsonUnfolder.optional(raw, "facebook", DecodeUtils.to_opt_str).map(
-            lambda v: v.bind(lambda x: x),
-        ),
-        JsonUnfolder.require(raw, "phone", DecodeUtils.to_str),
-        JsonUnfolder.optional(raw, "mobile", DecodeUtils.to_opt_str).map(
-            lambda v: v.bind(lambda x: x),
-        ),
-        JsonUnfolder.optional(raw, "secondaryEmail", DecodeUtils.to_opt_str).map(
-            lambda v: v.bind(lambda x: x),
-        ),
+        decode_maybe_str(raw, "Email"),
+        decode_maybe_str(raw, "Facebook"),
+        decode_maybe_str(raw, "Phone"),
+        decode_maybe_str(raw, "Mobile"),
+        decode_maybe_str(raw, "Secondary Email"),
     ).map(lambda obj: ContactInfo(*obj))
 
 
 def decode_contact_obj(raw: JsonObj) -> ResultE[ContactObj]:
     first = smash.smash_result_5(
-        decode_user(raw),
+        decode_contact_id_bulk(raw),
+        decode_user_bulk(raw),
         decode_contact_info(raw),
         decode_contact_addres(raw),
         decode_contact_dates(raw),
-        decode_account_id(raw),
     )
 
-    second = smash.smash_result_4(
-        JsonUnfolder.require(raw, "ownerId", DecodeUtils.to_str)
+    second = smash.smash_result_5(
+        decode_optional_id(raw, "Account ID"),
+        JsonUnfolder.require(raw, "Contact Owner", DecodeUtils.to_str)
         .bind(lambda v: Natural.from_int(int(v)))
         .map(lambda j: UserId(j)),
-        decode_crm_id(raw),
-        JsonUnfolder.optional(raw, "description", DecodeUtils.to_opt_str).map(
+        decode_optional_id(raw, "CRM ID"),
+        JsonUnfolder.optional(raw, "Description", DecodeUtils.to_opt_str).map(
             lambda v: v.bind(lambda j: j),
         ),
-        JsonUnfolder.optional(raw, "state", DecodeUtils.to_opt_str).map(
+        JsonUnfolder.optional(raw, "State", DecodeUtils.to_opt_str).map(
             lambda v: v.bind(lambda j: j),
         ),
     )
 
     three = smash.smash_result_3(
-        JsonUnfolder.optional(raw, "title", DecodeUtils.to_opt_str).map(
+        JsonUnfolder.optional(raw, "Title", DecodeUtils.to_opt_str).map(
             lambda v: v.bind(lambda j: j),
         ),
-        JsonUnfolder.optional(raw, "type", DecodeUtils.to_opt_str).map(
+        JsonUnfolder.optional(raw, "Type", DecodeUtils.to_opt_str).map(
             lambda v: v.bind(lambda j: j),
         ),
-        JsonUnfolder.optional(raw, "zip", DecodeUtils.to_opt_str).map(
+        JsonUnfolder.optional(raw, "Zip", DecodeUtils.to_opt_str).map(
             lambda v: v.bind(lambda j: j),
         ),
     )
@@ -140,53 +141,167 @@ def decode_contact_obj(raw: JsonObj) -> ResultE[ContactObj]:
     return smash.smash_result_3(first, second, three).map(lambda v: ContactObj(*v[0], *v[1], *v[2]))
 
 
+def decode_contacts(raws: FrozenList[JsonObj]) -> ResultE[FrozenList[ContactObj]]:
+    return decode_list_objs(raws, decode_contact_obj)
+
+
 def decode_ticket_dates(raw: JsonObj) -> ResultE[TicketDates]:
     return smash.smash_result_4(
-        decode_optional_date(raw, "modifiedTime"),
-        decode_require_date(raw, "createdTime"),
-        decode_optional_date(raw, "closedTime"),
-        decode_optional_date(raw, "customerResponseTime"),
+        decode_opt_date_to_utc(raw, "Modified Time"),
+        decode_opt_date_to_utc(raw, "Created Time"),
+        decode_opt_date_to_utc(raw, "Ticket Closed Time"),
+        decode_opt_date_to_utc(raw, "Customer Response Time"),
     ).map(lambda v: TicketDates(*v))
 
 
 def decode_ticket_properties(raw: JsonObj) -> ResultE[TicketProperties]:
-    first = smash.smash_result_5(
+    first = smash.smash_result_4(
         decode_ticket_id(raw),
-        JsonUnfolder.require(raw, "ticketNumber", DecodeUtils.to_str),
-        decode_maybe_str(raw, "subject"),
-        decode_maybe_str(raw, "channel"),
-        decode_maybe_str(raw, "status"),
+        decode_maybe_str(raw, "Subject"),
+        decode_maybe_str(raw, "Channel"),
+        decode_maybe_str(raw, "Status"),
     )
 
     second = smash.smash_result_4(
-        decode_maybe_str(raw, "category"),
-        JsonUnfolder.require(raw, "isEscalated", DecodeUtils.to_bool),
-        JsonUnfolder.require(raw, "priority", DecodeUtils.to_str),
-        decode_maybe_str(raw, "resolution"),
+        decode_maybe_str(raw, "Category"),
+        JsonUnfolder.require(raw, "Is Escalated", DecodeUtils.to_str).map(parse_bool),
+        decode_maybe_str(raw, "Priority"),
+        decode_maybe_str(raw, "Resolution"),
     )
 
     three = smash.smash_result_2(
-        decode_maybe_str(raw, "clasification"),
-        decode_maybe_str(raw, "description"),
+        decode_maybe_str(raw, "Classifications"),
+        decode_maybe_str(raw, "Description"),
     )
     return smash.smash_result_3(first, second, three).map(
         lambda v: TicketProperties(*v[0], *v[1], *v[2]),
     )
 
 
+def decode_maybe_account_id(raw: JsonObj) -> ResultE[Maybe[AccountId]]:
+    return JsonUnfolder.optional(raw, "Account ID", DecodeUtils.to_opt_str).map(
+        lambda v: v.bind(lambda x: x)
+        .map(
+            lambda j: Natural.from_int(int(j)).alt(Unsafe.raise_exception).to_union(),
+        )
+        .map(lambda obj: AccountId(obj)),
+    )
+
+
+def decode_maybe_product_id(raw: JsonObj) -> ResultE[Maybe[ProductId]]:
+    return JsonUnfolder.optional(raw, "Product ID", DecodeUtils.to_opt_str).map(
+        lambda v: v.bind(lambda x: x)
+        .map(
+            lambda j: Natural.from_int(int(j)).alt(Unsafe.raise_exception).to_union(),
+        )
+        .map(lambda obj: ProductId(obj)),
+    )
+
+
 def decode_ticket_obj(raw: JsonObj) -> ResultE[TicketObj]:
     first = smash.smash_result_5(
-        decode_account_id_ticket(raw),
-        decode_deparment_id(raw),
-        decode_team_id(raw),
-        decode_product_id(raw),
+        decode_optional_id(raw, "Account ID"),
+        decode_optional_id(raw, "Department"),
+        decode_optional_id(raw, "Team ID"),
+        decode_optional_id(raw, "Product ID"),
         decode_ticket_dates(raw),
     )
-    second = smash.smash_result_5(
+
+    second = smash.smash_result_4(
         decode_ticket_properties(raw),
         decode_contact_id(raw),
-        JsonUnfolder.require(raw, "email", DecodeUtils.to_str),
-        JsonUnfolder.require(raw, "phone", DecodeUtils.to_str),
-        decode_maybe_str(raw, "onholdTime"),
+        decode_maybe_str(raw, "Email"),
+        decode_maybe_str(raw, "Phone"),
     )
-    return smash.smash_result_2(first, second).map(lambda v: TicketObj(*v[0], *v[1]))
+
+    third = smash.smash_result_2(
+        decode_maybe_str(raw, "Ticket On Hold Time"),
+        decode_maybe_str(raw, "Stakeholder"),
+    )
+    return smash.smash_result_3(first, second, third).map(lambda v: TicketObj(*v[0], *v[1], *v[2]))
+
+
+def decode_tickets(raws: FrozenList[JsonObj]) -> ResultE[FrozenList[TicketObj]]:
+    return decode_list_objs(raws, decode_ticket_obj)
+
+
+def decode_team_obj(raw: JsonObj) -> ResultE[TeamObj]:
+    return smash.smash_result_4(
+        decode_department_id(raw),
+        decode_id_team(raw),
+        JsonUnfolder.require(raw, "description", DecodeUtils.to_str),
+        JsonUnfolder.require(raw, "name", DecodeUtils.to_str),
+    ).map(lambda team: TeamObj(*team))
+
+
+def decode_derived_agent(
+    id_agent: str,
+) -> ResultE[DerivedAgent]:
+    return Result.success(DerivedAgent(UserId(NaturalOperations.absolute(int(id_agent)))))
+
+
+def decode_team_obj_with_agents(raw: JsonObj) -> ResultE[tuple[TeamObj, FrozenList[DerivedAgent]]]:
+    team_r: ResultE[TeamObj] = smash.smash_result_4(
+        decode_department_id_team(raw),
+        decode_id_team(raw),
+        JsonUnfolder.require(raw, "description", DecodeUtils.to_str),
+        JsonUnfolder.require(raw, "name", DecodeUtils.to_str),
+    ).map(lambda team: TeamObj(*team))
+
+    derived_agents_json = JsonUnfolder.require(
+        raw,
+        "derivedAgents",
+        lambda v: Unfolder.to_list_of(
+            v,
+            lambda j: Unfolder.to_primitive(j).bind(lambda j: JsonPrimitiveUnfolder.to_str(j)),
+        ),
+    )
+
+    list_agents = derived_agents_json.bind(
+        lambda agents: ResultTransform.all_ok(
+            tuple(PureIterFactory.from_list(agents).map(decode_derived_agent)),
+        ),
+    )
+
+    return team_r.bind(lambda team: list_agents.map(lambda agents: (team, agents)))
+
+
+def decode_derived_agents(agents: FrozenList[str]) -> ResultE[FrozenList[DerivedAgent]]:
+    if not agents:
+        return Result.failure(ValueError("Expected a list wiht elements"))
+    return ResultTransform.all_ok(
+        PureIterFactory.from_list(agents).map(lambda v: decode_derived_agent(v)).to_list(),
+    )
+
+
+def decode_teams(raw: JsonObj) -> ResultE[FrozenList[tuple[TeamObj, FrozenList[DerivedAgent]]]]:
+    return JsonUnfolder.require(
+        raw,
+        "teams",
+        lambda v: Unfolder.to_list_of(
+            v,
+            lambda j: Unfolder.to_json(j).bind(decode_team_obj_with_agents),
+        ),
+    )
+
+
+# DECODERS AGENTS
+
+
+def decode_agent_obj(raw: JsonObj) -> ResultE[AgentObj]:
+    first = smash.smash_result_3(
+        decode_user_bulk(raw),
+        JsonUnfolder.require(raw, "IsConfirmed", DecodeUtils.to_str).map(parse_bool),
+        JsonUnfolder.require(raw, "Email", DecodeUtils.to_str),
+    )
+
+    second = smash.smash_result_3(
+        JsonUnfolder.require(raw, "Profile", DecodeUtils.to_str),
+        JsonUnfolder.require(raw, "Role", DecodeUtils.to_str),
+        JsonUnfolder.require(raw, "Status", DecodeUtils.to_str),
+    )
+    return smash.smash_result_2(first, second).map(lambda v: AgentObj(*v[0], *v[1]))
+
+
+def decode_agents(raws: FrozenList[JsonObj]) -> ResultE[FrozenList[AgentObj]]:
+    return decode_list_objs(raws, decode_agent_obj)

fluidattacks_zoho_sdk/zoho_desk/core.py

@@ -1,26 +1,28 @@
+from __future__ import annotations
+
 from dataclasses import dataclass
 
-from fa_purity import Maybe
+from fa_purity import Cmd, FrozenList, Maybe, ResultE
 from fa_purity.date_time import DatetimeUTC
 
 from fluidattacks_zoho_sdk.ids import (
-    AccountId,
     ContactId,
-    CrmId,
     DeparmentId,
-    ProductId,
-    ProfileId,
-    RoleId,
     TeamId,
     TicketId,
     UserId,
 )
 
 
+@dataclass(frozen=True)
+class OptionalId:
+    id: str
+
+
 @dataclass(frozen=True)
 class UserObj:
     id_user: UserId
-    first_name: str
+    first_name: Maybe[str]
     last_name: str
 
 
@@ -29,22 +31,22 @@ class AgentObj:
     user: UserObj
     is_confirmed: bool
     email: str
-    profile: ProfileId
-    role: RoleId
+    profile: str
+    role: str
     status: str
 
 
 @dataclass(frozen=True)
 class ContactDates:
-    created_time: DatetimeUTC
-    modified_time: DatetimeUTC
+    created_time: Maybe[DatetimeUTC]
+    modified_time: Maybe[DatetimeUTC]
 
 
 @dataclass(frozen=True)
 class ContactInfo:
-    email: str
+    email: Maybe[str]
     facebook: Maybe[str]
-    phone: str
+    phone: Maybe[str]
     mobile: Maybe[str]
     secondary_email: Maybe[str]
 
@@ -58,13 +60,14 @@ class ContactAddres:
 
 @dataclass(frozen=True)
 class ContactObj:
+    contact_id: ContactId
     user: UserObj
     contact_info: ContactInfo
     contact_addres: ContactAddres
     contact_dates: ContactDates
-    account_id: AccountId
+    account_id: Maybe[OptionalId]
     contact_owner: UserId
-    crm_id: CrmId
+    crm_id: Maybe[OptionalId]
     description: Maybe[str]
     state: Maybe[str]
     title: Maybe[str]
@@ -80,10 +83,15 @@ class TeamObj:
     name: str
 
 
+@dataclass(frozen=True)
+class DerivedAgent:
+    id_user: UserId
+
+
 @dataclass(frozen=True)
 class TicketDates:
     modified_time: Maybe[DatetimeUTC]
-    created_time: DatetimeUTC
+    created_time: Maybe[DatetimeUTC]
     closed_time: Maybe[DatetimeUTC]
     customer_response_time: Maybe[DatetimeUTC]
 
@@ -91,13 +99,12 @@ class TicketDates:
 @dataclass(frozen=True)
 class TicketProperties:
     id_ticket: TicketId
-    ticket_number: str
     suject: Maybe[str]
     channel: Maybe[str]
     status: Maybe[str]
     category: Maybe[str]
     is_escalated: bool
-    priority: str
+    priority: Maybe[str]
     resolution: Maybe[str]
     classification: Maybe[str]
     description: Maybe[str]
@@ -105,13 +112,23 @@ class TicketProperties:
 
 @dataclass(frozen=True)
 class TicketObj:
-    account_id: AccountId
-    deparment_id: DeparmentId
-    team_id: TeamId
-    product_id: ProductId
+    account_id: Maybe[OptionalId]
+    deparment_id: Maybe[OptionalId]
+    team_id: Maybe[OptionalId]
+    product_id: Maybe[OptionalId]
     ticket_date: TicketDates
     ticket_properties: TicketProperties
     contact_id: ContactId
-    email: str
-    phone: str
+    email: Maybe[str]
+    phone: Maybe[str]
     onhold_time: Maybe[str]
+    stakeholder: Maybe[str]
+
+
+@dataclass(frozen=True)
+class DeskClient:
+    get_teams: Cmd[ResultE[FrozenList[tuple[TeamObj, FrozenList[DerivedAgent]]]]]
+    # bulk export
+    fetch_bulk_agents: Cmd[ResultE[FrozenList[AgentObj]]]
+    fetch_bulk_tickets: Cmd[ResultE[FrozenList[TicketObj]]]
+    fetch_bulk_contacts: Cmd[ResultE[FrozenList[ContactObj]]]

{fluidattacks_zoho_sdk-1.0.0.dist-info → fluidattacks_zoho_sdk-2.0.0.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: fluidattacks_zoho_sdk
-Version: 1.0.0
+Version: 2.0.0
 Summary: zoho SDK
 Author-email: Product Team <development@fluidattacks.com>
 Requires-Python: >=3.11
 Requires-Dist: fa-purity >=2.5.0, <3.0.0
-Requires-Dist: fluidattacks-etl-utils >=1.0.0, <2.0.0
+Requires-Dist: fluidattacks-etl-utils >=2.0.0, <3.0.0
 Requires-Dist: pure-requests >=3.0.0, <4.0.0