fluidattacks_zoho_sdk 1.0.0__py3-none-any.whl

fluidattacks_zoho_sdk/__init__.py

@@ -0,0 +1,8 @@
+from fluidattacks_zoho_sdk.auth import AuthApiFactory, Credentials
+
+__version__ = "1.0.0"
+
+__all__ = [
+    "AuthApiFactory",
+    "Credentials",
+]

fluidattacks_zoho_sdk/_decoders.py

@@ -0,0 +1,177 @@
+from typing import (
+    IO,
+)
+
+from fa_purity import Maybe, ResultE, Unsafe
+from fa_purity.date_time import DatetimeUTC
+from fa_purity.json import (
+    JsonObj,
+    JsonPrimitiveUnfolder,
+    JsonUnfolder,
+    UnfoldedFactory,
+    Unfolder,
+)
+from fluidattacks_etl_utils.decode import DecodeUtils
+from fluidattacks_etl_utils.natural import Natural
+
+from fluidattacks_zoho_sdk.auth import Credentials
+from fluidattacks_zoho_sdk.ids import (
+    AccountId,
+    ContactId,
+    CrmId,
+    DeparmentId,
+    ProductId,
+    ProfileId,
+    RoleId,
+    TeamId,
+    TicketId,
+    UserId,
+)
+
+
+def _decode_zoho_creds(raw: JsonObj) -> ResultE[Credentials]:
+    client_id = JsonUnfolder.require(raw, "client_id", Unfolder.to_primitive).bind(
+        JsonPrimitiveUnfolder.to_str,
+    )
+    client_secret = JsonUnfolder.require(raw, "client_secret", Unfolder.to_primitive).bind(
+        JsonPrimitiveUnfolder.to_str,
+    )
+    refresh_token = JsonUnfolder.require(raw, "refresh_token", Unfolder.to_primitive).bind(
+        JsonPrimitiveUnfolder.to_str,
+    )
+    scopes_result = JsonUnfolder.require(
+        raw,
+        "scopes",
+        lambda i: Unfolder.to_list_of(
+            i,
+            lambda x: Unfolder.to_primitive(x).bind(JsonPrimitiveUnfolder.to_str),
+        ),
+    )
+    return client_id.bind(
+        lambda cid: client_secret.bind(
+            lambda secret: refresh_token.bind(
+                lambda token: scopes_result.map(
+                    lambda scopes: Credentials(cid, secret, token, frozenset(scopes)),
+                ),
+            ),
+        ),
+    )
+
+
+def get_sub_json(raw: JsonObj, key: str) -> JsonObj:
+    return (
+        JsonUnfolder.require(raw, key, lambda v: Unfolder.to_json(v))
+        .alt(Unsafe.raise_exception)
+        .to_union()
+    )
+
+
+def decode_optional_date(raw: JsonObj, key: str) -> ResultE[Maybe[DatetimeUTC]]:
+    return JsonUnfolder.optional(raw, key, DecodeUtils.to_opt_date_time).map(
+        lambda v: v.bind(lambda j: j),
+    )
+
+
+def decode_require_date(raw: JsonObj, key: str) -> ResultE[DatetimeUTC]:
+    return JsonUnfolder.require(raw, key, DecodeUtils.to_date_time)
+
+
+def decode_maybe_str(raw: JsonObj, key: str) -> ResultE[Maybe[str]]:
+    return JsonUnfolder.optional(raw, key, DecodeUtils.to_opt_str).map(
+        lambda v: v.bind(lambda j: j),
+    )
+
+
+def decode_zoho_creds(auth_file: IO[str]) -> ResultE[Credentials]:
+    return UnfoldedFactory.load(auth_file).bind(_decode_zoho_creds)
+
+
+def decode_user_id(raw: JsonObj) -> ResultE[UserId]:
+    return (
+        JsonUnfolder.require(raw, "id", DecodeUtils.to_str)
+        .bind(lambda v: Natural.from_int(int(v)))
+        .map(UserId)
+    )
+
+
+def decode_rol_id(raw: JsonObj) -> ResultE[RoleId]:
+    return (
+        JsonUnfolder.require(raw, "roleId", DecodeUtils.to_str)
+        .bind(lambda v: Natural.from_int(int(v)))
+        .map(RoleId)
+    )
+
+
+def decode_profile_id(raw: JsonObj) -> ResultE[ProfileId]:
+    return (
+        JsonUnfolder.require(raw, "profileId", DecodeUtils.to_str)
+        .bind(lambda v: Natural.from_int(int(v)))
+        .map(ProfileId)
+    )
+
+
+def decode_account_id(raw: JsonObj) -> ResultE[AccountId]:
+    return (
+        JsonUnfolder.require(raw, "accountId", DecodeUtils.to_str)
+        .bind(lambda v: Natural.from_int(int(v)))
+        .map(AccountId)
+    )
+
+
+def decode_crm_id(raw: JsonObj) -> ResultE[CrmId]:
+    return (
+        JsonUnfolder.require(get_sub_json(raw, "zohoCRMContact"), "id", DecodeUtils.to_str)
+        .bind(lambda v: Natural.from_int(int(v)))
+        .map(lambda obj: CrmId(obj))
+    )
+
+
+def decode_deparment_id(raw: JsonObj) -> ResultE[DeparmentId]:
+    return (
+        JsonUnfolder.optional(raw, "departmentId", 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: DeparmentId(obj))
+    )
+
+
+def decode_product_id(raw: JsonObj) -> ResultE[ProductId]:
+    return (
+        JsonUnfolder.optional(raw, "productId", 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_team_id(raw: JsonObj) -> ResultE[TeamId]:
+    return JsonUnfolder.require(raw, "teamId", DecodeUtils.to_str).bind(
+        lambda v: Natural.from_int(int(v)).map(lambda obj: TeamId(obj)),
+    )
+
+
+def decode_ticket_id(raw: JsonObj) -> ResultE[TicketId]:
+    return JsonUnfolder.require(raw, "id", DecodeUtils.to_str).bind(
+        lambda v: Natural.from_int(int(v)).map(lambda obj: TicketId(obj)),
+    )
+
+
+def decode_contact_id(raw: JsonObj) -> ResultE[ContactId]:
+    return JsonUnfolder.require(get_sub_json(raw, "contact"), "id", DecodeUtils.to_str).bind(
+        lambda v: Natural.from_int(int(v)).map(lambda obj: ContactId(obj)),
+    )
+
+
+def decode_account_id_ticket(raw: JsonObj) -> ResultE[AccountId]:
+    account_obj = get_sub_json(raw, "contact")
+    return JsonUnfolder.require(
+        get_sub_json(account_obj, "account"),
+        "id",
+        DecodeUtils.to_str,
+    ).bind(lambda v: Natural.from_int(int(v)).map(lambda obj: AccountId(obj)))

fluidattacks_zoho_sdk/auth/__init__.py

@@ -0,0 +1,51 @@
+import logging
+from dataclasses import (
+    dataclass,
+)
+
+from fa_purity import (
+    Cmd,
+)
+from fa_purity.json import (
+    JsonObj,
+)
+
+from . import (
+    _access,
+    _refresh,
+    _revoke,
+)
+from ._core import (
+    Credentials,
+    RefreshToken,
+    Token,
+)
+
+ACCOUNTS_URL = "https://accounts.zoho.com"  # for US region
+LOG = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class AuthApi:
+    new_access_token: Cmd[Token]
+    manual_new_refresh_token: Cmd[RefreshToken]
+    manual_revoke_token: Cmd[JsonObj]
+
+
+@dataclass(frozen=True)
+class AuthApiFactory:
+    @staticmethod
+    def auth_api(creds: Credentials) -> AuthApi:
+        return AuthApi(
+            _access.new_access_token(creds),
+            _refresh.generate_refresh_token(creds),
+            _revoke.revoke_refresh_token(),
+        )
+
+
+__version__ = "1.0.0"
+__all__ = [
+    "Credentials",
+    "RefreshToken",
+    "Token",
+]

fluidattacks_zoho_sdk/auth/_access.py

@@ -0,0 +1,86 @@
+import inspect
+import logging
+
+from fa_purity import (
+    Cmd,
+    FrozenDict,
+    ResultE,
+    cast_exception,
+)
+from fa_purity.json import (
+    JsonObj,
+    JsonPrimitiveUnfolder,
+    JsonUnfolder,
+    Primitive,
+    UnfoldedFactory,
+    Unfolder,
+)
+from fluidattacks_etl_utils.bug import Bug
+from pure_requests.basic import (
+    Data,
+    Endpoint,
+    HttpClientFactory,
+    Params,
+)
+
+from ._core import (
+    Credentials,
+    Token,
+)
+from ._decode import (
+    decode_json,
+)
+
+ACCOUNTS_URL = "https://accounts.zoho.com"  # for US region
+LOG = logging.getLogger(__name__)
+
+
+def _decode(raw: JsonObj) -> ResultE[Token]:
+    return JsonUnfolder.require(
+        raw,
+        "access_token",
+        lambda v: Unfolder.to_primitive(v).bind(JsonPrimitiveUnfolder.to_str),
+    ).map(Token)
+
+
+def new_access_token(credentials: Credentials) -> Cmd[Token]:
+    LOG.info("Generating access token")
+    endpoint = Endpoint(f"{ACCOUNTS_URL}/oauth/v2/token")
+    params: dict[str, Primitive] = {
+        "refresh_token": credentials.refresh_token,
+        "client_id": credentials.client_id,
+        "client_secret": credentials.client_secret,
+        "grant_type": "refresh_token",
+    }
+    empty: JsonObj = FrozenDict({})
+    client = HttpClientFactory.new_client(None, None, None)
+    response = client.post(endpoint, Params(UnfoldedFactory.from_dict(params)), Data(empty)).map(
+        lambda r: Bug.assume_success(
+            "NewTokenError.response",
+            inspect.currentframe(),
+            (str(client), endpoint.raw, str(params)),
+            r.alt(cast_exception),
+        ),
+    )
+    data = response.map(
+        lambda r: Bug.assume_success(
+            "NewTokenError.decode_json",
+            inspect.currentframe(),
+            (str(client), endpoint.raw, str(params)),
+            decode_json(r).alt(
+                lambda c: c.map(
+                    cast_exception,
+                    lambda v: v.map(cast_exception, cast_exception),
+                ),
+            ),
+        ),
+    )
+
+    return data.map(
+        lambda j: Bug.assume_success(
+            "NewTokenError.decode_json",
+            inspect.currentframe(),
+            (JsonUnfolder.dumps(j),),
+            _decode(j),
+        ),
+    )

fluidattacks_zoho_sdk/auth/_core.py

@@ -0,0 +1,39 @@
+import hashlib
+from dataclasses import (
+    dataclass,
+)
+
+ACCOUNTS_URL = "https://accounts.zoho.com"  # for US region
+
+
+@dataclass(frozen=True)
+class Token:
+    raw_token: str
+
+    def __repr__(self) -> str:
+        return "[masked]"
+
+
+@dataclass(frozen=True)
+class RefreshToken:
+    raw_token: str
+
+    def __repr__(self) -> str:
+        signature = hashlib.sha256(self.raw_token.encode("utf-8")).hexdigest()[:128]
+        return f"[masked] signature={signature}"
+
+
+@dataclass(frozen=True)
+class Credentials:
+    client_id: str
+    client_secret: str
+    refresh_token: str
+    scopes: frozenset[str]
+
+    def __repr__(self) -> str:
+        return f"Creds(client_id={self.client_id}, scopes={self.scopes})"
+
+
+__all__ = [
+    "Token",
+]

fluidattacks_zoho_sdk/auth/_decode.py

@@ -0,0 +1,62 @@
+from typing import (
+    TypeVar,
+)
+
+from fa_purity import (
+    Coproduct,
+    CoproductFactory,
+    FrozenList,
+    Result,
+    ResultE,
+    ResultFactory,
+)
+from fa_purity.json import (
+    JsonObj,
+)
+from pure_requests.response import (
+    handle_status,
+    json_decode,
+)
+from requests import (
+    HTTPError,
+    JSONDecodeError,
+    Response,
+)
+
+_T = TypeVar("_T")
+
+
+def decode_json(
+    response: Response,
+) -> Result[JsonObj, Coproduct[HTTPError, Coproduct[JSONDecodeError, TypeError]]]:
+    _factory: CoproductFactory[HTTPError, Coproduct[JSONDecodeError, TypeError]] = (
+        CoproductFactory()
+    )
+    _factory_2: CoproductFactory[JSONDecodeError, TypeError] = CoproductFactory()
+    _factory_3: ResultFactory[
+        JsonObj,
+        Coproduct[HTTPError, Coproduct[JSONDecodeError, TypeError]],
+    ] = ResultFactory()
+    return (
+        handle_status(response)
+        .alt(lambda x: _factory.inl(x))
+        .bind(
+            lambda r: json_decode(r)
+            .alt(lambda e: _factory.inr(_factory_2.inl(e)))
+            .bind(
+                lambda c: c.map(
+                    lambda j: _factory_3.success(j),
+                    lambda _: _factory_3.failure(
+                        _factory.inr(_factory_2.inr(TypeError("Expected non-list"))),
+                    ),
+                ),
+            ),
+        )
+    )
+
+
+def require_index(items: FrozenList[_T], index: int) -> ResultE[_T]:
+    try:
+        return Result.success(items[index])
+    except IndexError as err:
+        return Result.failure(Exception(err))

fluidattacks_zoho_sdk/auth/_refresh.py

@@ -0,0 +1,123 @@
+import inspect
+import logging
+from getpass import (
+    getpass,
+)
+from urllib.parse import (
+    urlencode,
+)
+
+from fa_purity import (
+    Cmd,
+    FrozenDict,
+    Result,
+    ResultE,
+    cast_exception,
+)
+from fa_purity.json import (
+    JsonObj,
+    JsonPrimitiveUnfolder,
+    JsonUnfolder,
+    Primitive,
+    UnfoldedFactory,
+    Unfolder,
+)
+from fluidattacks_etl_utils.bug import Bug
+from pure_requests.basic import (
+    Data,
+    Endpoint,
+    HttpClientFactory,
+    Params,
+)
+from requests import (
+    RequestException,
+    Response,
+)
+
+from ._core import (
+    ACCOUNTS_URL,
+    Credentials,
+    RefreshToken,
+)
+from ._decode import (
+    decode_json,
+)
+
+LOG = logging.getLogger(__name__)
+
+
+def _decode(raw: JsonObj) -> ResultE[RefreshToken]:
+    LOG.debug("raw token response: %s", JsonUnfolder.dumps(raw))
+    return JsonUnfolder.require(
+        raw,
+        "refresh_token",
+        lambda v: Unfolder.to_primitive(v).bind(JsonPrimitiveUnfolder.to_str),
+    ).map(RefreshToken)
+
+
+def _user_input_code() -> Cmd[str]:
+    def _action() -> str:
+        LOG.info("Paste grant token:")
+        token = getpass()
+        LOG.debug(token)
+        return token
+
+    return Cmd.wrap_impure(_action)
+
+
+def _gen_refresh_token(
+    credentials: Credentials,
+    code: str,
+) -> Cmd[Result[Response, RequestException]]:
+    endpoint = Endpoint(f"{ACCOUNTS_URL}/oauth/v2/token")
+    raw: dict[str, Primitive] = {
+        "grant_type": "authorization_code",
+        "client_id": credentials.client_id,
+        "client_secret": credentials.client_secret,
+        "code": code,
+    }
+    empty: JsonObj = FrozenDict({})
+    encoded = urlencode(raw)
+    headers: dict[str, Primitive] = {
+        "Content-Type": "application/x-www-form-urlencoded",
+        "Content-Length": str(len(encoded)),
+    }
+    client = HttpClientFactory.new_client(None, UnfoldedFactory.from_dict(headers), None)
+    return client.post(endpoint, Params(empty), Data(encoded))
+
+
+def _decode_refresh(result: Result[Response, RequestException]) -> ResultE[RefreshToken]:
+    response = Bug.assume_success(
+        "AuthRefreshError.response",
+        inspect.currentframe(),
+        (),
+        result.alt(cast_exception),
+    )
+    json_data = Bug.assume_success(
+        "AuthRefreshError.decode_json",
+        inspect.currentframe(),
+        (),
+        decode_json(response).alt(
+            lambda e: e.map(cast_exception, lambda f: f.map(cast_exception, cast_exception)),
+        ),
+    )
+    return _decode(json_data)
+
+
+def generate_refresh_token(
+    credentials: Credentials,
+) -> Cmd[RefreshToken]:
+    msg = Cmd.wrap_impure(
+        lambda: LOG.info(
+            "Generating refresh token with scopes: %s",
+            ",".join(credentials.scopes),
+        ),
+    )
+    return msg + _user_input_code().bind(lambda c: _gen_refresh_token(credentials, c)).map(
+        lambda r: Bug.assume_success(
+            "AuthRefreshError.decode_token",
+            inspect.currentframe(),
+            (str(r),),
+            _decode_refresh(r),
+        ),
+    )

fluidattacks_zoho_sdk/auth/_revoke.py

@@ -0,0 +1,98 @@
+import inspect
+import logging
+from getpass import (
+    getpass,
+)
+from urllib.parse import (
+    urlencode,
+)
+
+from fa_purity import (
+    Cmd,
+    FrozenDict,
+    cast_exception,
+)
+from fa_purity.json import (
+    JsonObj,
+    Primitive,
+    UnfoldedFactory,
+)
+from fluidattacks_etl_utils.bug import Bug
+from pure_requests.basic import (
+    Data,
+    Endpoint,
+    HttpClientFactory,
+    Params,
+)
+
+from ._core import (
+    RefreshToken,
+)
+from ._decode import (
+    decode_json,
+)
+
+ACCOUNTS_URL = "https://accounts.zoho.com"  # for US region
+LOG = logging.getLogger(__name__)
+
+
+def _user_input() -> Cmd[RefreshToken]:
+    def _action() -> RefreshToken:
+        LOG.info("Refresh token to revoke:")
+        return RefreshToken(getpass())
+
+    return Cmd.wrap_impure(_action)
+
+
+def _revoke_refresh_token(token: RefreshToken) -> Cmd[JsonObj]:
+    endpoint = Endpoint(f"{ACCOUNTS_URL}/oauth/v2/token/revoke")
+    empty: JsonObj = FrozenDict({})
+    raw: dict[str, Primitive] = {
+        "token": token.raw_token,
+    }
+    encoded = urlencode(raw)
+    headers: dict[str, Primitive] = {
+        "Content-Type": "application/x-www-form-urlencoded",
+        "Content-Length": str(len(encoded)),
+    }
+    client = HttpClientFactory.new_client(None, UnfoldedFactory.from_dict(headers), None)
+    return (
+        client.post(
+            endpoint,
+            Params(empty),
+            Data(encoded),
+        )
+        .map(
+            lambda r: Bug.assume_success(
+                "AuthRevokeError.response",
+                inspect.currentframe(),
+                (endpoint.raw, str(token)),
+                r.alt(cast_exception),
+            ),
+        )
+        .map(
+            lambda r: Bug.assume_success(
+                "AuthRevokeError.decode",
+                inspect.currentframe(),
+                (endpoint.raw, str(token), str(r), str(decode_json(r))),
+                decode_json(r).alt(
+                    lambda e: e.map(
+                        cast_exception,
+                        lambda x: x.map(cast_exception, cast_exception),
+                    ),
+                ),
+            ),
+        )
+    )
+
+
+def revoke_refresh_token() -> Cmd[JsonObj]:
+    return (
+        _user_input()
+        .bind(_revoke_refresh_token)
+        .bind(
+            lambda j: Cmd.wrap_impure(lambda: LOG.debug("revoke_refresh_token: %s", j)).map(
+                lambda _: j,
+            ),
+        )
+    )

fluidattacks_zoho_sdk/ids.py

@@ -0,0 +1,59 @@
+from dataclasses import dataclass
+
+from fa_purity import Maybe
+from fluidattacks_etl_utils.natural import Natural
+
+
+@dataclass(frozen=True)
+class UserId:
+    user_id: Natural
+
+
+@dataclass(frozen=True)
+class AccountId:
+    accound_id: Natural
+
+
+@dataclass(frozen=True)
+class CrmId:
+    crm_id: Natural
+
+
+@dataclass(frozen=True)
+class DeparmentId:
+    id_deparment: Maybe[Natural]
+
+
+@dataclass(frozen=True)
+class TeamId:
+    id_team: Natural
+
+
+@dataclass(frozen=True)
+class AgentId:
+    agent_id: Natural
+
+
+@dataclass(frozen=True)
+class ProfileId:
+    id_profile: Natural
+
+
+@dataclass(frozen=True)
+class RoleId:
+    id_role: Natural
+
+
+@dataclass(frozen=True)
+class ProductId:
+    id_product: Maybe[Natural]
+
+
+@dataclass(frozen=True)
+class TicketId:
+    id_ticket: Natural
+
+
+@dataclass(frozen=True)
+class ContactId:
+    id_contact: Natural

fluidattacks_zoho_sdk/zoho_desk/_decode.py

@@ -0,0 +1,192 @@
+from fa_purity import ResultE
+from fa_purity.json import (
+    JsonObj,
+    JsonUnfolder,
+)
+from fluidattacks_etl_utils import smash
+from fluidattacks_etl_utils.decode import DecodeUtils
+from fluidattacks_etl_utils.natural import Natural
+
+from fluidattacks_zoho_sdk._decoders import (
+    decode_account_id,
+    decode_account_id_ticket,
+    decode_contact_id,
+    decode_crm_id,
+    decode_deparment_id,
+    decode_maybe_str,
+    decode_optional_date,
+    decode_product_id,
+    decode_profile_id,
+    decode_require_date,
+    decode_rol_id,
+    decode_team_id,
+    decode_ticket_id,
+    decode_user_id,
+)
+from fluidattacks_zoho_sdk.ids import UserId
+from fluidattacks_zoho_sdk.zoho_desk.core import (
+    AgentObj,
+    ContactAddres,
+    ContactDates,
+    ContactInfo,
+    ContactObj,
+    TicketDates,
+    TicketObj,
+    TicketProperties,
+    UserObj,
+)
+
+
+def decode_user(raw: JsonObj) -> ResultE[UserObj]:
+    return smash.smash_result_3(
+        decode_user_id(raw),
+        JsonUnfolder.require(raw, "firstName", DecodeUtils.to_str),
+        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_contact_addres(raw: JsonObj) -> ResultE[ContactAddres]:
+    return smash.smash_result_3(
+        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(
+            lambda v: v.bind(lambda x: x),
+        ),
+        JsonUnfolder.optional(raw, "street", DecodeUtils.to_opt_str).map(
+            lambda v: v.bind(lambda x: x),
+        ),
+    ).map(lambda obj: ContactAddres(*obj))
+
+
+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),
+    ).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),
+        ),
+    ).map(lambda obj: ContactInfo(*obj))
+
+
+def decode_contact_obj(raw: JsonObj) -> ResultE[ContactObj]:
+    first = smash.smash_result_5(
+        decode_user(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)
+        .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(
+            lambda v: v.bind(lambda j: j),
+        ),
+        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(
+            lambda v: v.bind(lambda j: j),
+        ),
+        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(
+            lambda v: v.bind(lambda j: j),
+        ),
+    )
+
+    return smash.smash_result_3(first, second, three).map(lambda v: ContactObj(*v[0], *v[1], *v[2]))
+
+
+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"),
+    ).map(lambda v: TicketDates(*v))
+
+
+def decode_ticket_properties(raw: JsonObj) -> ResultE[TicketProperties]:
+    first = smash.smash_result_5(
+        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"),
+    )
+
+    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"),
+    )
+
+    three = smash.smash_result_2(
+        decode_maybe_str(raw, "clasification"),
+        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_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_ticket_dates(raw),
+    )
+    second = smash.smash_result_5(
+        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"),
+    )
+    return smash.smash_result_2(first, second).map(lambda v: TicketObj(*v[0], *v[1]))

fluidattacks_zoho_sdk/zoho_desk/core.py

@@ -0,0 +1,117 @@
+from dataclasses import dataclass
+
+from fa_purity import Maybe
+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 UserObj:
+    id_user: UserId
+    first_name: str
+    last_name: str
+
+
+@dataclass(frozen=True)
+class AgentObj:
+    user: UserObj
+    is_confirmed: bool
+    email: str
+    profile: ProfileId
+    role: RoleId
+    status: str
+
+
+@dataclass(frozen=True)
+class ContactDates:
+    created_time: DatetimeUTC
+    modified_time: DatetimeUTC
+
+
+@dataclass(frozen=True)
+class ContactInfo:
+    email: str
+    facebook: Maybe[str]
+    phone: str
+    mobile: Maybe[str]
+    secondary_email: Maybe[str]
+
+
+@dataclass(frozen=True)
+class ContactAddres:
+    city: Maybe[str]
+    country: Maybe[str]
+    street: Maybe[str]
+
+
+@dataclass(frozen=True)
+class ContactObj:
+    user: UserObj
+    contact_info: ContactInfo
+    contact_addres: ContactAddres
+    contact_dates: ContactDates
+    account_id: AccountId
+    contact_owner: UserId
+    crm_id: CrmId
+    description: Maybe[str]
+    state: Maybe[str]
+    title: Maybe[str]
+    type_contact: Maybe[str]
+    zip_contact: Maybe[str]
+
+
+@dataclass(frozen=True)
+class TeamObj:
+    id_deparment: DeparmentId
+    id_team: TeamId
+    description: str
+    name: str
+
+
+@dataclass(frozen=True)
+class TicketDates:
+    modified_time: Maybe[DatetimeUTC]
+    created_time: DatetimeUTC
+    closed_time: Maybe[DatetimeUTC]
+    customer_response_time: Maybe[DatetimeUTC]
+
+
+@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
+    resolution: Maybe[str]
+    classification: Maybe[str]
+    description: Maybe[str]
+
+
+@dataclass(frozen=True)
+class TicketObj:
+    account_id: AccountId
+    deparment_id: DeparmentId
+    team_id: TeamId
+    product_id: ProductId
+    ticket_date: TicketDates
+    ticket_properties: TicketProperties
+    contact_id: ContactId
+    email: str
+    phone: str
+    onhold_time: Maybe[str]

fluidattacks_zoho_sdk-1.0.0.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: fluidattacks_zoho_sdk
+Version: 1.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: pure-requests >=3.0.0, <4.0.0

fluidattacks_zoho_sdk-1.0.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+fluidattacks_zoho_sdk/__init__.py,sha256=gJQK6zYoY-Lb4Z7_DeCB5U1U7YvfKqoGLqnpLTK65cA,146
+fluidattacks_zoho_sdk/_decoders.py,sha256=-el9TJI9n6pE2bmwuYK22V9iZa14QyKclw6SkbPpB_g,5272
+fluidattacks_zoho_sdk/ids.py,sha256=mWqttCK4__D5TWayl_vf7q_H8zHSxSCcYuAIqD6K2sA,837
+fluidattacks_zoho_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fluidattacks_zoho_sdk/auth/__init__.py,sha256=jHqC0muxwU-loTAtd4n94tyoBUfRjXuLHKyePWxZjzE,901
+fluidattacks_zoho_sdk/auth/_access.py,sha256=JTF8qUvTMvkwDOAn_m-vIyssteEzOM_INR_sxWoQ_24,2229
+fluidattacks_zoho_sdk/auth/_core.py,sha256=-r-yYX6M5ocNjqnYJkZEO8gLLiyPg-bWGU4wrdCVl7I,738
+fluidattacks_zoho_sdk/auth/_decode.py,sha256=oYxxSABGOrVGUHiWGhGTmKMqHTCiw_PR-EVymAKly3Q,1552
+fluidattacks_zoho_sdk/auth/_refresh.py,sha256=Tgfy7K4SbuGW4uFB-kWNJAa8pdz4rjs0vV-WKSP6sRg,3031
+fluidattacks_zoho_sdk/auth/_revoke.py,sha256=Urv3fY0kOSAKArImz-C5EDIe44cm_L5ZNjkYxIWqL2E,2412
+fluidattacks_zoho_sdk/zoho_desk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fluidattacks_zoho_sdk/zoho_desk/_decode.py,sha256=E7nthNHKHtsVgnPtnhU1xahCs2Aza6ajPO2jjUNhkTU,6387
+fluidattacks_zoho_sdk/zoho_desk/core.py,sha256=3ItHmjEGhl86G0sF1X440KbwWtIKB0-dGIiSjVxfrcA,2215
+fluidattacks_zoho_sdk-1.0.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+fluidattacks_zoho_sdk-1.0.0.dist-info/METADATA,sha256=wGlydBuRr-CcAsCF0W3QagY3qrmK02tLP-7SLdMVEDM,305
+fluidattacks_zoho_sdk-1.0.0.dist-info/RECORD,,

fluidattacks_zoho_sdk-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.12.0
+Root-Is-Purelib: true
+Tag: py3-none-any