zalo-toolkit 1.0.0 → 1.0.2

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,56 @@
+'use strict';
+
+var FormData = require('form-data');
+var index = require('../core/utils/index.cjs');
+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 avatarPath Attachment source, string
+     *
+     * @throws {ZaloApiError | ZaloApiMissingImageMetadataGetter}
+     */
+    return async function changeAccountAvatar(avatarPath) {
+        const file = await index.getFileUpload(avatarPath);
+        const imageMetaData = await utils.getImageMetaData(file);
+        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 formData = new FormData();
+        formData.append('fileContent', file.buffer, {
+            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,47 @@
+'use strict';
+
+var FormData = require('form-data');
+var fs = require('node:fs');
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+var index = require('../core/utils/index.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 groupId Group ID
+     * @param avatarPath Path to the image file
+     *
+     * @throws ZaloApiError
+     */
+    return async function changeGroupAvatar(groupId, avatarPath) {
+        const params = {
+            grid: groupId,
+            avatarSize: 120,
+            clientId: `g${groupId}${utils.getFullTimeFromMillisecond(new Date().getTime())}`,
+            imei: ctx.imei,
+        };
+        const file = await index.getFileUpload(avatarPath);
+        const imageMetaData = await utils.getImageMetaData(file);
+        params.originWidth = imageMetaData.width || 1080;
+        params.originHeight = imageMetaData.height || 1080;
+        const formData = new FormData();
+        formData.append('fileContent', fs.readFileSync(avatarPath), {
+            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(serviceURL + `&params=${encodeURIComponent(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 groupId Group ID
+     * @param name New group name
+     *
+     * @throws ZaloApiError
+     */
+    return async function changeGroupName(groupId, name) {
+        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;

package/dist/cjs/apis/changeGroupOwner.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const changeGroupOwnerFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/change-owner`);
+    /**
+     * Change group owner
+     *
+     * @param userId UserId for change group owner
+     * @param threadId ThreadId for change group owner
+     * @notes Change stupid is lose group rights. Because Web and APP not change key gold (admin main) <(")
+     *
+     * @throws ZaloApiError
+     *
+     */
+    return async function changeGroupOwner(userId, threadId) {
+        const params = {
+            grid: threadId,
+            newAdminId: userId,
+            imei: ctx.imei,
+            language: ctx.language,
+        };
+        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.changeGroupOwnerFactory = changeGroupOwnerFactory;

package/dist/cjs/apis/createAutoReply.cjs

@@ -0,0 +1,42 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const createAutoReplyFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.auto_reply[0]}/api/autoreply/create`);
+    /**
+     * Create auto reply
+     *
+     * @param payload payload
+     *
+     * @note this API used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function createAutoReply(payload) {
+        const uids = Array.isArray(payload.uids) ? payload.uids : [payload.uids];
+        const resultUids = payload.scope === 2 || payload.scope === 3 ? uids : [];
+        const params = {
+            cliLang: ctx.language,
+            enable: payload.isEnable,
+            content: payload.content,
+            startTime: payload.startTime,
+            endTime: payload.endTime,
+            recurrence: ['RRULE:FREQ=DAILY;'],
+            scope: payload.scope,
+            uids: resultUids,
+        };
+        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.createAutoReplyFactory = createAutoReplyFactory;

package/dist/cjs/apis/createCatalog.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const createCatalogFactory = utils.apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.catalog[0]}/api/prodcatalog/catalog/create`);
+    /**
+     * Create catalog?
+     *
+     * @param catalogName catalog name
+     *
+     * @note this API is used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function createCatalog(catalogName) {
+        const params = {
+            catalog_name: catalogName,
+            catalog_photo: '',
+        };
+        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.createCatalogFactory = createCatalogFactory;

package/dist/cjs/apis/createGroup.cjs

@@ -0,0 +1,48 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const createGroupFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/create/v2`);
+    /**
+     * Create a new group
+     *
+     * @param options Group options
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function createGroup(options) {
+        if (options.members.length == 0)
+            throw new ZaloApiError.ZaloApiError('Group must have at least one member');
+        const params = {
+            clientId: Date.now(),
+            gname: String(Date.now()),
+            gdesc: null,
+            members: options.members,
+            membersTypes: options.members.map(() => -1),
+            nameChanged: 0,
+            createLink: 1,
+            clientLang: ctx.language,
+            imei: ctx.imei,
+            zsource: 601,
+        };
+        if (options.name && options.name.length > 0) {
+            params.gname = options.name;
+            params.nameChanged = 1;
+        }
+        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: 'POST',
+        });
+        const data = await utils.resolve(response);
+        options.avatarSource = options.avatarSource;
+        if (options.avatarSource)
+            await api.changeGroupAvatar(options.avatarSource, data.groupId).catch(utils.logger.error);
+        return data;
+    };
+});
+
+exports.createGroupFactory = createGroupFactory;

package/dist/cjs/apis/createNote.cjs

@@ -0,0 +1,52 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const createNoteFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/topic/createv2`);
+    /**
+     * Create a note in a group
+     *
+     * @param options note options
+     * @param options.title note title
+     * @param options.pinAct pin action (pin note)
+     * @param groupId group id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function createNote(options, groupId) {
+        const params = {
+            grid: groupId,
+            type: 0,
+            color: -16777216,
+            emoji: '',
+            startTime: -1,
+            duration: -1,
+            params: JSON.stringify({
+                title: options.title,
+            }),
+            repeat: 0,
+            src: 1,
+            imei: ctx.imei,
+            pinAct: options.pinAct ? 1 : 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, (result) => {
+            if (typeof result.data.params === 'string') {
+                result.data.params = JSON.parse(result.data.params);
+            }
+            return result.data;
+        });
+    };
+});
+
+exports.createNoteFactory = createNoteFactory;

package/dist/cjs/apis/createPoll.cjs

@@ -0,0 +1,45 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const createPollFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/poll/create`);
+    /**
+     * Create a poll in a group.
+     *
+     * @param options Poll options
+     * @param groupId Group ID to create poll from
+     *
+     * @throws ZaloApiError
+     */
+    return async function createPoll(options, groupId) {
+        var _a;
+        const params = {
+            group_id: groupId,
+            question: options.question,
+            options: options.options,
+            expired_time: (_a = options.expiredTime) !== null && _a !== void 0 ? _a : 0,
+            pinAct: !!options.pinAct,
+            allow_multi_choices: !!options.allowMultiChoices,
+            allow_add_new_option: !!options.allowAddNewOption,
+            is_hide_vote_preview: !!options.hideVotePreview,
+            is_anonymous: !!options.isAnonymous,
+            poll_type: 0,
+            src: 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.createPollFactory = createPollFactory;

package/dist/cjs/apis/createProductCatalog.cjs

@@ -0,0 +1,55 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const createProductCatalogFactory = utils.apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.catalog[0]}/api/prodcatalog/product/create`);
+    /**
+     * Create product catalog?
+     *
+     * @param payload payload
+     *
+     * @note this API is used for zBussiness - Maximum 5 media files are supported
+     * @throws {ZaloApiError}
+     */
+    return async function createProductCatalog(payload) {
+        const productPhoto = payload.product_photos || [];
+        if (payload.files && payload.files.length == 0) {
+            if (payload.files.length > 5) {
+                throw new ZaloApiError.ZaloApiError('Maximum 5 media files are allowed');
+            }
+            for (const mediaFile of payload.files) {
+                const uploadMedia = await api.uploadProductPhoto({
+                    url: mediaFile,
+                });
+                const url = uploadMedia.normalUrl || uploadMedia.hdUrl;
+                productPhoto.push(url);
+            }
+        }
+        if (productPhoto.length > 5) {
+            throw new ZaloApiError.ZaloApiError('Maximum 5 media files are allowed');
+        }
+        const params = {
+            product_name: payload.productName,
+            price: payload.price,
+            description: payload.description,
+            product_photos: productPhoto,
+            catalog_id: payload.catalogId,
+            currency_unit: '₫', // $
+            create_time: Date.now(),
+        };
+        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.createProductCatalogFactory = createProductCatalogFactory;

package/dist/cjs/apis/createReminder.cjs

@@ -0,0 +1,76 @@
+'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');
+var Reminder = require('../models/Reminder.cjs');
+require('../models/ZBusiness.cjs');
+
+const createReminderFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = {
+        [Enum.ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/oneone/create`),
+        [Enum.ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/topic/createv2`),
+    };
+    /**
+     * Create a reminder in a group
+     *
+     * @param options reminder options
+     * @param threadId Group ID to create note from
+     * @param type Thread type (User or Group)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function createReminder(options, threadId, type = Enum.ThreadType.User) {
+        var _a, _b, _c, _d, _e, _f;
+        const params = type === Enum.ThreadType.User
+            ? {
+                objectData: JSON.stringify({
+                    toUid: threadId,
+                    type: 0,
+                    color: -16245706,
+                    emoji: (_a = options.emoji) !== null && _a !== void 0 ? _a : '⏰',
+                    startTime: (_b = options.startTime) !== null && _b !== void 0 ? _b : Date.now(),
+                    duration: -1,
+                    params: { title: options.title },
+                    needPin: false,
+                    repeat: (_c = options.repeat) !== null && _c !== void 0 ? _c : Reminder.ReminderRepeatMode.None,
+                    creatorUid: ctx.uid, // Note: for some reason, you can put any valid UID here instead of your own and it still works, atleast for mobile
+                    src: 1,
+                }),
+                imei: ctx.imei,
+            }
+            : {
+                grid: threadId,
+                type: 0,
+                color: -16245706,
+                emoji: (_d = options.emoji) !== null && _d !== void 0 ? _d : '⏰',
+                startTime: (_e = options.startTime) !== null && _e !== void 0 ? _e : Date.now(),
+                duration: -1,
+                params: JSON.stringify({
+                    title: options.title,
+                }),
+                repeat: (_f = options.repeat) !== null && _f !== void 0 ? _f : Reminder.ReminderRepeatMode.None,
+                src: 1,
+                imei: ctx.imei,
+                pinAct: 0,
+            };
+        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,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.createReminderFactory = createReminderFactory;

package/dist/cjs/apis/custom.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var utils = require('../utils.cjs');
+
+/* eslint-disable */
+const customFactory = utils.apiFactory()((api, ctx, utils) => {
+    return function custom(name, callback) {
+        Object.defineProperty(api, name, {
+            value: function (props) {
+                return callback({ ctx, utils, props });
+            },
+            writable: false,
+            enumerable: false,
+            configurable: false,
+        });
+    };
+});
+
+exports.customFactory = customFactory;