zalo-toolkit 1.0.0 → 1.0.2

package/dist/apis/sendMessage.d.ts

@@ -1,5 +1,6 @@
 import type { IFileUpload } from '../core/interfaces/common.js';
 import { ThreadType, type TMessage } from '../models/index.js';
+import type { ParseLinkResponse } from './parseLink.js';
 export type SendMessageResult = {
     msgId: number;
 };
@@ -85,6 +86,10 @@ export type MessageContent = {
      * Mentions in the message (optional)
      */
     mentions?: Mention[];
+    /**
+     * Parse Link (optional)
+     */
+    parseLink?: ParseLinkResponse['data'];
     /**
      * Attachments in the message (optional)
      */

package/dist/apis/sendMessage.js

@@ -158,7 +158,7 @@ export const sendMessageFactory = apiFactory()((api, ctx, utils) => {
             Object.assign(params, { metaData: { urgency } });
         }
     }
-    async function handleMessage({ msg, styles, urgency, mentions, quote, ttl }, threadId, type) {
+    async function handleMessage({ msg, styles, urgency, mentions, parseLink, quote, ttl }, threadId, type) {
         if (!msg || msg.length == 0)
             throw new ZaloApiError('Missing message content');
         const isGroupMessage = type == ThreadType.Group;
@@ -192,16 +192,33 @@ export const sendMessageFactory = apiFactory()((api, ctx, utils) => {
                 qmsgTTL: quote.ttl,
                 ttl: ttl !== null && ttl !== void 0 ? ttl : 0,
             }
-            : {
-                message: msg,
-                clientId: Date.now(),
-                mentionInfo: isMentionsValid ? JSON.stringify(mentionsFinal) : undefined,
-                imei: isGroupMessage ? undefined : ctx.imei,
-                ttl: ttl !== null && ttl !== void 0 ? ttl : 0,
-                visibility: isGroupMessage ? 0 : undefined,
-                toid: isGroupMessage ? undefined : threadId,
-                grid: isGroupMessage ? threadId : undefined,
-            };
+            : parseLink
+                ? {
+                    msg: msg,
+                    href: parseLink.href,
+                    src: parseLink.src,
+                    title: parseLink.title || parseLink.href,
+                    desc: parseLink.desc,
+                    thumb: parseLink.thumb,
+                    type: 0,
+                    media: JSON.stringify(parseLink.media),
+                    ttl: 0,
+                    toId: isGroupMessage ? undefined : threadId,
+                    grid: isGroupMessage ? threadId : undefined,
+                    clientId: Date.now(),
+                    mentionInfo: isMentionsValid ? JSON.stringify(mentionsFinal) : '',
+                    imei: isGroupMessage ? ctx.imei : undefined,
+                }
+                : {
+                    message: msg,
+                    clientId: Date.now(),
+                    mentionInfo: isMentionsValid ? JSON.stringify(mentionsFinal) : undefined,
+                    imei: isGroupMessage ? undefined : ctx.imei,
+                    ttl: ttl !== null && ttl !== void 0 ? ttl : 0,
+                    visibility: isGroupMessage ? 0 : undefined,
+                    toid: isGroupMessage ? undefined : threadId,
+                    grid: isGroupMessage ? threadId : undefined,
+                };
         handleStyles(params, styles);
         handleUrgency(params, urgency);
         removeUndefinedKeys(params);
@@ -212,6 +229,9 @@ export const sendMessageFactory = apiFactory()((api, ctx, utils) => {
         if (quote) {
             finalServiceUrl.pathname = finalServiceUrl.pathname + '/quote';
         }
+        else if (parseLink) {
+            finalServiceUrl.pathname = finalServiceUrl.pathname + '/' + (isGroupMessage ? 'sendlink' : 'link');
+        }
         else {
             finalServiceUrl.pathname = finalServiceUrl.pathname + '/' + (isGroupMessage ? (params.mentionInfo ? 'mention' : 'sendmsg') : 'sms');
         }

package/dist/cjs/apis/acceptFriendRequest.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const acceptFriendRequestFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/accept`);
+    /**
+     * Accept a friend request from a User
+     *
+     * @param userId The User ID to friend request is accept
+     *
+     * @throws ZaloApiError
+     */
+    return async function acceptFriendRequest(userId) {
+        const params = {
+            fid: userId,
+            language: 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.acceptFriendRequestFactory = acceptFriendRequestFactory;

package/dist/cjs/apis/addGroupBlockedMember.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const addGroupBlockedMemberFactory = utils.apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/blockedmems/add`);
+    /**
+     * Add group blocked member
+     *
+     * @param memberId member id(s)
+     * @param groupId group id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function addGroupBlockedMember(memberId, groupId) {
+        if (!Array.isArray(memberId))
+            memberId = [memberId];
+        const params = {
+            grid: groupId,
+            members: memberId,
+        };
+        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.addGroupBlockedMemberFactory = addGroupBlockedMemberFactory;

package/dist/cjs/apis/addGroupDeputy.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const addGroupDeputyFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/admins/add`);
+    /**
+     * Add group deputy
+     *
+     * @param memberId user Id or list of user Ids
+     * @param groupId group Id
+     *
+     * @throws ZaloApiError
+     *
+     */
+    return async function addGroupDeputy(memberId, groupId) {
+        if (!Array.isArray(memberId))
+            memberId = [memberId];
+        const params = {
+            grid: groupId,
+            members: memberId,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError('Failed to encrypt params');
+        const urlWithParams = `${serviceURL}&params=${encodeURIComponent(encryptedParams)}`;
+        const response = await utils.request(urlWithParams, {
+            method: 'GET',
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.addGroupDeputyFactory = addGroupDeputyFactory;

package/dist/cjs/apis/addPollOptions.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const addPollOptionsFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/poll/option/add`);
+    /**
+     * Add new option to poll
+     *
+     * @param payload
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function addPollOptions(payload) {
+        const params = {
+            poll_id: payload.pollId,
+            new_options: JSON.stringify(payload.options),
+            voted_option_ids: payload.votedOptionIds,
+        };
+        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.addPollOptionsFactory = addPollOptionsFactory;

package/dist/cjs/apis/addQuickMessage.cjs

@@ -0,0 +1,65 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const addQuickMessageFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.quick_message[0]}/api/quickmessage/create`);
+    /**
+     * Add quick message
+     *
+     * @param addPayload - The payload containing data to add the quick message
+     *
+     * @note Zalo might throw an error with code 821 if you have reached the limit of quick messages.
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function addQuickMessage(addPayload) {
+        const isType = !addPayload.media ? 0 : 1;
+        const params = {
+            keyword: addPayload.keyword,
+            message: {
+                title: addPayload.title,
+                params: '',
+            },
+            type: isType,
+            imei: ctx.imei,
+        };
+        if (isType === 1) {
+            if (!addPayload.media)
+                throw new ZaloApiError.ZaloApiError('Media is required');
+            const uploadMedia = await api.uploadProductPhoto({
+                url: addPayload.media,
+            });
+            const photoId = uploadMedia.photoId;
+            const thumbUrl = uploadMedia.thumbUrl;
+            const normalUrl = uploadMedia.normalUrl;
+            const hdUrl = uploadMedia.hdUrl;
+            params.media = {
+                items: [
+                    {
+                        type: 0,
+                        photoId: photoId,
+                        title: '',
+                        width: '',
+                        height: '',
+                        previewThumb: thumbUrl,
+                        rawUrl: normalUrl || hdUrl,
+                        thumbUrl: thumbUrl,
+                        normalUrl: normalUrl || hdUrl,
+                        hdUrl: hdUrl || normalUrl,
+                    },
+                ],
+            };
+        }
+        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.addQuickMessageFactory = addQuickMessageFactory;

package/dist/cjs/apis/addReaction.cjs

@@ -0,0 +1,297 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var Enum = require('../models/Enum.cjs');
+var Reaction = require('../models/Reaction.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 params = {
+            react_list: [
+                {
+                    message: JSON.stringify({
+                        rMsg: [
+                            {
+                                gMsgID: parseInt(dest.data.msgId),
+                                cMsgID: parseInt(dest.data.cliMsgId),
+                                msgType: 1,
+                            },
+                        ],
+                        rIcon: icon,
+                        rType,
+                        source,
+                    }),
+                    clientId: Date.now(),
+                },
+            ],
+            imei: ctx.imei,
+        };
+        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,65 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+require('../models/AutoReply.cjs');
+require('../models/Board.cjs');
+var Enum = require('../models/Enum.cjs');
+require('../models/FriendEvent.cjs');
+require('../models/Group.cjs');
+require('../models/GroupEvent.cjs');
+var utils = require('../utils.cjs');
+require('../models/Reaction.cjs');
+require('../models/Reminder.cjs');
+require('../models/ZBusiness.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 groupId Group ID
+     * @param members User ID or list of user IDs to add
+     *
+     * @throws ZaloApiError
+     */
+    return async function addUserToGroup(groupId, members) {
+        if (!Array.isArray(members))
+            members = [members];
+        const params = {
+            grid: groupId,
+            members: members,
+            membersTypes: members.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;