@zenify-omni/chat-js 0.1.0

package/api/session.js

@@ -0,0 +1,249 @@
+import { requestApi, requestAuthApi } from "../utils/request.js";
+import { getDeviceId, getUser } from "../utils/auth.js";
+const LOGIN_ENDPOINT = "/auth/login";
+const SDK_SIGN_IN_ENDPOINT = "/auth/sdk/sign-in";
+const LOGOUT_ENDPOINT = "/auth/logout";
+const LEGACY_LOGOUT_ENDPOINT = "/v2/logout";
+const LEGACY_LOGIN_ENDPOINT = "/v2/login";
+const LEGACY_TTL_IN_SECOND = 2592e3;
+const CREDENTIAL_REJECTION_STATUSES = /* @__PURE__ */ new Set([400, 401, 403, 422, 429]);
+const errorStatus = (error) => error?.status ?? error?.statusCode;
+const isAuthServiceUnavailable = (error) => {
+  const status = errorStatus(error);
+  if (status === void 0 || status === null) return true;
+  if (CREDENTIAL_REJECTION_STATUSES.has(status)) return false;
+  return status === 404 || status === 408 || status >= 500;
+};
+const legacyLogin = ({ domain, email, password }) => requestApi({
+  isPublicApi: true,
+  method: "post",
+  endpoint: LEGACY_LOGIN_ENDPOINT,
+  data: { domain, email, password, ttl_in_second: LEGACY_TTL_IN_SECOND }
+});
+const DEFAULT_SDK_TTL_SECONDS = 7 * 24 * 60 * 60;
+const signInWithApiKey = async ({
+  email,
+  apiKey,
+  ttlInSecond = DEFAULT_SDK_TTL_SECONDS
+}) => requestAuthApi({
+  method: "post",
+  endpoint: SDK_SIGN_IN_ENDPOINT,
+  customHeaders: { "api-key": apiKey },
+  data: { email, ttl_in_second: ttlInSecond }
+});
+const login = async (credentials) => {
+  const { domain, email, password } = credentials;
+  try {
+    return await requestAuthApi({
+      method: "post",
+      endpoint: LOGIN_ENDPOINT,
+      data: {
+        domain,
+        email,
+        password,
+        // Selects the web timeout pair + the web access-token TTL server-side.
+        device_type: "web",
+        // One id per browser, so N tabs share ONE session row.
+        device_id: getDeviceId()
+      }
+    });
+  } catch (error) {
+    if (!isAuthServiceUnavailable(error)) throw error;
+    console.warn(
+      "[auth] POST /auth/login unavailable \u2014 falling back to legacy POST /v2/login",
+      {
+        status: errorStatus(error),
+        code: error?.code,
+        message: error?.message
+      }
+    );
+    return legacyLogin({ domain, email, password });
+  }
+};
+const authHeader = () => {
+  const user = getUser();
+  return { Authorization: `Bearer ${user?.token}` };
+};
+const listMySessions = () => requestAuthApi({
+  method: "get",
+  endpoint: "/auth/sessions",
+  customHeaders: authHeader()
+});
+const updateCurrentSessionAppVersion = (version) => requestAuthApi({
+  method: "post",
+  endpoint: "/auth/sessions/current/app-version",
+  timeout: 3e3,
+  customHeaders: { ...authHeader(), "x-app-version": version }
+});
+const revokeMySession = (sid) => requestAuthApi({
+  method: "delete",
+  endpoint: `/auth/sessions/${sid}`,
+  customHeaders: authHeader()
+});
+const listUserSessions = (userId) => requestAuthApi({
+  method: "get",
+  endpoint: `/auth/admin/users/${userId}/sessions`,
+  customHeaders: authHeader()
+});
+const revokeUserSession = (userId, sid) => requestAuthApi({
+  method: "delete",
+  endpoint: `/auth/admin/users/${userId}/sessions/${sid}`,
+  customHeaders: authHeader()
+});
+const forceLogoutUser = (userId) => requestAuthApi({
+  method: "post",
+  endpoint: `/auth/admin/users/${userId}/logout-all`,
+  customHeaders: authHeader()
+});
+const adminSessionTrace = (userId, { from, to } = {}) => {
+  const params = {};
+  if (from) params.from = from;
+  if (to) params.to = to;
+  return requestAuthApi({
+    method: "get",
+    endpoint: `/auth/admin/users/${userId}/session-trace`,
+    params: Object.keys(params).length ? params : void 0,
+    customHeaders: authHeader()
+  });
+};
+const getOnlineUserList = ({
+  tenantId,
+  limit,
+  offset,
+  q,
+  activityBucket
+} = {}) => {
+  const params = {};
+  if (tenantId) params.tenant_id = tenantId;
+  if (limit !== void 0) params.limit = limit;
+  if (offset !== void 0) params.offset = offset;
+  if (q) params.q = q;
+  if (activityBucket) params.activity_bucket = activityBucket;
+  return requestAuthApi({
+    method: "get",
+    endpoint: "/auth/admin/online-user-list",
+    params: Object.keys(params).length ? params : void 0,
+    customHeaders: authHeader()
+  });
+};
+const getOnlineCounts = () => requestAuthApi({
+  method: "get",
+  endpoint: "/auth/admin/online-users",
+  customHeaders: authHeader()
+});
+const getSuperAdmins = () => requestAuthApi({
+  method: "get",
+  endpoint: "/auth/admin/superadmins",
+  customHeaders: authHeader()
+});
+const getSessionTimeline = ({ range } = {}) => requestAuthApi({
+  method: "get",
+  endpoint: "/auth/admin/session-timeline",
+  params: range ? { range } : void 0,
+  customHeaders: authHeader()
+});
+const getSessionPolicy = (tenantId) => requestAuthApi({
+  method: "get",
+  endpoint: "/auth/admin/session-policy",
+  params: { tenant_id: tenantId },
+  customHeaders: authHeader()
+});
+const updateSessionPolicy = (tenantId, rules) => requestAuthApi({
+  method: "put",
+  endpoint: "/auth/admin/session-policy",
+  data: { tenant_id: tenantId, rules },
+  customHeaders: authHeader()
+});
+const getMyTenantSessionPolicy = () => requestAuthApi({
+  method: "get",
+  endpoint: "/auth/session-policy",
+  customHeaders: authHeader()
+});
+const updateMyTenantSessionPolicy = (rules) => requestAuthApi({
+  method: "put",
+  endpoint: "/auth/session-policy",
+  data: { rules },
+  customHeaders: authHeader()
+});
+const tenantListUserSessions = (userId) => requestAuthApi({
+  method: "get",
+  endpoint: `/auth/users/${userId}/sessions`,
+  customHeaders: authHeader()
+});
+const tenantRevokeUserSession = (userId, sid) => requestAuthApi({
+  method: "delete",
+  endpoint: `/auth/users/${userId}/sessions/${sid}`,
+  customHeaders: authHeader()
+});
+const tenantForceLogoutUser = (userId) => requestAuthApi({
+  method: "post",
+  endpoint: `/auth/users/${userId}/logout-all`,
+  customHeaders: authHeader()
+});
+const tenantSessionTrace = (userId, { from, to } = {}) => {
+  const params = {};
+  if (from) params.from = from;
+  if (to) params.to = to;
+  return requestAuthApi({
+    method: "get",
+    endpoint: `/auth/users/${userId}/session-trace`,
+    params: Object.keys(params).length ? params : void 0,
+    customHeaders: authHeader()
+  });
+};
+const updateSessionLimits = (tenantId, limits) => requestAuthApi({
+  method: "put",
+  endpoint: "/auth/admin/session-limits",
+  data: { tenant_id: tenantId, ...limits },
+  customHeaders: authHeader()
+});
+const forceLogoutTenant = (tenantId) => requestAuthApi({
+  method: "post",
+  endpoint: `/auth/admin/tenants/${tenantId}/logout-all`,
+  customHeaders: authHeader()
+});
+const logoutSession = () => {
+  const user = getUser();
+  const token = user?.token;
+  if (!token) return Promise.resolve();
+  if (!user.refresh_token) {
+    return requestApi({
+      method: "get",
+      endpoint: LEGACY_LOGOUT_ENDPOINT,
+      customHeaders: { Authorization: token }
+    });
+  }
+  return requestAuthApi({
+    method: "post",
+    endpoint: LOGOUT_ENDPOINT,
+    data: { refresh_token: user.refresh_token },
+    customHeaders: { Authorization: `Bearer ${token}` }
+  });
+};
+export {
+  DEFAULT_SDK_TTL_SECONDS,
+  adminSessionTrace,
+  forceLogoutTenant,
+  forceLogoutUser,
+  getMyTenantSessionPolicy,
+  getOnlineCounts,
+  getOnlineUserList,
+  getSessionPolicy,
+  getSessionTimeline,
+  getSuperAdmins,
+  listMySessions,
+  listUserSessions,
+  login,
+  logoutSession,
+  revokeMySession,
+  revokeUserSession,
+  signInWithApiKey,
+  tenantForceLogoutUser,
+  tenantListUserSessions,
+  tenantRevokeUserSession,
+  tenantSessionTrace,
+  updateCurrentSessionAppVersion,
+  updateMyTenantSessionPolicy,
+  updateSessionLimits,
+  updateSessionPolicy
+};

package/api/settings/assign-task.js

@@ -0,0 +1,10 @@
+import { requestHubApi } from "../../utils/request.js";
+function getAssignTaskPolicy({ id }) {
+  return requestHubApi({
+    method: "get",
+    endpoint: `/api/v3/assignment-policies/${id}`
+  });
+}
+export {
+  getAssignTaskPolicy
+};

package/api/settings/channel.js

@@ -0,0 +1,136 @@
+import { requestApi, requestZaloApi } from "../../utils/request.js";
+import { env } from "../../config/env.js";
+const getPages = ({ params }) => requestApi({
+  method: "get",
+  endpoint: `/v2/social/pages`,
+  params
+});
+const getPageDetail = (pageId) => requestApi({
+  method: "get",
+  endpoint: `/v2/social/pages/${pageId}`
+});
+function getEmail({ params }) {
+  return requestApi({
+    method: "get",
+    endpoint: "/v2/email/accounts",
+    params
+  });
+}
+function getZNS({ params }) {
+  return requestApi({
+    method: "get",
+    endpoint: "/v2/zalo/zns/templates",
+    params
+  });
+}
+function getSMS({ params }) {
+  return requestApi({
+    method: "get",
+    endpoint: "/v2/sms",
+    params
+  });
+}
+function getZaloLoginQr(id, type) {
+  return requestZaloApi({
+    method: "get",
+    endpoint: type === "general" ? "/zalo-general/gen-qr-login" : "/gen-qr-login",
+    params: {
+      id,
+      type
+    }
+  });
+}
+function addFriendZalo({
+  user_id,
+  phone,
+  first_message,
+  old_ticket_id,
+  customer_id,
+  zalo_user_id,
+  page_id
+}) {
+  return requestZaloApi({
+    method: "post",
+    endpoint: `/send-friend-request/${user_id}`,
+    data: {
+      phone,
+      first_message,
+      old_ticket_id,
+      customer_id,
+      zalo_user_id,
+      source_id: page_id
+    }
+  });
+}
+function sendMessageZalo({
+  user_id,
+  phone,
+  first_message,
+  old_ticket_id,
+  page_id,
+  user_zalo_id,
+  is_group
+}) {
+  return requestZaloApi({
+    method: "post",
+    endpoint: `/send-message`,
+    data: {
+      phone,
+      first_message,
+      old_ticket_id,
+      source_id: page_id,
+      user_zalo_id,
+      is_group
+    }
+  });
+}
+function findUserZalo({ user_id, phone, zalo_customer_id, page_id }) {
+  return requestZaloApi({
+    method: "post",
+    endpoint: `/find-user/${user_id}`,
+    data: {
+      phone,
+      zalo_customer_id,
+      source_id: page_id
+    }
+  });
+}
+function getZaloLoginStatus(sessionId, type, options = {}) {
+  return requestZaloApi({
+    method: "get",
+    endpoint: type === "general" ? `/zalo-general/get-login-status/${sessionId}` : `/get-login-status/${sessionId}`,
+    ...options
+  });
+}
+const hubOttUrl = () => `${env.HUB_URL || "https://apihub.zenify.vn"}/api/v3`;
+function getZalosAllocated({
+  user_id,
+  agent_id,
+  tenant_id,
+  page_id,
+  customer_id
+}) {
+  return requestZaloApi({
+    method: "post",
+    endpoint: `/get-zalos-allocated/${user_id}`,
+    data: {
+      agent_id,
+      tenant_id,
+      page_id,
+      customer_id
+    }
+  });
+}
+export {
+  addFriendZalo,
+  findUserZalo,
+  getEmail,
+  getPageDetail,
+  getPages,
+  getSMS,
+  getZNS,
+  getZaloLoginQr,
+  getZaloLoginStatus,
+  getZalosAllocated,
+  sendMessageZalo
+};

package/api/settings/chat-layout.js

@@ -0,0 +1,37 @@
+import { requestApi } from "../../utils/request.js";
+const getChatLayouts = (params) => requestApi({
+  method: "get",
+  endpoint: "/v2/chat-layouts/filter",
+  params
+});
+const getChatConfigs = (workspaceId) => requestApi({
+  method: "get",
+  endpoint: "/v2/chat-configs",
+  params: { workspace_id: workspaceId }
+});
+const getChatLayout = (id) => requestApi({
+  method: "get",
+  endpoint: `/v2/chat-layouts/${id}`
+});
+const createChatLayout = (data) => requestApi({
+  method: "post",
+  endpoint: "/v2/chat-layouts",
+  data
+});
+const updateChatLayout = (id, data) => requestApi({
+  method: "put",
+  endpoint: `/v2/chat-layouts/${id}`,
+  data
+});
+const deleteChatLayout = (id) => requestApi({
+  method: "delete",
+  endpoint: `/v2/chat-layouts/${id}`
+});
+export {
+  createChatLayout,
+  deleteChatLayout,
+  getChatConfigs,
+  getChatLayout,
+  getChatLayouts,
+  updateChatLayout
+};

package/api/settings/chat-timeout.js

@@ -0,0 +1,10 @@
+import { requestHubApi } from "../../utils/request.js";
+function getChatTimeoutConfig({ channelType }) {
+  return requestHubApi({
+    method: "get",
+    endpoint: `/api/v3/chat-timeout/${channelType}`
+  }).then(({ data }) => data);
+}
+export {
+  getChatTimeoutConfig
+};

package/api/settings/common.js

@@ -0,0 +1,32 @@
+import { requestApi } from "../../utils/request.js";
+const getSettingCommon = ({ params }) => requestApi({
+  method: "get",
+  endpoint: `/v2/setting-common`,
+  params
+});
+const getSettingDashboard = ({ params }) => requestApi({
+  method: "get",
+  endpoint: "/v2/setting-dashboard"
+});
+const settingUserConfig = ({ data }) => requestApi({
+  method: "post",
+  endpoint: `/v2/setting-user-config`,
+  data
+});
+const getSettingUserConfig = () => requestApi({
+  method: "get",
+  endpoint: `/v2/setting-user-config`
+});
+const searchGlobal = ({ params, data }) => requestApi({
+  method: "post",
+  endpoint: `/v2/global-search`,
+  params,
+  data
+});
+export {
+  getSettingCommon,
+  getSettingDashboard,
+  getSettingUserConfig,
+  searchGlobal,
+  settingUserConfig
+};

package/api/settings/config.js

@@ -0,0 +1,19 @@
+import { requestApi } from "../../utils/request.js";
+const getConfigs = (params) => {
+  return requestApi({
+    method: "get",
+    endpoint: "/v2/settings/configs",
+    params
+  });
+};
+const createOrUpdateConfig = (data) => {
+  return requestApi({
+    method: "put",
+    endpoint: "/v2/settings/config",
+    data
+  });
+};
+export {
+  createOrUpdateConfig,
+  getConfigs
+};

package/api/settings/index.js

@@ -0,0 +1,24 @@
+import * as assignTask from "./assign-task.js";
+import * as channel from "./channel.js";
+import * as chatLayout from "./chat-layout.js";
+import * as chatTimeout from "./chat-timeout.js";
+import * as common from "./common.js";
+import * as config from "./config.js";
+import * as ivr from "./ivr.js";
+import * as queueV3 from "./queue-v3.js";
+import * as queue from "./queue.js";
+import * as routing from "./routing.js";
+import * as service from "./service.js";
+export {
+  assignTask,
+  channel,
+  chatLayout,
+  chatTimeout,
+  common,
+  config,
+  ivr,
+  queue,
+  queueV3,
+  routing,
+  service
+};

package/api/settings/ivr.js

@@ -0,0 +1,25 @@
+import { requestApi } from "../../utils/request.js";
+function getState(cpId) {
+  return requestApi({
+    method: "get",
+    endpoint: "/v2/ivr-config/states/" + cpId
+  });
+}
+function getStateTypes() {
+  return requestApi({
+    method: "get",
+    endpoint: "/v2/ivr-config/state-types"
+  });
+}
+function getAudio(params) {
+  return requestApi({
+    method: "get",
+    endpoint: "/v2/ivr/audio",
+    params
+  });
+}
+export {
+  getAudio,
+  getState,
+  getStateTypes
+};

package/api/settings/queue-v3.js

@@ -0,0 +1,56 @@
+import { requestHubApi } from "../../utils/request.js";
+function getQueue({ params }) {
+  return requestHubApi({
+    method: "get",
+    endpoint: "/api/v3/queues/filter",
+    params
+  }).then(({ data }) => data);
+}
+function getQueueDetail({ id }) {
+  return requestHubApi({
+    method: "get",
+    endpoint: `/api/v3/queues/${id}`
+  }).then(({ data }) => data);
+}
+function createQueue({ data }) {
+  return requestHubApi({
+    method: "post",
+    endpoint: "/api/v3/queues",
+    data
+  }).then(({ data: data2 }) => data2);
+}
+function editQueue({ id, data }) {
+  return requestHubApi({
+    method: "put",
+    endpoint: `/api/v3/queues/${id}`,
+    data
+  }).then(({ data: data2 }) => data2);
+}
+function deleteQueue({ id }) {
+  return requestHubApi({
+    method: "delete",
+    endpoint: `/api/v3/queues/${id}`
+  }).then(({ data }) => data);
+}
+function getParamsInQueue({ id }) {
+  return requestHubApi({
+    method: "get",
+    endpoint: `/api/v3/queue-params/by-queue/${id}`
+  });
+}
+function getUsersInQueues({ queueIds }) {
+  return requestHubApi({
+    method: "get",
+    endpoint: "/api/v3/queues/users-in-queues",
+    params: { queue_ids: queueIds.join(",") }
+  });
+}
+export {
+  createQueue,
+  deleteQueue,
+  editQueue,
+  getParamsInQueue,
+  getQueue,
+  getQueueDetail,
+  getUsersInQueues
+};

package/api/settings/queue.js

@@ -0,0 +1,48 @@
+import { requestApi } from "../../utils/request.js";
+function getQueue({ params }) {
+  return requestApi({
+    method: "get",
+    endpoint: "/v2/queues",
+    params
+  });
+}
+function createQueue({ data }) {
+  return requestApi({
+    method: "post",
+    endpoint: "/v2/queue",
+    data
+  });
+}
+function editQueue({ id, data }) {
+  return requestApi({
+    method: "put",
+    endpoint: `/v2/queue/${id}`,
+    data
+  });
+}
+function deleteQueue({ id }) {
+  return requestApi({
+    method: "delete",
+    endpoint: `/v2/queue/${id}`
+  });
+}
+function getAgentInQueue({ id }) {
+  return requestApi({
+    method: "get",
+    endpoint: `/v2/agent-in-queue/${id}`
+  });
+}
+function getParamsInQueue({ id }) {
+  return requestApi({
+    method: "get",
+    endpoint: `/v2/all-param?queue_id=${id}`
+  });
+}
+export {
+  createQueue,
+  deleteQueue,
+  editQueue,
+  getAgentInQueue,
+  getParamsInQueue,
+  getQueue
+};

package/api/settings/routing.js

@@ -0,0 +1,32 @@
+import { requestHubApi } from "../../utils/request.js";
+function getTenantConfigs({ keys }) {
+  return requestHubApi({
+    method: "get",
+    endpoint: "/api/v3/tenant-configs",
+    params: { keys, type: "CONFIG" }
+  }).then(({ data }) => data);
+}
+function updateTenantConfig(configs) {
+  return requestHubApi({
+    method: "put",
+    endpoint: "/api/v3/tenant-configs",
+    data: {
+      items: configs.map(({ key, rules }) => ({
+        key,
+        type: "CONFIG",
+        rules
+      }))
+    }
+  }).then(({ data }) => data);
+}
+async function getRoutingRuleDetail({ id }) {
+  return requestHubApi({
+    method: "get",
+    endpoint: `/api/v3/routing-rules/${id}`
+  }).then(({ data }) => data);
+}
+export {
+  getRoutingRuleDetail,
+  getTenantConfigs,
+  updateTenantConfig
+};