@ohos-ports/zca-js 2.2.0-beta.1

package/dist/apis/deleteCatalog.js

@@ -0,0 +1,28 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const deleteCatalogFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.catalog[0]}/api/prodcatalog/catalog/delete`);
+    /**
+     * Delete catalog?
+     *
+     * @param catalogId catalog id
+     *
+     * @note this API is used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function deleteCatalog(catalogId) {
+        const params = {
+            catalog_id: catalogId,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/deleteChat.d.ts

@@ -0,0 +1,19 @@
+import { ThreadType } from "../models/index.js";
+export type DeleteChatResponse = {
+    status: number;
+};
+export type DeleteChatLastMessage = {
+    /**
+     * Last message owner ID to delete backwards
+     */
+    ownerId: string;
+    /**
+     * Last message client ID to delete backwards
+     */
+    cliMsgId: string;
+    /**
+     * Last message global ID to delete backwards
+     */
+    globalMsgId: string;
+};
+export declare const deleteChatFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (lastMessage: DeleteChatLastMessage, threadId: string, type?: ThreadType) => Promise<DeleteChatResponse>;

package/dist/apis/deleteChat.js

@@ -0,0 +1,50 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { ThreadType } from "../models/index.js";
+import { apiFactory } from "../utils.js";
+export const deleteChatFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = {
+        [ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.chat[0]}/api/message/deleteconver`, {
+            nretry: 0,
+        }),
+        [ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/deleteconver`, {
+            nretry: 0,
+        }),
+    };
+    /**
+     * Delete chat
+     *
+     * @param lastMessage Last message info
+     * @param threadId Thread ID
+     * @param type Thread type
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function deleteChat(lastMessage, threadId, type = ThreadType.User) {
+        const timestampString = Date.now().toString();
+        const params = type === ThreadType.User
+            ? {
+                toid: threadId,
+                cliMsgId: timestampString,
+                conver: lastMessage,
+                onlyMe: 1,
+                imei: ctx.imei,
+            }
+            : {
+                grid: threadId,
+                cliMsgId: timestampString,
+                conver: lastMessage,
+                onlyMe: 1,
+                imei: ctx.imei,
+            };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL[type], {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/deleteGroupInviteBox.d.ts

@@ -0,0 +1,9 @@
+export type DeleteGroupInviteBoxResponse = {
+    delInvitaionIds: string[];
+    errMap: {
+        [groupId: string]: {
+            err: number;
+        };
+    };
+};
+export declare const deleteGroupInviteBoxFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (groupId: string | string[], blockFutureInvite?: boolean) => Promise<DeleteGroupInviteBoxResponse>;

package/dist/apis/deleteGroupInviteBox.js

@@ -0,0 +1,27 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const deleteGroupInviteBoxFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/inv-box/mdel-inv`);
+    /**
+     * Delete group invite box
+     *
+     * @param groupId - The group id
+     * @param blockFutureInvite - Whether to block future invites from this group
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function deleteGroupInviteBox(groupId, blockFutureInvite = false) {
+        const grids = Array.isArray(groupId) ? groupId : [groupId];
+        const params = {
+            invitations: JSON.stringify(grids.map((grid) => ({ grid }))),
+            block: blockFutureInvite ? 1 : 0,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/deleteMessage.d.ts

@@ -0,0 +1,14 @@
+import { ThreadType } from "../models/index.js";
+export type DeleteMessageResponse = {
+    status: number;
+};
+export type DeleteMessageDestination = {
+    data: {
+        cliMsgId: string;
+        msgId: string;
+        uidFrom: string;
+    };
+    threadId: string;
+    type?: ThreadType;
+};
+export declare const deleteMessageFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (dest: DeleteMessageDestination, onlyMe?: boolean) => Promise<DeleteMessageResponse>;

package/dist/apis/deleteMessage.js

@@ -0,0 +1,52 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { ThreadType } from "../models/index.js";
+import { apiFactory } from "../utils.js";
+export const deleteMessageFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = {
+        [ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.chat[0]}/api/message/delete`),
+        [ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/deletemsg`),
+    };
+    /**
+     * Delete a message
+     *
+     * @param dest Delete target
+     * @param onlyMe Delete message for only you
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function deleteMessage(dest, onlyMe = false) {
+        const { threadId, type = ThreadType.User, data } = dest;
+        const isGroup = type === ThreadType.Group;
+        const isSelf = ctx.uid == data.uidFrom;
+        if (isSelf && onlyMe === false)
+            throw new ZaloApiError("To delete your message for everyone, use undo api instead");
+        if (!isGroup && onlyMe === false)
+            throw new ZaloApiError("Can't delete message for everyone in a private chat");
+        const params = {
+            [isGroup ? "grid" : "toid"]: threadId,
+            cliMsgId: Date.now(),
+            msgs: [
+                {
+                    cliMsgId: data.cliMsgId,
+                    globalMsgId: data.msgId,
+                    ownerId: data.uidFrom,
+                    destId: threadId,
+                },
+            ],
+            onlyMe: onlyMe ? 1 : 0,
+        };
+        if (!isGroup) {
+            params.imei = ctx.imei;
+        }
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt message");
+        const response = await utils.request(serviceURL[type], {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/deleteProductCatalog.d.ts

@@ -0,0 +1,10 @@
+export type DeleteProductCatalogPayload = {
+    productIds: string | string[];
+    catalogId: string;
+};
+export type DeleteProductCatalogResponse = {
+    item: number[];
+    version_ls_catalog: number;
+    version_catalog: number;
+};
+export declare const deleteProductCatalogFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (payload: DeleteProductCatalogPayload) => Promise<DeleteProductCatalogResponse>;

package/dist/apis/deleteProductCatalog.js

@@ -0,0 +1,31 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const deleteProductCatalogFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.catalog[0]}/api/prodcatalog/product/mdelete`);
+    /**
+     * Delete product catalog?
+     *
+     * @param payload payload
+     *
+     * @note this API is used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function deleteProductCatalog(payload) {
+        if (!Array.isArray(payload.productIds))
+            payload.productIds = [payload.productIds];
+        const params = {
+            product_ids: payload.productIds,
+            catalog_id: payload.catalogId,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/disableGroupLink.d.ts

@@ -0,0 +1,2 @@
+export type DisableGroupLinkResponse = "";
+export declare const disableGroupLinkFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (groupId: string) => Promise<"">;

package/dist/apis/disableGroupLink.js

@@ -0,0 +1,24 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const disableGroupLinkFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/link/disable`);
+    /**
+     * Disable group link
+     *
+     * @param groupId The group id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function disableGroupLink(groupId) {
+        const params = {
+            grid: groupId,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/disperseGroup.d.ts

@@ -0,0 +1,2 @@
+export type DisperseGroupResponse = "";
+export declare const disperseGroupFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (groupId: string) => Promise<"">;

package/dist/apis/disperseGroup.js

@@ -0,0 +1,28 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const disperseGroupFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/disperse`);
+    /**
+     * Disperse Group
+     *
+     * @param groupId Group ID to disperse Group from
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function disperseGroup(groupId) {
+        const params = {
+            grid: groupId,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/editNote.d.ts

@@ -0,0 +1,17 @@
+import type { NoteDetail } from "../models/index.js";
+export type EditNoteOptions = {
+    /**
+     * New note title
+     */
+    title: string;
+    /**
+     * Topic ID to edit note from
+     */
+    topicId: string;
+    /**
+     * Should the note be pinned?
+     */
+    pinAct?: boolean;
+};
+export type EditNoteResponse = NoteDetail;
+export declare const editNoteFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (options: EditNoteOptions, groupId: string) => Promise<NoteDetail>;

package/dist/apis/editNote.js

@@ -0,0 +1,46 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const editNoteFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/topic/updatev2`);
+    /**
+     * Edit an existing note in a group
+     *
+     * @param options Options for editing the note
+     * @param groupId Group ID to create note from
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function editNote(options, groupId) {
+        const params = {
+            grid: groupId,
+            type: 0,
+            color: -16777216,
+            emoji: "",
+            startTime: -1,
+            duration: -1,
+            params: JSON.stringify({
+                title: options.title,
+            }),
+            topicId: options.topicId,
+            repeat: 0,
+            imei: ctx.imei,
+            pinAct: options.pinAct ? 1 : 2,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response, (result) => {
+            const data = result.data;
+            if (typeof data.params == "string") {
+                data.params = JSON.parse(data.params);
+            }
+            return data;
+        });
+    };
+});

package/dist/apis/editReminder.d.ts

@@ -0,0 +1,13 @@
+import type { ReminderRepeatMode, ReminderGroup, ReminderUser } from "../models/index.js";
+import { ThreadType } from "../models/index.js";
+export type EditReminderOptions = {
+    title: string;
+    topicId: string;
+    emoji?: string;
+    startTime?: number;
+    repeat?: ReminderRepeatMode;
+};
+export type EditReminderUser = ReminderUser;
+export type EditReminderGroup = Omit<ReminderGroup, "responseMem">;
+export type EditReminderResponse = EditReminderUser | EditReminderGroup;
+export declare const editReminderFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (options: EditReminderOptions, threadId: string, type?: ThreadType) => Promise<EditReminderResponse>;

package/dist/apis/editReminder.js

@@ -0,0 +1,61 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { ThreadType } from "../models/index.js";
+import { apiFactory } from "../utils.js";
+export const editReminderFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = {
+        [ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/oneone/update`),
+        [ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/topic/updatev2`),
+    };
+    /**
+     * Edit an existing reminder
+     *
+     * @param options Reminder parameters
+     * @param threadId Thread ID
+     * @param type Thread type (User/Group)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function editReminder(options, threadId, type = ThreadType.User) {
+        var _a, _b, _c, _d, _e, _f;
+        const requestParams = type === ThreadType.User
+            ? {
+                objectData: JSON.stringify({
+                    toUid: threadId,
+                    type: 0,
+                    color: -16777216,
+                    emoji: (_a = options.emoji) !== null && _a !== void 0 ? _a : "",
+                    startTime: (_b = options.startTime) !== null && _b !== void 0 ? _b : Date.now(),
+                    duration: -1,
+                    params: { title: options.title },
+                    needPin: false,
+                    reminderId: options.topicId,
+                    repeat: (_c = options.repeat) !== null && _c !== void 0 ? _c : 0,
+                }),
+            }
+            : {
+                grid: threadId,
+                type: 0,
+                color: -16777216,
+                emoji: (_d = options.emoji) !== null && _d !== void 0 ? _d : "",
+                startTime: (_e = options.startTime) !== null && _e !== void 0 ? _e : Date.now(),
+                duration: -1,
+                params: JSON.stringify({
+                    title: options.title,
+                }),
+                topicId: options.topicId,
+                repeat: (_f = options.repeat) !== null && _f !== void 0 ? _f : 0,
+                imei: ctx.imei,
+                pinAct: 2,
+            };
+        const encryptedParams = utils.encodeAES(JSON.stringify(requestParams));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL[type], {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/enableGroupLink.d.ts

@@ -0,0 +1,6 @@
+export type EnableGroupLinkResponse = {
+    link: string;
+    expiration_date: number;
+    enabled: number;
+};
+export declare const enableGroupLinkFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (groupId: string) => Promise<EnableGroupLinkResponse>;

package/dist/apis/enableGroupLink.js

@@ -0,0 +1,25 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const enableGroupLinkFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/link/new`);
+    /**
+     * Enable and create new group link
+     *
+     * @param groupId The group id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function enableGroupLink(groupId) {
+        const params = {
+            grid: groupId,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/fetchAccountInfo.d.ts

@@ -0,0 +1,5 @@
+import type { User } from "../models/index.js";
+export type FetchAccountInfoResponse = {
+    profile: User;
+};
+export declare const fetchAccountInfoFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => () => Promise<FetchAccountInfoResponse>;

package/dist/apis/fetchAccountInfo.js

@@ -0,0 +1,10 @@
+import { apiFactory } from "../utils.js";
+export const fetchAccountInfoFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/profile/me-v2`);
+    return async function fetchAccountInfo() {
+        const response = await utils.request(serviceURL, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/findUser.d.ts

@@ -0,0 +1,3 @@
+import { AvatarSize, type UserBasic } from "../models/index.js";
+export type FindUserResponse = UserBasic;
+export declare const findUserFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (phoneNumber: string, avatarSize?: AvatarSize) => Promise<UserBasic>;

package/dist/apis/findUser.js

@@ -0,0 +1,42 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+import { AvatarSize } from "../models/index.js";
+export const findUserFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/profile/get`);
+    /**
+     * Find user by phone number
+     *
+     * @param phoneNumber Phone number
+     * @param avatarSize Avatar size (default: AvatarSize.Large)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function findUser(phoneNumber, avatarSize = AvatarSize.Large) {
+        if (!phoneNumber)
+            throw new ZaloApiError("Missing phoneNumber");
+        if (phoneNumber.startsWith("0")) {
+            if (ctx.language == "vi")
+                phoneNumber = "84" + phoneNumber.slice(1);
+        }
+        const params = {
+            phone: phoneNumber,
+            avatar_size: avatarSize,
+            language: ctx.language,
+            imei: ctx.imei,
+            reqSrc: 40,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt message");
+        const finalServiceUrl = new URL(serviceURL);
+        finalServiceUrl.searchParams.append("params", encryptedParams);
+        const response = await utils.request(utils.makeURL(finalServiceUrl.toString(), {
+            params: encryptedParams,
+        }));
+        return utils.resolve(response, (result) => {
+            if (result.error && result.error.code != 216)
+                throw new ZaloApiError(result.error.message, result.error.code);
+            return result.data;
+        });
+    };
+});

package/dist/apis/findUserByUsername.d.ts

@@ -0,0 +1,3 @@
+import { AvatarSize, type UserBasic } from "../models/index.js";
+export type FindUserByUsernameResponse = UserBasic;
+export declare const findUserByUsernameFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (username: string, avatarSize?: AvatarSize) => Promise<UserBasic>;

package/dist/apis/findUserByUsername.js

@@ -0,0 +1,27 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+import { AvatarSize } from "../models/index.js";
+export const findUserByUsernameFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/search/by-user-name`);
+    /**
+     * Find user by username
+     *
+     * @param username username for find
+     * @param avatarSize Avatar size (default: AvatarSize.Large)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function findUserByUsername(username, avatarSize = AvatarSize.Large) {
+        const params = {
+            user_name: username,
+            avatar_size: avatarSize,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/forwardMessage.d.ts

@@ -0,0 +1,24 @@
+import { ThreadType } from "../models/index.js";
+export type ForwardMessagePayload = {
+    message: string;
+    ttl?: number;
+    reference?: {
+        id: string;
+        ts: number;
+        logSrcType: number;
+        fwLvl: number;
+    };
+};
+export type ForwardMessageSuccess = {
+    clientId: string;
+    msgId: string;
+};
+export type ForwardMessageFail = {
+    clientId: string;
+    error_code: string;
+};
+export type ForwardMessageResponse = {
+    success: ForwardMessageSuccess[];
+    fail: ForwardMessageFail[];
+};
+export declare const forwardMessageFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (payload: ForwardMessagePayload, threadIds: string[], type?: ThreadType) => Promise<ForwardMessageResponse>;