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

package/dist/cjs/apis/addReaction.cjs

@@ -0,0 +1,308 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+require('../models/AutoReply.cjs');
+require('../models/Bank.cjs');
+require('../models/Board.cjs');
+var Enum = require('../models/Enum.cjs');
+require('../models/FriendEvent.cjs');
+require('../models/Group.cjs');
+require('../models/GroupEvent.cjs');
+var Reaction = require('../models/Reaction.cjs');
+require('../models/Reminder.cjs');
+require('../models/ZBusiness.cjs');
+var utils = require('../utils.cjs');
+
+const addReactionFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURLs = {
+        [Enum.ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.reaction[0]}/api/message/reaction`),
+        [Enum.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 Reaction.Reactions.HAHA:
+                    rType = 0;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.LIKE:
+                    rType = 3;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.HEART:
+                    rType = 5;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.WOW:
+                    rType = 32;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.CRY:
+                    rType = 2;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.ANGRY:
+                    rType = 20;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.KISS:
+                    rType = 8;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.TEARS_OF_JOY:
+                    rType = 7;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.SHIT:
+                    rType = 66;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.ROSE:
+                    rType = 120;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.BROKEN_HEART:
+                    rType = 65;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.DISLIKE:
+                    rType = 4;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.LOVE:
+                    rType = 29;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.CONFUSED:
+                    rType = 51;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.WINK:
+                    rType = 45;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.FADE:
+                    rType = 121;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.SUN:
+                    rType = 67;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.BIRTHDAY:
+                    rType = 126;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.BOMB:
+                    rType = 127;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.OK:
+                    rType = 68;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.PEACE:
+                    rType = 69;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.THANKS:
+                    rType = 70;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.PUNCH:
+                    rType = 71;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.SHARE:
+                    rType = 72;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.PRAY:
+                    rType = 73;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.NO:
+                    rType = 131;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.BAD:
+                    rType = 132;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.LOVE_YOU:
+                    rType = 133;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.SAD:
+                    rType = 1;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.VERY_SAD:
+                    rType = 16;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.COOL:
+                    rType = 21;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.NERD:
+                    rType = 22;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.BIG_SMILE:
+                    rType = 23;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.SUNGLASSES:
+                    rType = 26;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.NEUTRAL:
+                    rType = 30;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.SAD_FACE:
+                    rType = 35;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.BYE:
+                    rType = 36;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.SLEEPY:
+                    rType = 38;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.WIPE:
+                    rType = 39;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.DIG:
+                    rType = 42;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.ANGUISH:
+                    rType = 44;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.HANDCLAP:
+                    rType = 46;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.ANGRY_FACE:
+                    rType = 47;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.F_CHAIR:
+                    rType = 48;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.L_CHAIR:
+                    rType = 49;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.R_CHAIR:
+                    rType = 50;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.SILENT:
+                    rType = 52;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.SURPRISE:
+                    rType = 53;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.EMBARRASSED:
+                    rType = 54;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.AFRAID:
+                    rType = 60;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.SAD2:
+                    rType = 61;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.BIG_LAUGH:
+                    rType = 62;
+                    source = 6;
+                    break;
+                case Reaction.Reactions.RICH:
+                    rType = 63;
+                    source = 6;
+                    break;
+                case Reaction.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.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 == Enum.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.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;
+        });
+    };
+});
+
+exports.addReactionFactory = addReactionFactory;

package/dist/cjs/apis/addUnreadMark.cjs

@@ -0,0 +1,66 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+require('../models/AutoReply.cjs');
+require('../models/Bank.cjs');
+require('../models/Board.cjs');
+var Enum = require('../models/Enum.cjs');
+require('../models/FriendEvent.cjs');
+require('../models/Group.cjs');
+require('../models/GroupEvent.cjs');
+require('../models/Reaction.cjs');
+require('../models/Reminder.cjs');
+require('../models/ZBusiness.cjs');
+var utils = require('../utils.cjs');
+
+const addUnreadMarkFactory = utils.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 = Enum.ThreadType.User) {
+        const timestamp = Date.now();
+        const timestampString = timestamp.toString();
+        const isGroup = type === Enum.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.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;
+        });
+    };
+});
+
+exports.addUnreadMarkFactory = addUnreadMarkFactory;

package/dist/cjs/apis/addUserToGroup.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const addUserToGroupFactory = utils.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.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.addUserToGroupFactory = addUserToGroupFactory;

package/dist/cjs/apis/blockUser.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const blockUserFactory = utils.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.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.blockUserFactory = blockUserFactory;

package/dist/cjs/apis/blockViewFeed.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const blockViewFeedFactory = utils.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.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.blockViewFeedFactory = blockViewFeedFactory;

package/dist/cjs/apis/changeAccountAvatar.cjs

@@ -0,0 +1,57 @@
+'use strict';
+
+var FormData = require('form-data');
+var fs = require('node:fs');
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const changeAccountAvatarFactory = utils.apiFactory()((api, ctx, utils$1) => {
+    const serviceURL = utils$1.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 utils.getImageMetaData(ctx, avatarSource) : avatarSource.metadata;
+        const fileSize = imageMetaData.totalSize || 0;
+        const params = {
+            avatarSize: 120,
+            clientId: String(ctx.uid + utils.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$1.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        const response = await utils$1.request(utils$1.makeURL(serviceURL, {
+            params: encryptedParams,
+        }), {
+            method: "POST",
+            headers: formData.getHeaders(),
+            body: formData.getBuffer(),
+        });
+        return utils$1.resolve(response);
+    };
+});
+
+exports.changeAccountAvatarFactory = changeAccountAvatarFactory;

package/dist/cjs/apis/changeFriendAlias.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const changeFriendAliasFactory = utils.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.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.changeFriendAliasFactory = changeFriendAliasFactory;

package/dist/cjs/apis/changeGroupAvatar.cjs

@@ -0,0 +1,49 @@
+'use strict';
+
+var FormData = require('form-data');
+var fs = require('node:fs');
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const changeGroupAvatarFactory = utils.apiFactory()((api, ctx, utils$1) => {
+    const serviceURL = utils$1.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}${utils.getFullTimeFromMillisecond(new Date().getTime())}`,
+            imei: ctx.imei,
+        };
+        const isSourceFilePath = typeof avatarSource == "string";
+        const imageMetaData = isSourceFilePath ? await utils.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$1.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        const response = await utils$1.request(utils$1.makeURL(serviceURL, {
+            params: encryptedParams,
+        }), {
+            method: "POST",
+            headers: formData.getHeaders(),
+            body: formData.getBuffer(),
+        });
+        return utils$1.resolve(response);
+    };
+});
+
+exports.changeGroupAvatarFactory = changeGroupAvatarFactory;

package/dist/cjs/apis/changeGroupName.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const changeGroupNameFactory = utils.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.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.changeGroupNameFactory = changeGroupNameFactory;