zalo-toolkit 1.0.0 → 1.0.2

package/dist/cjs/apis/forwardMessage.cjs

@@ -0,0 +1,122 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var Enum = require('../models/Enum.cjs');
+var utils = require('../utils.cjs');
+
+exports.ForwardMessageType = void 0;
+(function (ForwardMessageType) {
+    ForwardMessageType["TEXT"] = "text";
+    ForwardMessageType["LINK"] = "link";
+})(exports.ForwardMessageType || (exports.ForwardMessageType = {}));
+const forwardMessageFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = {
+        [Enum.ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.file[0]}/api/message/mforward`),
+        [Enum.ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.file[0]}/api/group/mforward`),
+    };
+    return async function forwardMessage(options, toIds, type = Enum.ThreadType.User, messageType) {
+        const timestamp = Date.now();
+        const params = {
+            imei: ctx.imei,
+            ttl: 0,
+            msgType: '1',
+            totalIds: toIds.length,
+        };
+        switch (messageType) {
+            case exports.ForwardMessageType.LINK:
+                const linkOptions = options;
+                params.msgType = '3';
+                params.msgInfo = JSON.stringify({
+                    link: linkOptions.url,
+                    linkTitle: linkOptions.url,
+                    linkDesc: linkOptions.description,
+                    linkThumb: linkOptions.thumbnailUrl,
+                    linkType: '',
+                    extData: JSON.stringify({
+                        streamUrl: '',
+                        stream_icon: '',
+                        mediaTitle: '',
+                        artist: '',
+                        src: linkOptions.src,
+                        count: '',
+                        type: 0,
+                    }),
+                    message: linkOptions.url,
+                    reference: JSON.stringify({
+                        type: 3,
+                        data: JSON.stringify({
+                            logSrcType: 2,
+                            ts: 1744700773591,
+                            fwLvl: 1,
+                            rootMsgRef: {
+                                ts: 1744700761721,
+                                logSrcType: 2,
+                            },
+                        }),
+                    }),
+                });
+                params.decorLog = JSON.stringify({
+                    fw: {
+                        pmsg: {
+                            st: 2,
+                            ts: 1744700773591,
+                        },
+                        rmsg: {
+                            st: 2,
+                            ts: 1744700761721,
+                        },
+                        fwLvl: 1,
+                    },
+                });
+                break;
+            case exports.ForwardMessageType.TEXT:
+                const textOptions = options;
+                params.msgType = '1';
+                params.msgInfo = JSON.stringify(Object.assign(Object.assign({}, params.msgInfo), { message: textOptions.message, reference: JSON.stringify({
+                        type: 3,
+                        data: JSON.stringify({
+                            ts: timestamp,
+                            logSrcType: 2,
+                            fwLvl: 1,
+                            rootMsgRef: {
+                                ts: timestamp,
+                                logSrcType: 2,
+                            },
+                        }),
+                    }) }));
+                params.decorLog = JSON.stringify({
+                    fw: {
+                        pmsg: {
+                            st: 1,
+                            ts: timestamp,
+                        },
+                        rmsg: {
+                            st: 1,
+                            ts: timestamp,
+                        },
+                        fwLvl: 1,
+                    },
+                });
+                break;
+        }
+        if (type === Enum.ThreadType.Group) {
+            params['grids'] = toIds.map((item) => (Object.assign(Object.assign({}, item), { toUid: undefined, grid: item.toUid })));
+        }
+        else {
+            params['toIds'] = toIds;
+        }
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError('Failed to encrypt params');
+        const response = await utils.request(serviceURL[type], {
+            method: 'POST',
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        const result = await utils.resolve(response);
+        return result;
+    };
+});
+
+exports.forwardMessageFactory = forwardMessageFactory;

package/dist/cjs/apis/getAliasList.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getAliasListFactory = utils.apiFactory()((api, ctx, utils) => {
+    return async function getListAlias(page = 1, limit = 200) {
+        console.log('getListAlias', page, ctx.uid);
+        try {
+            const params = {
+                page,
+                count: limit,
+                imei: ctx.imei,
+            };
+            const encryptedParams = utils.encodeAES(JSON.stringify(params));
+            if (!encryptedParams)
+                throw new ZaloApiError.ZaloApiError('Failed to encrypt message');
+            const serviceURL = utils.makeURL(`${api.zpwServiceMap.alias[0]}/api/alias/list`, {
+                params: encryptedParams,
+            });
+            const response = await utils.request(serviceURL, {
+                method: 'GET',
+            });
+            const result = await utils.resolve(response);
+            return (result === null || result === void 0 ? void 0 : result.items) || [];
+        }
+        catch (error) {
+            return [];
+        }
+    };
+});
+
+exports.getAliasListFactory = getAliasListFactory;

package/dist/cjs/apis/getAllFriends.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getAllFriendsFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/friend/getfriends`);
+    /**
+     * Get all friends
+     *
+     * @param count Page size (default: 20000)
+     * @param page Page number (default: 1)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getAllFriends(count = 20000, page = 1) {
+        const params = {
+            incInvalid: 1,
+            page,
+            count,
+            avatar_size: 120,
+            actiontime: 0,
+            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(utils.makeURL(serviceURL, {
+            params: encryptedParams,
+        }), {
+            method: 'GET',
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.getAllFriendsFactory = getAllFriendsFactory;

package/dist/cjs/apis/getAllGroups.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var utils = require('../utils.cjs');
+
+const getAllGroupsFactory = utils.apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group_poll[0]}/api/group/getlg/v4`);
+    return async function getAllGroups() {
+        const response = await utils.request(serviceURL, {
+            method: 'GET',
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.getAllGroupsFactory = getAllGroupsFactory;

package/dist/cjs/apis/getArchivedChatList.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getArchivedChatListFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.label[0]}/api/archivedchat/list`);
+    /**
+     * Get arcnived chat list
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getArchivedChatList() {
+        const params = {
+            version: 1,
+            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.getArchivedChatListFactory = getArchivedChatListFactory;

package/dist/cjs/apis/getAutoDeleteChat.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getAutoDeleteChatFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.conversation[0]}/api/conv/autodelete/getConvers`);
+    /**
+     * Get auto delete chat
+     *
+     * @throws {ZaloApiError}
+     *
+     */
+    return async function getAutoDeleteChat() {
+        const params = {};
+        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.getAutoDeleteChatFactory = getAutoDeleteChatFactory;

package/dist/cjs/apis/getAutoReplyList.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getAutoReplyListFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.auto_reply[0]}/api/autoreply/list`);
+    /**
+     * Get auto reply list
+     *
+     * @note this API used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function getAutoReplyList() {
+        const params = {
+            version: 0,
+            cliLang: ctx.language,
+        };
+        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.getAutoReplyListFactory = getAutoReplyListFactory;

package/dist/cjs/apis/getAvatarList.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getAvatarListFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/avatar-list`);
+    /**
+     * Get avatar list
+     *
+     * @param count The number of avatars to fetch (default: 50)
+     * @param page The page number to fetch (default: 1)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getAvatarList(count = 50, page = 1) {
+        const params = {
+            page,
+            albumId: '0',
+            count,
+            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.getAvatarListFactory = getAvatarListFactory;

package/dist/cjs/apis/getBizAccount.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getBizAccountFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/friend/get-bizacc`);
+    /**
+     * Get biz account
+     *
+     * @param friendId The friend ID to get biz account
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getBizAccount(friendId) {
+        const params = {
+            fid: friendId,
+        };
+        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.getBizAccountFactory = getBizAccountFactory;

package/dist/cjs/apis/getCatalogList.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getCatalogListFactory = utils.apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.catalog[0]}/api/prodcatalog/catalog/list`);
+    /**
+     * Get catalog list?
+     *
+     * @param payload payload
+     *
+     * @note this API is used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function getCatalogList(payload) {
+        var _a, _b, _c;
+        const params = {
+            version_list_catalog: 0,
+            limit: (_a = payload === null || payload === void 0 ? void 0 : payload.limit) !== null && _a !== void 0 ? _a : 20,
+            last_product_id: (_b = payload === null || payload === void 0 ? void 0 : payload.lastProductId) !== null && _b !== void 0 ? _b : -1,
+            page: (_c = payload === null || payload === void 0 ? void 0 : payload.page) !== null && _c !== void 0 ? _c : 0,
+        };
+        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.getCatalogListFactory = getCatalogListFactory;

package/dist/cjs/apis/getContext.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var utils = require('../utils.cjs');
+
+const getContextFactory = utils.apiFactory()((_, ctx) => {
+    return () => ctx;
+});
+
+exports.getContextFactory = getContextFactory;

package/dist/cjs/apis/getCookie.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var utils = require('../utils.cjs');
+
+const getCookieFactory = utils.apiFactory()((_, ctx) => {
+    /**
+     * Get the current cookie string
+     */
+    return function getCookie() {
+        return ctx.cookie;
+    };
+});
+
+exports.getCookieFactory = getCookieFactory;

package/dist/cjs/apis/getFriendBoardList.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getFriendBoardListFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend_board[0]}/api/friendboard/list`);
+    /**
+     * Get friend board list
+     *
+     * @param conversationId conversation id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getFriendBoardList(conversationId) {
+        const params = {
+            conversationId: conversationId,
+            version: 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(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: 'GET',
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.getFriendBoardListFactory = getFriendBoardListFactory;

package/dist/cjs/apis/getFriendOnlines.cjs

@@ -0,0 +1,40 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getFriendOnlinesFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/friend/onlines`);
+    /**
+     * Get friend onlines?
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getFriendOnlines() {
+        const params = {
+            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, (result) => {
+            const data = result.data;
+            if (Array.isArray(data.onlines)) {
+                for (const online of data.onlines) {
+                    if (typeof online.status === 'string') {
+                        const parsed = JSON.parse(online.status);
+                        if (parsed && typeof parsed.status === 'string') {
+                            online.status = parsed.status;
+                        }
+                    }
+                }
+            }
+            return data;
+        });
+    };
+});
+
+exports.getFriendOnlinesFactory = getFriendOnlinesFactory;

package/dist/cjs/apis/getFriendRecommendations.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+exports.FriendRecommendationsType = void 0;
+(function (FriendRecommendationsType) {
+    FriendRecommendationsType[FriendRecommendationsType["RecommendedFriend"] = 1] = "RecommendedFriend";
+    FriendRecommendationsType[FriendRecommendationsType["ReceivedFriendRequest"] = 2] = "ReceivedFriendRequest";
+})(exports.FriendRecommendationsType || (exports.FriendRecommendationsType = {}));
+const getFriendRecommendationsFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/recommendsv2/list`);
+    /**
+     * Get friend recommendations/received friend requests
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getFriendRecommendations() {
+        const params = {
+            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.getFriendRecommendationsFactory = getFriendRecommendationsFactory;

package/dist/cjs/apis/getFriendRequestStatus.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getFriendRequestStatusFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/reqstatus`);
+    /**
+     * Get friend request status
+     *
+     * @param friendId friend id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getFriendRequestStatus(friendId) {
+        const params = {
+            fid: friendId,
+            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.getFriendRequestStatusFactory = getFriendRequestStatusFactory;

package/dist/cjs/apis/getGroupBlockedMember.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getGroupBlockedMemberFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/blockedmems/list`);
+    /**
+     * Get group blocked member
+     *
+     * @param payload payload
+     * @param groupId group id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupBlockedMember(payload, groupId) {
+        var _a, _b;
+        const params = {
+            grid: groupId,
+            page: (_a = payload.page) !== null && _a !== void 0 ? _a : 1,
+            count: (_b = payload.count) !== null && _b !== void 0 ? _b : 50,
+            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.getGroupBlockedMemberFactory = getGroupBlockedMemberFactory;

package/dist/cjs/apis/getGroupInfo.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getGroupInfoFactory = utils.apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/getmg-v2`);
+    /**
+     * Get group information
+     *
+     * @param groupId Group ID or list of group IDs
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupInfo(groupId) {
+        if (!Array.isArray(groupId))
+            groupId = [groupId];
+        const params = {
+            gridVerMap: JSON.stringify(groupId.reduce((acc, id) => {
+                acc[id] = 0;
+                return acc;
+            }, {})),
+        };
+        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);
+    };
+});
+
+exports.getGroupInfoFactory = getGroupInfoFactory;