@softtynet/zca-js 2.2.9 → 2.2.10

package/dist/cjs/apis/profile/getUserInfo.cjs

@@ -0,0 +1,60 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.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');
+require('../../models/SyncEvent.cjs');
+require('../../models/CallEvent.cjs');
+
+const getUserInfoFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/friend/getprofiles/v2`);
+    /**
+     * Get user info using user id
+     *
+     * @param userId User id(s)
+     * @param avatarSize Avatar size (default: AvatarSize.Small)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getUserInfo(userId, avatarSize = Enum.AvatarSize.Small) {
+        if (!userId)
+            throw new ZaloApiError.ZaloApiError("Missing user id");
+        if (!Array.isArray(userId))
+            userId = [userId];
+        userId = userId.map((id) => {
+            if (id.split("_").length > 1) {
+                return id;
+            }
+            return `${id}_0`;
+        });
+        const params = {
+            phonebook_version: ctx.extraVer.phonebook,
+            friend_pversion_map: userId,
+            avatar_size: avatarSize,
+            language: ctx.language,
+            show_online_status: 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(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.getUserInfoFactory = getUserInfoFactory;

package/dist/cjs/apis/profile/reuseAvatar.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const reuseAvatarFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/reuse-avatar`);
+    /**
+     * Reuse avatar
+     *
+     * @param photoId photo id from getAvatarList api
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function reuseAvatar(photoId) {
+        const params = {
+            photoId: photoId,
+            isPostSocial: 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.reuseAvatarFactory = reuseAvatarFactory;

package/dist/cjs/apis/profile/updateProfile.cjs

@@ -0,0 +1,47 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const updateProfileFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/profile/update`);
+    /**
+     * Change account setting information
+     *
+     * @param payload payload
+     *
+     * @note If your account is a Business Account, include the biz.cate field; otherwise the category will be removed.
+     * You may leave the other biz fields empty if you don’t want to change them.
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function updateProfile(payload) {
+        const params = {
+            profile: JSON.stringify({
+                name: payload.profile.name,
+                dob: payload.profile.dob,
+                gender: payload.profile.gender,
+            }),
+            biz: JSON.stringify({
+                desc: payload.biz?.description,
+                cate: payload.biz?.cate,
+                addr: payload.biz?.address,
+                website: payload.biz?.website,
+                email: payload.biz?.email,
+            }),
+            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.updateProfileFactory = updateProfileFactory;

package/dist/cjs/apis/profile/updateProfileBio.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const updateProfileBioFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/profile/status`);
+    /**
+     * Update profile bio
+     *
+     * @param status status for update bio
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function updateProfileBio(status) {
+        const params = {
+            status: status,
+        };
+        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: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.updateProfileBioFactory = updateProfileBioFactory;

package/dist/cjs/apis/profile/updateSettings.cjs

@@ -0,0 +1,97 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+var domains = require('../../constants/domains.cjs');
+var endpoints = require('../../constants/endpoints.cjs');
+
+exports.UpdateSettingsType = void 0;
+(function (UpdateSettingsType) {
+    UpdateSettingsType["ViewBirthday"] = "view_birthday";
+    UpdateSettingsType["ShowOnlineStatus"] = "show_online_status";
+    UpdateSettingsType["DisplaySeenStatus"] = "display_seen_status";
+    UpdateSettingsType["ReceiveMessage"] = "receive_message";
+    UpdateSettingsType["AcceptCall"] = "accept_stranger_call";
+    UpdateSettingsType["AddFriendViaPhone"] = "add_friend_via_phone";
+    UpdateSettingsType["AddFriendViaQR"] = "add_friend_via_qr";
+    UpdateSettingsType["AddFriendViaGroup"] = "add_friend_via_group";
+    UpdateSettingsType["AddFriendViaContact"] = "add_friend_via_contact";
+    UpdateSettingsType["DisplayOnRecommendFriend"] = "display_on_recommend_friend";
+    UpdateSettingsType["ArchivedChat"] = "archivedChatStatus";
+    UpdateSettingsType["QuickMessage"] = "quickMessageStatus";
+})(exports.UpdateSettingsType || (exports.UpdateSettingsType = {}));
+const updateSettingsFactory = utils.apiFactory()((_api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${domains.ZALO_DOMAINS.WPA_CHAT}${endpoints.ZALO_ENDPOINTS.WPA.SETTING_UPDATE}`);
+    /**
+     * Set account settings
+     *
+     * @param type The type of setting to update
+     * @param value
+     *
+     * ViewBirthday
+     * * 0: hide
+     * * 1: show full day/month/year
+     * * 2: show day/month
+     *
+     * ShowOnlineStatus
+     * * 0: hide
+     * * 1: show
+     *
+     * DisplaySeenStatus
+     * * 0: hide
+     * * 1: show
+     *
+     * ReceiveMessage
+     * * 1: everyone
+     * * 2: only friends
+     *
+     * AcceptCall
+     * * 2: only friends
+     * * 3: everyone
+     * * 4: friends and person who contacted
+     *
+     * AddFriendViaPhone
+     * * 0: disable
+     * * 1: enable
+     *
+     * AddFriendViaQR
+     * * 0: disable
+     * * 1: enable
+     *
+     * AddFriendViaGroup
+     * * 0: disable
+     * * 1: enable
+     *
+     * AddFriendViaContact
+     * * 0: disable
+     * * 1: enable
+     *
+     * DisplayOnRecommendFriend
+     * * 0: disable
+     * * 1: enable
+     *
+     * ArchivedChat
+     * * 0: disable
+     * * 1: enable
+     *
+     * QuickMessage
+     * * 0: disable
+     * * 1: enable
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function updateSettings(type, value) {
+        const params = {
+            [type]: value,
+        };
+        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.updateSettingsFactory = updateSettingsFactory;

package/dist/cjs/apis/sticker/getPersonalizedStickerList.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const getPersonalizedStickerListFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.sticker[0]}/api/message/sticker/personalized/list`);
+    /**
+     * Lấy danh sách Sticker cá nhân hóa của tài khoản (command 11745)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getPersonalizedStickerList() {
+        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.getPersonalizedStickerListFactory = getPersonalizedStickerListFactory;

package/dist/cjs/apis/sticker/getStickerCategoriesV2.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const getStickerCategoriesV2Factory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.sticker[0]}/api/message/sticker/category/list/v2`);
+    /**
+     * Lấy danh sách danh mục bộ nhãn dán (Sticker Categories V2 - command 12020)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getStickerCategoriesV2() {
+        const encryptedParams = utils.encodeAES("");
+        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.getStickerCategoriesV2Factory = getStickerCategoriesV2Factory;

package/dist/cjs/apis/sticker/getStickerCategoryData.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const getStickerCategoryDataFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.sticker[0]}/api/message/sticker/category/detail`);
+    /**
+     * Lấy thông tin chi tiết một bộ nhãn dán theo `cid` (command 11156)
+     *
+     * @param cid ID bộ nhãn dán (Category ID)
+     * @throws {ZaloApiError}
+     */
+    return async function getStickerCategoryData(cid) {
+        const params = {
+            cid,
+        };
+        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.getStickerCategoryDataFactory = getStickerCategoryDataFactory;

package/dist/cjs/apis/sticker/getStickerCategoryDetail.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const getStickerCategoryDetailFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.sticker[0]}/api/message/sticker/category/sticker_detail`);
+    /**
+     * Get sticker category detail
+     *
+     * @param cateId Sticker category ID
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getStickerCategoryDetail(cateId) {
+        const params = {
+            cid: cateId,
+        };
+        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.getStickerCategoryDetailFactory = getStickerCategoryDetailFactory;

package/dist/cjs/apis/sticker/getStickerHello.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const getStickerHelloFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.sticker[0]}/api/message/sticker/suggestion`);
+    /**
+     * Lấy danh sách Sticker chào hỏi gợi ý khi bắt đầu trò chuyện mới (command 11751)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getStickerHello() {
+        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) => {
+            if (typeof result.data === "string") {
+                try {
+                    return JSON.parse(result.data);
+                }
+                catch {
+                    return result.data;
+                }
+            }
+            return result.data;
+        });
+    };
+});
+
+exports.getStickerHelloFactory = getStickerHelloFactory;

package/dist/cjs/apis/sticker/getStickerSuggestKeywords.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const getStickerSuggestKeywordsFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.sticker[0]}/api/message/sticker/suggest/keywords`);
+    /**
+     * Lấy bộ từ khóa gợi ý Sticker tự động khi gõ tin nhắn (command 11740)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getStickerSuggestKeywords() {
+        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.getStickerSuggestKeywordsFactory = getStickerSuggestKeywordsFactory;

package/dist/cjs/apis/sticker/getStickerSuggestion.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const getStickerSuggestionFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.sticker[0]}/api/message/sticker/suggest/stickers`);
+    /**
+     * Gợi ý Sticker/GIF theo từ khóa đang nhập (command 11741)
+     *
+     * @param options Từ khóa và tùy chọn kèm theo (`gif`, `guggy`)
+     * @throws {ZaloApiError}
+     */
+    return async function getStickerSuggestion(options) {
+        const normalized = typeof options === "string" ? { keyword: options } : options;
+        const params = {
+            keyword: normalized.keyword,
+            gif: normalized.gif ?? 1,
+            guggy: normalized.guggy ?? 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.getStickerSuggestionFactory = getStickerSuggestionFactory;

package/dist/cjs/apis/sticker/getStickers.cjs

@@ -0,0 +1,45 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const getStickersFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.sticker}/api/message/sticker`);
+    /**
+     * Get stickers by keyword
+     *
+     * @param keyword Keyword to search for
+     * @returns Sticker IDs
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getStickers(keyword) {
+        if (!keyword)
+            throw new ZaloApiError.ZaloApiError("Missing keyword");
+        const params = {
+            keyword: keyword,
+            gif: 1,
+            guggy: 0,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt message");
+        const finalServiceUrl = new URL(serviceURL);
+        finalServiceUrl.pathname = finalServiceUrl.pathname + "/suggest/stickers";
+        const response = await utils.request(utils.makeURL(finalServiceUrl.toString(), {
+            params: encryptedParams,
+        }));
+        return utils.resolve(response, (result) => {
+            const suggestions = result.data;
+            const stickerIds = [];
+            // @TODO: Implement these
+            // suggestions.sugg_guggy, suggestions.sugg_gif
+            if (suggestions.sugg_sticker)
+                suggestions.sugg_sticker.forEach((sticker) => stickerIds.push(sticker.sticker_id));
+            return stickerIds;
+        });
+    };
+});
+
+exports.getStickersFactory = getStickersFactory;

package/dist/cjs/apis/sticker/getStickersDetail.cjs

@@ -0,0 +1,45 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const getStickersDetailFactory = utils.apiFactory()((api, ctx, utils$1) => {
+    const serviceURL = utils$1.makeURL(`${api.zpwServiceMap.sticker}/api/message/sticker/sticker_detail`);
+    /**
+     * Get stickers detail by sticker IDs
+     *
+     * @param stickerIds Sticker IDs to search for
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getStickersDetail(stickerIds) {
+        if (!stickerIds)
+            throw new ZaloApiError.ZaloApiError("Missing sticker id");
+        if (!Array.isArray(stickerIds))
+            stickerIds = [stickerIds];
+        if (stickerIds.length == 0)
+            throw new ZaloApiError.ZaloApiError("Missing sticker id");
+        const stickers = [];
+        const tasks = stickerIds.map((stickerId) => getStickerDetail(stickerId));
+        const tasksResult = await Promise.allSettled(tasks);
+        tasksResult.forEach((result) => {
+            if (result.status === "fulfilled")
+                stickers.push(result.value);
+        });
+        return stickers;
+    };
+    async function getStickerDetail(stickerId) {
+        const params = {
+            sid: stickerId,
+        };
+        const encryptedParams = utils$1.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt message");
+        const response = await utils$1.request(utils$1.makeURL(serviceURL, {
+            params: encryptedParams,
+        }));
+        return utils.resolveResponse(ctx, response);
+    }
+});
+
+exports.getStickersDetailFactory = getStickersDetailFactory;

package/dist/cjs/apis/sticker/searchSticker.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const searchStickerFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.sticker[0]}/api/message/sticker/search`);
+    /**
+     * Search stickers
+     *
+     * @param keyword Keyword to search stickers
+     * @param limit Limit of stickers to return (default: 50)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function searchSticker(keyword, limit = 50) {
+        const params = {
+            keyword: keyword,
+            limit: limit,
+            srcType: 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.searchStickerFactory = searchStickerFactory;

package/dist/cjs/apis/sync/cancelPullMobile.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const cancelPullMobileFactory = utils.apiFactory()((api, ctx, utils) => {
+    const baseURL = utils.makeURL(`${api.zpwServiceMap.file[0]}/api/message/cancel_pull_mobile_msg`);
+    /**
+     * Huỷ yêu cầu đồng bộ tin nhắn từ điện thoại đang chờ (`cancel_pull_mobile_msg`, command `12700`).
+     *
+     * @param params Tham số huỷ đồng bộ (`public_key`, `pc_name`)
+     * @throws {ZaloApiError}
+     */
+    return async function cancelPullMobile({ public_key, pc_name = "Web" }) {
+        if (!public_key)
+            throw new ZaloApiError.ZaloApiError("Missing public_key");
+        const payload = {
+            pc_name,
+            public_key,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(payload));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        const serviceURL = utils.makeURL(baseURL, {
+            zpw_ver: ctx.API_VERSION,
+            zpw_type: ctx.API_TYPE,
+            params: encryptedParams,
+            nretry: 0,
+        }, false);
+        const response = await utils.request(serviceURL, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.cancelPullMobileFactory = cancelPullMobileFactory;