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

package/dist/cjs/apis/changeGroupOwner.cjs

@@ -0,0 +1,35 @@
+'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 memberId User Id of new group owner
+     * @param groupId Group Id
+     * @note Be careful when changing the key, as it will result in losing group admin rights
+     *
+     * @throws {ZaloApiError}
+     *
+     */
+    return async function changeGroupOwner(memberId, groupId) {
+        const params = {
+            grid: groupId,
+            newAdminId: memberId,
+            imei: ctx.imei,
+            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(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            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/createBankAccount.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const createBankAccountFactory = utils.apiFactory()((api, ctx, utils$1) => {
+    const serviceURL = utils$1.makeURL(`${api.zpwServiceMap.zimsg[0]}/api/transfer/create`);
+    /**
+     * Create bank account
+     *
+     * @param payload The payload containing the bank account information
+     *
+     * @throws {ZaloApiError} When something went wrong, with `error.code`
+     * - `-263` - Bank account already exists
+     * - `810` - Internal Zalo error, might be invalid input
+     */
+    return async function createBankAccount(payload) {
+        const params = {
+            bin: payload.binBank,
+            bank_number: payload.numAccBank,
+            holder_name: utils.normalizeHolderName(payload.nameAccBank),
+            language: ctx.language,
+        };
+        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, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils$1.resolve(response);
+    };
+});
+
+exports.createBankAccountFactory = createBankAccountFactory;

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 || options.avatarPath;
+        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: false,
+            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({
+                    file: 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,77 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+require('../models/AutoReply.cjs');
+require('../models/Bank.cjs');
+require('../models/Board.cjs');
+var Enum = require('../models/Enum.cjs');
+require('../models/FriendEvent.cjs');
+require('../models/Group.cjs');
+require('../models/GroupEvent.cjs');
+require('../models/Reaction.cjs');
+var Reminder = require('../models/Reminder.cjs');
+require('../models/ZBusiness.cjs');
+var utils = require('../utils.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;

package/dist/cjs/apis/deleteAutoReply.cjs

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

package/dist/cjs/apis/deleteAvatar.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const deleteAvatarFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/del-avatars`);
+    /**
+     * Delete avatar from avatar list
+     *
+     * @param photoId avatar photo ID(s) to delete - can be a single string or array of strings
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function deleteAvatar(photoId) {
+        const photoIds = Array.isArray(photoId) ? photoId : [photoId];
+        const delPhotos = photoIds.map((id) => ({ photoId: id }));
+        const params = {
+            delPhotos: JSON.stringify(delPhotos),
+            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.deleteAvatarFactory = deleteAvatarFactory;

package/dist/cjs/apis/deleteBankAccount.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const deleteBankAccountFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.zimsg[0]}/api/transfer/delete`);
+    /**
+     * Delete bank account
+     *
+     * @param payload The payload containing the bank account information to delete
+     *
+     * @throws {ZaloApiError} When something went wrong, with `error.code`
+     * - `114` - Invalid params
+     * - `-265` - Bank account not exists
+     * - `810` Internal Zalo error, maybe you're trying to delete a default bank account
+     */
+    return async function deleteBankAccount(payload) {
+        const params = {
+            account_id: payload.accountId,
+            is_default: payload.isDefault,
+            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.deleteBankAccountFactory = deleteBankAccountFactory;

package/dist/cjs/apis/deleteCatalog.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const deleteCatalogFactory = utils.apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.catalog[0]}/api/prodcatalog/catalog/delete`);
+    /**
+     * Delete catalog?
+     *
+     * @param catalogId catalog id
+     *
+     * @note this API is used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function deleteCatalog(catalogId) {
+        const params = {
+            catalog_id: catalogId,
+        };
+        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.deleteCatalogFactory = deleteCatalogFactory;

package/dist/cjs/apis/deleteChat.cjs

@@ -0,0 +1,64 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+require('../models/AutoReply.cjs');
+require('../models/Bank.cjs');
+require('../models/Board.cjs');
+var Enum = require('../models/Enum.cjs');
+require('../models/FriendEvent.cjs');
+require('../models/Group.cjs');
+require('../models/GroupEvent.cjs');
+require('../models/Reaction.cjs');
+require('../models/Reminder.cjs');
+require('../models/ZBusiness.cjs');
+var utils = require('../utils.cjs');
+
+const deleteChatFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = {
+        [Enum.ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.chat[0]}/api/message/deleteconver`, {
+            nretry: 0,
+        }),
+        [Enum.ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/deleteconver`, {
+            nretry: 0,
+        }),
+    };
+    /**
+     * Delete chat
+     *
+     * @param lastMessage Last message info
+     * @param threadId Thread ID
+     * @param type Thread type
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function deleteChat(lastMessage, threadId, type = Enum.ThreadType.User) {
+        const timestampString = Date.now().toString();
+        const params = type === Enum.ThreadType.User
+            ? {
+                toid: threadId,
+                cliMsgId: timestampString,
+                conver: lastMessage,
+                onlyMe: 1,
+                imei: ctx.imei,
+            }
+            : {
+                grid: threadId,
+                cliMsgId: timestampString,
+                conver: lastMessage,
+                onlyMe: 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[type], {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.deleteChatFactory = deleteChatFactory;