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

package/dist/apis/addReaction.js

@@ -0,0 +1,294 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { ThreadType, Reactions } from "../models/index.js";
+import { apiFactory } from "../utils.js";
+export const addReactionFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURLs = {
+        [ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.reaction[0]}/api/message/reaction`),
+        [ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.reaction[0]}/api/group/reaction`),
+    };
+    /**
+     * Add reaction to a message
+     *
+     * @param icon Reaction icon
+     * @param dest Destination data including message IDs and thread information
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function addReaction(icon, dest) {
+        const serviceURL = serviceURLs[dest.type];
+        let rType, source;
+        if (typeof icon == "object") {
+            rType = icon.rType;
+            source = icon.source;
+        }
+        else
+            switch (icon) {
+                case Reactions.HAHA:
+                    rType = 0;
+                    source = 6;
+                    break;
+                case Reactions.LIKE:
+                    rType = 3;
+                    source = 6;
+                    break;
+                case Reactions.HEART:
+                    rType = 5;
+                    source = 6;
+                    break;
+                case Reactions.WOW:
+                    rType = 32;
+                    source = 6;
+                    break;
+                case Reactions.CRY:
+                    rType = 2;
+                    source = 6;
+                    break;
+                case Reactions.ANGRY:
+                    rType = 20;
+                    source = 6;
+                    break;
+                case Reactions.KISS:
+                    rType = 8;
+                    source = 6;
+                    break;
+                case Reactions.TEARS_OF_JOY:
+                    rType = 7;
+                    source = 6;
+                    break;
+                case Reactions.SHIT:
+                    rType = 66;
+                    source = 6;
+                    break;
+                case Reactions.ROSE:
+                    rType = 120;
+                    source = 6;
+                    break;
+                case Reactions.BROKEN_HEART:
+                    rType = 65;
+                    source = 6;
+                    break;
+                case Reactions.DISLIKE:
+                    rType = 4;
+                    source = 6;
+                    break;
+                case Reactions.LOVE:
+                    rType = 29;
+                    source = 6;
+                    break;
+                case Reactions.CONFUSED:
+                    rType = 51;
+                    source = 6;
+                    break;
+                case Reactions.WINK:
+                    rType = 45;
+                    source = 6;
+                    break;
+                case Reactions.FADE:
+                    rType = 121;
+                    source = 6;
+                    break;
+                case Reactions.SUN:
+                    rType = 67;
+                    source = 6;
+                    break;
+                case Reactions.BIRTHDAY:
+                    rType = 126;
+                    source = 6;
+                    break;
+                case Reactions.BOMB:
+                    rType = 127;
+                    source = 6;
+                    break;
+                case Reactions.OK:
+                    rType = 68;
+                    source = 6;
+                    break;
+                case Reactions.PEACE:
+                    rType = 69;
+                    source = 6;
+                    break;
+                case Reactions.THANKS:
+                    rType = 70;
+                    source = 6;
+                    break;
+                case Reactions.PUNCH:
+                    rType = 71;
+                    source = 6;
+                    break;
+                case Reactions.SHARE:
+                    rType = 72;
+                    source = 6;
+                    break;
+                case Reactions.PRAY:
+                    rType = 73;
+                    source = 6;
+                    break;
+                case Reactions.NO:
+                    rType = 131;
+                    source = 6;
+                    break;
+                case Reactions.BAD:
+                    rType = 132;
+                    source = 6;
+                    break;
+                case Reactions.LOVE_YOU:
+                    rType = 133;
+                    source = 6;
+                    break;
+                case Reactions.SAD:
+                    rType = 1;
+                    source = 6;
+                    break;
+                case Reactions.VERY_SAD:
+                    rType = 16;
+                    source = 6;
+                    break;
+                case Reactions.COOL:
+                    rType = 21;
+                    source = 6;
+                    break;
+                case Reactions.NERD:
+                    rType = 22;
+                    source = 6;
+                    break;
+                case Reactions.BIG_SMILE:
+                    rType = 23;
+                    source = 6;
+                    break;
+                case Reactions.SUNGLASSES:
+                    rType = 26;
+                    source = 6;
+                    break;
+                case Reactions.NEUTRAL:
+                    rType = 30;
+                    source = 6;
+                    break;
+                case Reactions.SAD_FACE:
+                    rType = 35;
+                    source = 6;
+                    break;
+                case Reactions.BYE:
+                    rType = 36;
+                    source = 6;
+                    break;
+                case Reactions.SLEEPY:
+                    rType = 38;
+                    source = 6;
+                    break;
+                case Reactions.WIPE:
+                    rType = 39;
+                    source = 6;
+                    break;
+                case Reactions.DIG:
+                    rType = 42;
+                    source = 6;
+                    break;
+                case Reactions.ANGUISH:
+                    rType = 44;
+                    source = 6;
+                    break;
+                case Reactions.HANDCLAP:
+                    rType = 46;
+                    source = 6;
+                    break;
+                case Reactions.ANGRY_FACE:
+                    rType = 47;
+                    source = 6;
+                    break;
+                case Reactions.F_CHAIR:
+                    rType = 48;
+                    source = 6;
+                    break;
+                case Reactions.L_CHAIR:
+                    rType = 49;
+                    source = 6;
+                    break;
+                case Reactions.R_CHAIR:
+                    rType = 50;
+                    source = 6;
+                    break;
+                case Reactions.SILENT:
+                    rType = 52;
+                    source = 6;
+                    break;
+                case Reactions.SURPRISE:
+                    rType = 53;
+                    source = 6;
+                    break;
+                case Reactions.EMBARRASSED:
+                    rType = 54;
+                    source = 6;
+                    break;
+                case Reactions.AFRAID:
+                    rType = 60;
+                    source = 6;
+                    break;
+                case Reactions.SAD2:
+                    rType = 61;
+                    source = 6;
+                    break;
+                case Reactions.BIG_LAUGH:
+                    rType = 62;
+                    source = 6;
+                    break;
+                case Reactions.RICH:
+                    rType = 63;
+                    source = 6;
+                    break;
+                case Reactions.BEER:
+                    rType = 99;
+                    source = 6;
+                    break;
+                default:
+                    rType = -1;
+                    source = 6;
+            }
+        const rIcon = typeof icon == "object" ? icon.icon : icon;
+        if (rType == undefined || source == undefined || rIcon == undefined) {
+            throw new ZaloApiError("Invalid reaction");
+        }
+        const params = {
+            react_list: [
+                {
+                    message: JSON.stringify({
+                        rMsg: [
+                            {
+                                gMsgID: parseInt(dest.data.msgId),
+                                cMsgID: parseInt(dest.data.cliMsgId),
+                                msgType: 1,
+                            },
+                        ],
+                        rIcon,
+                        rType,
+                        source,
+                    }),
+                    clientId: Date.now(),
+                },
+            ],
+        };
+        if (dest.type == ThreadType.User) {
+            params.toid = dest.threadId;
+        }
+        else {
+            params.grid = dest.threadId;
+            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, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response, (result) => {
+            if (typeof result.data.msgIds === "string") {
+                return {
+                    msgIds: JSON.parse(result.data.msgIds),
+                };
+            }
+            return result.data;
+        });
+    };
+});

package/dist/apis/addUnreadMark.d.ts

@@ -0,0 +1,8 @@
+import { ThreadType } from "../models/index.js";
+export type AddUnreadMarkResponse = {
+    data: {
+        updateId: number;
+    };
+    status: number;
+};
+export declare const addUnreadMarkFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (threadId: string, type?: ThreadType) => Promise<AddUnreadMarkResponse>;

package/dist/apis/addUnreadMark.js

@@ -0,0 +1,52 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { ThreadType } from "../models/index.js";
+import { apiFactory } from "../utils.js";
+export const addUnreadMarkFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.conversation[0]}/api/conv/addUnreadMark`);
+    /**
+     * Add unread mark to conversation
+     *
+     * @param threadId Thread ID
+     * @param type Thread type (User/Group)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function addUnreadMark(threadId, type = ThreadType.User) {
+        const timestamp = Date.now();
+        const timestampString = timestamp.toString();
+        const isGroup = type === ThreadType.Group;
+        const requestParams = {
+            param: JSON.stringify({
+                [isGroup ? "convsGroup" : "convsUser"]: [
+                    {
+                        id: threadId,
+                        cliMsgId: timestampString,
+                        fromUid: "0",
+                        ts: timestamp,
+                    },
+                ],
+                [isGroup ? "convsUser" : "convsGroup"]: [],
+                imei: ctx.imei,
+            }),
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(requestParams));
+        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.data === "string") {
+                return {
+                    data: JSON.parse(data.data),
+                    status: data.status,
+                };
+            }
+            return result.data;
+        });
+    };
+});

package/dist/apis/addUserToGroup.d.ts

@@ -0,0 +1,5 @@
+export type AddUserToGroupResponse = {
+    errorMembers: string[];
+    error_data: Record<string, string[]>;
+};
+export declare const addUserToGroupFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (memberId: string | string[], groupId: string) => Promise<AddUserToGroupResponse>;

package/dist/apis/addUserToGroup.js

@@ -0,0 +1,34 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const addUserToGroupFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/invite/v2`);
+    /**
+     * Add user to existing group
+     *
+     * @param memberId User ID or list of user IDs to add
+     * @param groupId Group ID
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function addUserToGroup(memberId, groupId) {
+        if (!Array.isArray(memberId))
+            memberId = [memberId];
+        const params = {
+            grid: groupId,
+            members: memberId,
+            memberTypes: memberId.map(() => -1),
+            imei: ctx.imei,
+            clientLang: ctx.language,
+        };
+        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/blockUser.d.ts

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

package/dist/apis/blockUser.js

@@ -0,0 +1,28 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const blockUserFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/block`);
+    /**
+     * Block a User
+     *
+     * @param userId The ID of the User to block
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function blockUser(userId) {
+        const params = {
+            fid: userId,
+            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/blockViewFeed.d.ts

@@ -0,0 +1,2 @@
+export type BlockViewFeedResponse = "";
+export declare const blockViewFeedFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (isBlockFeed: boolean, userId: string) => Promise<"">;

package/dist/apis/blockViewFeed.js

@@ -0,0 +1,30 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const blockViewFeedFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/feed/block`);
+    /**
+     * Block/Unblock friend view feed by ID
+     *
+     * @param isBlockFeed Boolean to block/unblock view feed
+     * @param userId User ID to block/unblock view feed
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function blockViewFeed(isBlockFeed, userId) {
+        const params = {
+            fid: userId,
+            isBlockFeed: isBlockFeed ? 1 : 0,
+            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/changeAccountAvatar.d.ts

@@ -0,0 +1,3 @@
+import type { AttachmentSource } from "../models/index.js";
+export type ChangeAccountAvatarResponse = "";
+export declare const changeAccountAvatarFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (avatarSource: AttachmentSource) => Promise<"">;

package/dist/apis/changeAccountAvatar.js

@@ -0,0 +1,52 @@
+import FormData from "form-data";
+import fs from "node:fs";
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory, formatTime, getImageMetaData } from "../utils.js";
+export const changeAccountAvatarFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.file[0]}/api/profile/upavatar`);
+    /**
+     * Change account avatar
+     *
+     * @param avatarSource Attachment source, can be a file path or an Attachment object
+     *
+     * @throws {ZaloApiError | ZaloApiMissingImageMetadataGetter}
+     */
+    return async function changeAccountAvatar(avatarSource) {
+        const isSourceFilePath = typeof avatarSource == "string";
+        const imageMetaData = isSourceFilePath ? await getImageMetaData(ctx, avatarSource) : avatarSource.metadata;
+        const fileSize = imageMetaData.totalSize || 0;
+        const params = {
+            avatarSize: 120,
+            clientId: String(ctx.uid + formatTime("%H:%M %d/%m/%Y")),
+            language: ctx.language,
+            metaData: JSON.stringify({
+                origin: {
+                    width: imageMetaData.width || 1080,
+                    height: imageMetaData.height || 1080,
+                },
+                processed: {
+                    width: imageMetaData.width || 1080,
+                    height: imageMetaData.height || 1080,
+                    size: fileSize,
+                },
+            }),
+        };
+        const avatarData = isSourceFilePath ? fs.readFileSync(avatarSource) : avatarSource.data;
+        const formData = new FormData();
+        formData.append("fileContent", avatarData, {
+            filename: "blob",
+            contentType: "image/jpeg",
+        });
+        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: "POST",
+            headers: formData.getHeaders(),
+            body: formData.getBuffer(),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/changeFriendAlias.d.ts

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

package/dist/apis/changeFriendAlias.js

@@ -0,0 +1,27 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const changeFriendAliasFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.alias[0]}/api/alias/update`);
+    /**
+     * Change friend's alias
+     *
+     * @param alias new alias (nickname - bietdanh)
+     * @param friendId friend id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function changeFriendAlias(alias, friendId) {
+        const params = {
+            friendId: friendId,
+            alias: alias,
+            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/changeGroupAvatar.d.ts

@@ -0,0 +1,3 @@
+import type { AttachmentSource } from "../models/index.js";
+export type ChangeGroupAvatarResponse = "";
+export declare const changeGroupAvatarFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (avatarSource: AttachmentSource, groupId: string) => Promise<"">;

package/dist/apis/changeGroupAvatar.js

@@ -0,0 +1,44 @@
+import FormData from "form-data";
+import fs from "node:fs";
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory, getFullTimeFromMillisecond, getImageMetaData } from "../utils.js";
+export const changeGroupAvatarFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.file[0]}/api/group/upavatar`);
+    /**
+     * Change group avatar
+     *
+     * @param avatarSource Attachment source, can be a file path or an Attachment object
+     * @param groupId Group ID
+     *
+     * @throws {ZaloApiError | ZaloApiMissingImageMetadataGetter}
+     */
+    return async function changeGroupAvatar(avatarSource, groupId) {
+        const params = {
+            grid: groupId,
+            avatarSize: 120,
+            clientId: `g${groupId}${getFullTimeFromMillisecond(new Date().getTime())}`,
+            imei: ctx.imei,
+        };
+        const isSourceFilePath = typeof avatarSource == "string";
+        const imageMetaData = isSourceFilePath ? await getImageMetaData(ctx, avatarSource) : avatarSource.metadata;
+        params.originWidth = imageMetaData.width || 1080;
+        params.originHeight = imageMetaData.height || 1080;
+        const avatarData = isSourceFilePath ? fs.readFileSync(avatarSource) : avatarSource.data;
+        const formData = new FormData();
+        formData.append("fileContent", avatarData, {
+            filename: "blob",
+            contentType: "image/jpeg",
+        });
+        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: "POST",
+            headers: formData.getHeaders(),
+            body: formData.getBuffer(),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/changeGroupName.d.ts

@@ -0,0 +1,4 @@
+export type ChangeGroupNameResponse = {
+    status: number;
+};
+export declare const changeGroupNameFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (name: string, groupId: string) => Promise<ChangeGroupNameResponse>;

package/dist/apis/changeGroupName.js

@@ -0,0 +1,32 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const changeGroupNameFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/updateinfo`);
+    /**
+     * Change group name
+     *
+     * @param name New group name
+     * @param groupId Group ID
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function changeGroupName(name, groupId) {
+        if (name.length == 0)
+            name = Date.now().toString();
+        const params = {
+            grid: groupId,
+            gname: name,
+            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/changeGroupOwner.d.ts

@@ -0,0 +1,4 @@
+export type ChangeGroupOwnerResponse = {
+    time: number;
+};
+export declare const changeGroupOwnerFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (memberId: string, groupId: string) => Promise<ChangeGroupOwnerResponse>;

package/dist/apis/changeGroupOwner.js

@@ -0,0 +1,30 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const changeGroupOwnerFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/change-owner`);
+    /**
+     * Change group owner
+     *
+     * @param memberId User Id of new group owner
+     * @param groupId Group Id
+     * @note Be careful when changing the key, as it will result in losing group admin rights
+     *
+     * @throws {ZaloApiError}
+     *
+     */
+    return async function changeGroupOwner(memberId, groupId) {
+        const params = {
+            grid: groupId,
+            newAdminId: memberId,
+            imei: ctx.imei,
+            language: ctx.language,
+        };
+        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);
+    };
+});