zalo-toolkit 1.0.0

package/dist/Errors/ZaloApiError.d.ts

@@ -0,0 +1,4 @@
+export declare class ZaloApiError extends Error {
+    code: number | null;
+    constructor(message: string, code?: number);
+}

package/dist/Errors/ZaloApiError.js

@@ -0,0 +1,7 @@
+export class ZaloApiError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.name = "ZcaApiError";
+        this.code = code || null;
+    }
+}

package/dist/Errors/ZaloApiLoginQRAborted.d.ts

@@ -0,0 +1,4 @@
+import { ZaloApiError } from "./ZaloApiError.js";
+export declare class ZaloApiLoginQRAborted extends ZaloApiError {
+    constructor(message?: string);
+}

package/dist/Errors/ZaloApiLoginQRAborted.js

@@ -0,0 +1,7 @@
+import { ZaloApiError } from "./ZaloApiError.js";
+export class ZaloApiLoginQRAborted extends ZaloApiError {
+    constructor(message = "Operation aborted") {
+        super(message);
+        this.name = "ZaloApiLoginQRAborted";
+    }
+}

package/dist/Errors/ZaloApiLoginQRDeclined.d.ts

@@ -0,0 +1,4 @@
+import { ZaloApiError } from "./ZaloApiError.js";
+export declare class ZaloApiLoginQRDeclined extends ZaloApiError {
+    constructor(message?: string);
+}

package/dist/Errors/ZaloApiLoginQRDeclined.js

@@ -0,0 +1,7 @@
+import { ZaloApiError } from "./ZaloApiError.js";
+export class ZaloApiLoginQRDeclined extends ZaloApiError {
+    constructor(message = "Login QR request declined") {
+        super(message);
+        this.name = "ZaloApiLoginQRDeclined";
+    }
+}

package/dist/Errors/ZaloApiMissingImageMetadataGetter.d.ts

@@ -0,0 +1,4 @@
+import { ZaloApiError } from "./ZaloApiError.js";
+export declare class ZaloApiMissingImageMetadataGetter extends ZaloApiError {
+    constructor();
+}

package/dist/Errors/ZaloApiMissingImageMetadataGetter.js

@@ -0,0 +1,7 @@
+import { ZaloApiError } from "./ZaloApiError.js";
+export class ZaloApiMissingImageMetadataGetter extends ZaloApiError {
+    constructor() {
+        super("Missing `imageMetadataGetter`. Please provide it in the Zalo object options.");
+        this.name = "ZaloApiMissingImageMetadataGetter";
+    }
+}

package/dist/Errors/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./ZaloApiError.js";
+export * from "./ZaloApiMissingImageMetadataGetter.js";
+export * from "./ZaloApiLoginQRAborted.js";
+export * from "./ZaloApiLoginQRDeclined.js";

package/dist/Errors/index.js

@@ -0,0 +1,4 @@
+export * from "./ZaloApiError.js";
+export * from "./ZaloApiMissingImageMetadataGetter.js";
+export * from "./ZaloApiLoginQRAborted.js";
+export * from "./ZaloApiLoginQRDeclined.js";

package/dist/apis/acceptFriendRequest.d.ts

@@ -0,0 +1,2 @@
+export type AcceptFriendRequestResponse = '';
+export declare const acceptFriendRequestFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").ZaloAPI) => (userId: string) => Promise<"">;

package/dist/apis/acceptFriendRequest.js

@@ -0,0 +1,28 @@
+import { ZaloApiError } from '../Errors/ZaloApiError.js';
+import { apiFactory } from '../utils.js';
+export const acceptFriendRequestFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/accept`);
+    /**
+     * Accept a friend request from a User
+     *
+     * @param userId The User ID to friend request is accept
+     *
+     * @throws ZaloApiError
+     */
+    return async function acceptFriendRequest(userId) {
+        const params = {
+            fid: userId,
+            language: ctx.language,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError('Failed to encrypt params');
+        const response = await utils.request(serviceURL, {
+            method: 'POST',
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/addGroupBlockedMember.d.ts

@@ -0,0 +1,2 @@
+export type AddGroupBlockedMemberResponse = '';
+export declare const addGroupBlockedMemberFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").ZaloAPI) => (memberId: string | string[], groupId: string) => Promise<"">;

package/dist/apis/addGroupBlockedMember.js

@@ -0,0 +1,28 @@
+import { ZaloApiError } from '../Errors/ZaloApiError.js';
+import { apiFactory } from '../utils.js';
+export const addGroupBlockedMemberFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/blockedmems/add`);
+    /**
+     * Add group blocked member
+     *
+     * @param memberId member id(s)
+     * @param groupId group id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function addGroupBlockedMember(memberId, groupId) {
+        if (!Array.isArray(memberId))
+            memberId = [memberId];
+        const params = {
+            grid: groupId,
+            members: memberId,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError('Failed to encrypt params');
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: 'GET',
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/addGroupDeputy.d.ts

@@ -0,0 +1,2 @@
+export type AddGroupDeputyResponse = '';
+export declare const addGroupDeputyFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").ZaloAPI) => (memberId: string | string[], groupId: string) => Promise<"">;

package/dist/apis/addGroupDeputy.js

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

package/dist/apis/addPollOptions.d.ts

@@ -0,0 +1,14 @@
+import type { PollOptions } from '../models/index.js';
+export type AddPollOptionsOption = {
+    voted: boolean;
+    content: string;
+};
+export type AddPollOptionsPayload = {
+    pollId: number;
+    options: AddPollOptionsOption[];
+    votedOptionIds: number[];
+};
+export type AddPollOptionsResponse = {
+    options: PollOptions[];
+};
+export declare const addPollOptionsFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").ZaloAPI) => (payload: AddPollOptionsPayload) => Promise<AddPollOptionsResponse>;

package/dist/apis/addPollOptions.js

@@ -0,0 +1,26 @@
+import { ZaloApiError } from '../Errors/ZaloApiError.js';
+import { apiFactory } from '../utils.js';
+export const addPollOptionsFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/poll/option/add`);
+    /**
+     * Add new option to poll
+     *
+     * @param payload
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function addPollOptions(payload) {
+        const params = {
+            poll_id: payload.pollId,
+            new_options: JSON.stringify(payload.options),
+            voted_option_ids: payload.votedOptionIds,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError('Failed to encrypt params');
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: 'GET',
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/addQuickMessage.d.ts

@@ -0,0 +1,11 @@
+import type { QuickMessage } from '../models/index.js';
+export type AddQuickMessagePayload = {
+    keyword: string;
+    title: string;
+    media?: string;
+};
+export type AddQuickMessageResponse = {
+    item: QuickMessage;
+    version: number;
+};
+export declare const addQuickMessageFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").ZaloAPI) => (addPayload: AddQuickMessagePayload) => Promise<AddQuickMessageResponse>;

package/dist/apis/addQuickMessage.js

@@ -0,0 +1,60 @@
+import { ZaloApiError } from '../Errors/ZaloApiError.js';
+import { apiFactory } from '../utils.js';
+export const addQuickMessageFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.quick_message[0]}/api/quickmessage/create`);
+    /**
+     * Add quick message
+     *
+     * @param addPayload - The payload containing data to add the quick message
+     *
+     * @note Zalo might throw an error with code 821 if you have reached the limit of quick messages.
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function addQuickMessage(addPayload) {
+        const isType = !addPayload.media ? 0 : 1;
+        const params = {
+            keyword: addPayload.keyword,
+            message: {
+                title: addPayload.title,
+                params: '',
+            },
+            type: isType,
+            imei: ctx.imei,
+        };
+        if (isType === 1) {
+            if (!addPayload.media)
+                throw new ZaloApiError('Media is required');
+            const uploadMedia = await api.uploadProductPhoto({
+                url: addPayload.media,
+            });
+            const photoId = uploadMedia.photoId;
+            const thumbUrl = uploadMedia.thumbUrl;
+            const normalUrl = uploadMedia.normalUrl;
+            const hdUrl = uploadMedia.hdUrl;
+            params.media = {
+                items: [
+                    {
+                        type: 0,
+                        photoId: photoId,
+                        title: '',
+                        width: '',
+                        height: '',
+                        previewThumb: thumbUrl,
+                        rawUrl: normalUrl || hdUrl,
+                        thumbUrl: thumbUrl,
+                        normalUrl: normalUrl || hdUrl,
+                        hdUrl: hdUrl || normalUrl,
+                    },
+                ],
+            };
+        }
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError('Failed to encrypt params');
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: 'GET',
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/addReaction.d.ts

@@ -0,0 +1,19 @@
+import { ThreadType } from '../models/Enum.js';
+import { Reactions } from '../models/Reaction.js';
+export type AddReactionResponse = {
+    msgIds: number[];
+};
+export type CustomReaction = {
+    rType: number;
+    source: number;
+    icon: string;
+};
+export type AddReactionDestination = {
+    data: {
+        msgId: string;
+        cliMsgId: string;
+    };
+    threadId: string;
+    type: ThreadType;
+};
+export declare const addReactionFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").ZaloAPI) => (icon: Reactions | CustomReaction, dest: AddReactionDestination) => Promise<AddReactionResponse>;

package/dist/apis/addReaction.js

@@ -0,0 +1,292 @@
+import { ZaloApiError } from '../Errors/ZaloApiError.js';
+import { ThreadType } from '../models/Enum.js';
+import { Reactions } from '../models/Reaction.js';
+import { apiFactory } from '../utils.js';
+export const addReactionFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURLs = {
+        [ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.reaction[0]}/api/message/reaction`),
+        [ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.reaction[0]}/api/group/reaction`),
+    };
+    /**
+     * Add reaction to a message
+     *
+     * @param icon Reaction icon
+     * @param dest Destination data including message IDs and thread information
+     *
+     * @throws ZaloApiError
+     */
+    return async function addReaction(icon, dest) {
+        const serviceURL = serviceURLs[dest.type];
+        let rType, source;
+        if (typeof icon == 'object') {
+            rType = icon.rType;
+            source = icon.source;
+        }
+        else
+            switch (icon) {
+                case Reactions.HAHA:
+                    rType = 0;
+                    source = 6;
+                    break;
+                case Reactions.LIKE:
+                    rType = 3;
+                    source = 6;
+                    break;
+                case Reactions.HEART:
+                    rType = 5;
+                    source = 6;
+                    break;
+                case Reactions.WOW:
+                    rType = 32;
+                    source = 6;
+                    break;
+                case Reactions.CRY:
+                    rType = 2;
+                    source = 6;
+                    break;
+                case Reactions.ANGRY:
+                    rType = 20;
+                    source = 6;
+                    break;
+                case Reactions.KISS:
+                    rType = 8;
+                    source = 6;
+                    break;
+                case Reactions.TEARS_OF_JOY:
+                    rType = 7;
+                    source = 6;
+                    break;
+                case Reactions.SHIT:
+                    rType = 66;
+                    source = 6;
+                    break;
+                case Reactions.ROSE:
+                    rType = 120;
+                    source = 6;
+                    break;
+                case Reactions.BROKEN_HEART:
+                    rType = 65;
+                    source = 6;
+                    break;
+                case Reactions.DISLIKE:
+                    rType = 4;
+                    source = 6;
+                    break;
+                case Reactions.LOVE:
+                    rType = 29;
+                    source = 6;
+                    break;
+                case Reactions.CONFUSED:
+                    rType = 51;
+                    source = 6;
+                    break;
+                case Reactions.WINK:
+                    rType = 45;
+                    source = 6;
+                    break;
+                case Reactions.FADE:
+                    rType = 121;
+                    source = 6;
+                    break;
+                case Reactions.SUN:
+                    rType = 67;
+                    source = 6;
+                    break;
+                case Reactions.BIRTHDAY:
+                    rType = 126;
+                    source = 6;
+                    break;
+                case Reactions.BOMB:
+                    rType = 127;
+                    source = 6;
+                    break;
+                case Reactions.OK:
+                    rType = 68;
+                    source = 6;
+                    break;
+                case Reactions.PEACE:
+                    rType = 69;
+                    source = 6;
+                    break;
+                case Reactions.THANKS:
+                    rType = 70;
+                    source = 6;
+                    break;
+                case Reactions.PUNCH:
+                    rType = 71;
+                    source = 6;
+                    break;
+                case Reactions.SHARE:
+                    rType = 72;
+                    source = 6;
+                    break;
+                case Reactions.PRAY:
+                    rType = 73;
+                    source = 6;
+                    break;
+                case Reactions.NO:
+                    rType = 131;
+                    source = 6;
+                    break;
+                case Reactions.BAD:
+                    rType = 132;
+                    source = 6;
+                    break;
+                case Reactions.LOVE_YOU:
+                    rType = 133;
+                    source = 6;
+                    break;
+                case Reactions.SAD:
+                    rType = 1;
+                    source = 6;
+                    break;
+                case Reactions.VERY_SAD:
+                    rType = 16;
+                    source = 6;
+                    break;
+                case Reactions.COOL:
+                    rType = 21;
+                    source = 6;
+                    break;
+                case Reactions.NERD:
+                    rType = 22;
+                    source = 6;
+                    break;
+                case Reactions.BIG_SMILE:
+                    rType = 23;
+                    source = 6;
+                    break;
+                case Reactions.SUNGLASSES:
+                    rType = 26;
+                    source = 6;
+                    break;
+                case Reactions.NEUTRAL:
+                    rType = 30;
+                    source = 6;
+                    break;
+                case Reactions.SAD_FACE:
+                    rType = 35;
+                    source = 6;
+                    break;
+                case Reactions.BYE:
+                    rType = 36;
+                    source = 6;
+                    break;
+                case Reactions.SLEEPY:
+                    rType = 38;
+                    source = 6;
+                    break;
+                case Reactions.WIPE:
+                    rType = 39;
+                    source = 6;
+                    break;
+                case Reactions.DIG:
+                    rType = 42;
+                    source = 6;
+                    break;
+                case Reactions.ANGUISH:
+                    rType = 44;
+                    source = 6;
+                    break;
+                case Reactions.HANDCLAP:
+                    rType = 46;
+                    source = 6;
+                    break;
+                case Reactions.ANGRY_FACE:
+                    rType = 47;
+                    source = 6;
+                    break;
+                case Reactions.F_CHAIR:
+                    rType = 48;
+                    source = 6;
+                    break;
+                case Reactions.L_CHAIR:
+                    rType = 49;
+                    source = 6;
+                    break;
+                case Reactions.R_CHAIR:
+                    rType = 50;
+                    source = 6;
+                    break;
+                case Reactions.SILENT:
+                    rType = 52;
+                    source = 6;
+                    break;
+                case Reactions.SURPRISE:
+                    rType = 53;
+                    source = 6;
+                    break;
+                case Reactions.EMBARRASSED:
+                    rType = 54;
+                    source = 6;
+                    break;
+                case Reactions.AFRAID:
+                    rType = 60;
+                    source = 6;
+                    break;
+                case Reactions.SAD2:
+                    rType = 61;
+                    source = 6;
+                    break;
+                case Reactions.BIG_LAUGH:
+                    rType = 62;
+                    source = 6;
+                    break;
+                case Reactions.RICH:
+                    rType = 63;
+                    source = 6;
+                    break;
+                case Reactions.BEER:
+                    rType = 99;
+                    source = 6;
+                    break;
+                default:
+                    rType = -1;
+                    source = 6;
+            }
+        const params = {
+            react_list: [
+                {
+                    message: JSON.stringify({
+                        rMsg: [
+                            {
+                                gMsgID: parseInt(dest.data.msgId),
+                                cMsgID: parseInt(dest.data.cliMsgId),
+                                msgType: 1,
+                            },
+                        ],
+                        rIcon: icon,
+                        rType,
+                        source,
+                    }),
+                    clientId: Date.now(),
+                },
+            ],
+            imei: ctx.imei,
+        };
+        if (dest.type == ThreadType.User) {
+            params.toid = dest.threadId;
+        }
+        else {
+            params.grid = dest.threadId;
+            params.imei = ctx.imei;
+        }
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError('Failed to encrypt message');
+        const response = await utils.request(serviceURL, {
+            method: 'POST',
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response, (result) => {
+            if (typeof result.data.msgIds === 'string') {
+                return {
+                    msgIds: JSON.parse(result.data.msgIds),
+                };
+            }
+            return result.data;
+        });
+    };
+});

package/dist/apis/addUnreadMark.d.ts

@@ -0,0 +1,8 @@
+import { ThreadType } from '../models/index.js';
+export type AddUnreadMarkResponse = {
+    data: {
+        updateId: number;
+    };
+    status: number;
+};
+export declare const addUnreadMarkFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").ZaloAPI) => (threadId: string, type?: ThreadType) => Promise<AddUnreadMarkResponse>;

package/dist/apis/addUnreadMark.js

@@ -0,0 +1,52 @@
+import { ZaloApiError } from '../Errors/ZaloApiError.js';
+import { ThreadType } from '../models/index.js';
+import { apiFactory } from '../utils.js';
+export const addUnreadMarkFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.conversation[0]}/api/conv/addUnreadMark`);
+    /**
+     * Add unread mark to conversation
+     *
+     * @param threadId Thread ID
+     * @param type Thread type (User/Group)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function addUnreadMark(threadId, type = ThreadType.User) {
+        const timestamp = Date.now();
+        const timestampString = timestamp.toString();
+        const isGroup = type === ThreadType.Group;
+        const requestParams = {
+            param: JSON.stringify({
+                [isGroup ? 'convsGroup' : 'convsUser']: [
+                    {
+                        id: threadId,
+                        cliMsgId: timestampString,
+                        fromUid: '0',
+                        ts: timestamp,
+                    },
+                ],
+                [isGroup ? 'convsUser' : 'convsGroup']: [],
+                imei: ctx.imei,
+            }),
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(requestParams));
+        if (!encryptedParams)
+            throw new ZaloApiError('Failed to encrypt params');
+        const response = await utils.request(serviceURL, {
+            method: 'POST',
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response, (result) => {
+            const data = result.data;
+            if (typeof data.data === 'string') {
+                return {
+                    data: JSON.parse(data.data),
+                    status: data.status,
+                };
+            }
+            return result.data;
+        });
+    };
+});

package/dist/apis/addUserToGroup.d.ts

@@ -0,0 +1,5 @@
+export type AddUserToGroupResponse = {
+    errorMemebers: string[];
+    error_data: Record<string, any>;
+};
+export declare const addUserToGroupFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").ZaloAPI) => (groupId: string, members: string | string[]) => Promise<AddUserToGroupResponse>;