@softtynet/zca-js 2.2.8 → 2.2.10

package/dist/apis/business/updateProductCatalog.js

@@ -0,0 +1,51 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const updateProductCatalogFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.catalog[0]}/api/prodcatalog/product/update`);
+    /**
+     * Update product catalog?
+     *
+     * @param payload payload
+     *
+     * @note this API is used for zBusiness - Maximum 5 media files are supported
+     * @throws {ZaloApiError}
+     */
+    return async function updateProductCatalog(payload) {
+        const productPhoto = payload.product_photos || [];
+        if (payload.files && payload.files.length == 0) {
+            if (payload.files.length > 5) {
+                throw new 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("Maximum 5 media files are allowed");
+        }
+        const params = {
+            product_id: payload.productId,
+            product_name: payload.productName,
+            price: payload.price,
+            description: payload.description,
+            product_photos: productPhoto,
+            catalog_id: payload.catalogId,
+            currency_unit: "₫",
+            create_time: payload.createTime,
+        };
+        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/business/updateQuickMessage.d.ts

@@ -0,0 +1,11 @@
+import type { QuickMessage, AttachmentSource } from "../../models/index.js";
+export type UpdateQuickMessagePayload = {
+    keyword: string;
+    title: string;
+    media?: AttachmentSource;
+};
+export type UpdateQuickMessageResponse = {
+    item: QuickMessage;
+    version: number;
+};
+export declare const updateQuickMessageFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (updatePayload: UpdateQuickMessagePayload, itemId: number) => Promise<UpdateQuickMessageResponse>;

package/dist/apis/business/updateQuickMessage.js

@@ -0,0 +1,61 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const updateQuickMessageFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.quick_message[0]}/api/quickmessage/update`);
+    /**
+     * Update quick message
+     *
+     * @param updatePayload - The payload containing data to update the quick message
+     * @param itemId - The id of the quick message to update
+     *
+     * @note Zalo might throw an error with code 212 if the itemId does not exist.
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function updateQuickMessage(updatePayload, itemId) {
+        const isType = !updatePayload.media ? 0 : 1;
+        const params = {
+            itemId: itemId,
+            keyword: updatePayload.keyword,
+            message: {
+                title: updatePayload.title,
+                params: "",
+            },
+            type: isType,
+        };
+        if (isType === 1) {
+            if (!updatePayload.media)
+                throw new ZaloApiError("Media is required");
+            const uploadMedia = await api.uploadProductPhoto({
+                file: updatePayload.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/business/uploadProductPhoto.d.ts

@@ -0,0 +1,14 @@
+import type { AttachmentSource } from "../../models/index.js";
+export type UploadProductPhotoPayload = {
+    file: AttachmentSource;
+};
+export type UploadProductPhotoResponse = {
+    normalUrl: string;
+    photoId: string;
+    finished: number;
+    hdUrl: string;
+    thumbUrl: string;
+    clientFileId: number;
+    chunkId: number;
+};
+export declare const uploadProductPhotoFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (payload: UploadProductPhotoPayload) => Promise<UploadProductPhotoResponse>;

package/dist/apis/business/uploadProductPhoto.js

@@ -0,0 +1,50 @@
+import fs from "node:fs";
+import FormData from "form-data";
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory, getImageMetaData } from "../../utils.js";
+export const uploadProductPhotoFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.file[0]}/api/product/upload/photo`);
+    /**
+     * Upload product photo for api quick message, product catalog or custom local storage
+     *
+     * @param payload file path or attachment source
+     *
+     * @throws {ZaloApiError | ZaloApiMissingImageMetadataGetter}
+     */
+    return async function uploadProductPhoto(payload) {
+        const isSourceFilePath = typeof payload.file == "string";
+        const fileMetaData = isSourceFilePath
+            ? await getImageMetaData(ctx, payload.file)
+            : payload.file.metadata;
+        const fileSize = fileMetaData.totalSize || 0;
+        const fileBuffer = isSourceFilePath
+            ? await fs.promises.readFile(payload.file)
+            : payload.file.data;
+        const formData = new FormData();
+        formData.append("chunkContent", fileBuffer, {
+            filename: "undefined",
+            contentType: "application/octet-stream",
+        });
+        const params = {
+            totalChunk: 1,
+            fileName: `Base64_Img_Picker_${Date.now()}.jpg`,
+            clientId: Date.now(),
+            totalSize: fileSize,
+            imei: ctx.imei,
+            chunkId: 1,
+            toid: ctx.loginInfo.send2me_id,
+            featureId: 1,
+        };
+        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: "POST",
+            headers: formData.getHeaders(),
+            body: formData.getBuffer(),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/call/cancelVoiceCall.d.ts

@@ -0,0 +1,7 @@
+import { CallType } from "./sendVoiceCall.js";
+export type CancelVoiceCallOptions = {
+    callType?: CallType;
+    status?: number;
+};
+export type CancelVoiceCallResponse = Record<string, unknown>;
+export declare const cancelVoiceCallFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (calleeId: string, callId: number, options?: CancelVoiceCallOptions) => Promise<CancelVoiceCallResponse>;

package/dist/apis/call/cancelVoiceCall.js

@@ -0,0 +1,40 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+import { CallType } from "./sendVoiceCall.js";
+export const cancelVoiceCallFactory = apiFactory()((api, ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Huỷ cuộc gọi đang đổ chuông trước khi người nhận bắt máy (`/api/voicecall/cancel`, command `11305`).
+     *
+     * @param calleeId User ID của người nhận cuộc gọi
+     * @param callId ID của cuộc gọi (nhận từ `sendVoiceCall`)
+     * @param options Tuỳ chọn loại cuộc gọi (`callType`) và `status`
+     * @throws {ZaloApiError}
+     */
+    return async function cancelVoiceCall(calleeId, callId, options = {}) {
+        if (!calleeId)
+            throw new ZaloApiError("Missing calleeId");
+        if (!callId)
+            throw new ZaloApiError("Missing callId");
+        if (!voiceCallService)
+            throw new ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const params = {
+            callerId: String(calleeId),
+            callId,
+            callType: options.callType ?? CallType.Audio,
+            status: options.status ?? 0,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt cancelVoiceCall params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/cancel`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/call/endVoiceCall.d.ts

@@ -0,0 +1,5 @@
+export type EndVoiceCallOptions = {
+    status?: number;
+};
+export type EndVoiceCallResponse = Record<string, unknown>;
+export declare const endVoiceCallFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (calleeId: string, callId: number, options?: EndVoiceCallOptions) => Promise<EndVoiceCallResponse>;

package/dist/apis/call/endVoiceCall.js

@@ -0,0 +1,38 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const endVoiceCallFactory = apiFactory()((api, ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Kết thúc cuộc gọi thoại / video (`/api/voicecall/endcall`, command `11306`).
+     *
+     * @param calleeId User ID của đối phương
+     * @param callId ID của cuộc gọi
+     * @param options Tuỳ chọn mã trạng thái kết thúc (`status`, mặc định `3`)
+     * @throws {ZaloApiError}
+     */
+    return async function endVoiceCall(calleeId, callId, options = {}) {
+        if (!calleeId)
+            throw new ZaloApiError("Missing calleeId");
+        if (!callId)
+            throw new ZaloApiError("Missing callId");
+        if (!voiceCallService)
+            throw new ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const params = {
+            uidTo: String(calleeId),
+            callId,
+            status: options.status ?? 3,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt endVoiceCall params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/endcall`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/call/sendVoiceCall.d.ts

@@ -0,0 +1,44 @@
+export declare enum CallType {
+    Audio = 1,
+    Video = 3
+}
+export type SendVoiceCallOptions = {
+    callType?: CallType;
+    callId?: number;
+    codec?: string;
+};
+export type RequestCallServerEntry = {
+    rtpaddr?: string;
+    rtcpaddr?: string;
+    rtpIPv6?: string;
+    rtcpIPv6?: string;
+    spTcp?: number;
+    bonus?: number;
+    [key: string]: unknown;
+};
+export type RequestCallServerInfo = {
+    sessId: string;
+    rtpServer?: string;
+    rtcpServer?: string;
+    rtpIP?: string;
+    rtcpIP?: string;
+    rtpIPv6?: string;
+    rtcpIPv6?: string;
+    servers?: RequestCallServerEntry[];
+    zrtpKey?: string;
+    expiredTime?: number;
+    codec?: string;
+    [key: string]: unknown;
+};
+export type SendVoiceCallResponse = {
+    callId: number;
+    sessId: string;
+    rtpServer: string;
+    rtcpServer: string;
+    zrtpKey?: string;
+    expiredTime?: number;
+    codec?: string;
+    serverInfo?: RequestCallServerInfo;
+    requestResult?: unknown;
+};
+export declare const sendVoiceCallFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (calleeId: string, options?: SendVoiceCallOptions) => Promise<SendVoiceCallResponse>;

package/dist/apis/call/sendVoiceCall.js

@@ -0,0 +1,113 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory, resolveResponse } from "../../utils.js";
+export var CallType;
+(function (CallType) {
+    CallType[CallType["Audio"] = 1] = "Audio";
+    CallType[CallType["Video"] = 3] = "Video";
+})(CallType || (CallType = {}));
+function parseServerEndpoint(addr) {
+    if (!addr)
+        return { host: "", ip: "0.0.0.0", port: 0 };
+    const idx = addr.lastIndexOf(":");
+    if (idx === -1)
+        return { host: addr, ip: addr, port: 0 };
+    const ip = addr.slice(0, idx);
+    const port = Number.parseInt(addr.slice(idx + 1), 10) || 0;
+    return { host: addr, ip, port };
+}
+export const sendVoiceCallFactory = apiFactory()((api, ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Khởi tạo cuộc gọi thoại / video (Signaling 2 bước: `/api/voicecall/requestcall` command `11300`
+     * + `/api/voicecall/request` command `11301`) giúp đổ chuông trực tiếp trên thiết bị của người nhận.
+     *
+     * @param calleeId User ID của người nhận cuộc gọi
+     * @param options Tuỳ chọn loại cuộc gọi (`CallType.Audio` hoặc `CallType.Video`) và `callId`
+     * @throws {ZaloApiError}
+     */
+    return async function sendVoiceCall(calleeId, options = {}) {
+        if (!calleeId)
+            throw new ZaloApiError("Missing calleeId");
+        if (!voiceCallService)
+            throw new ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const callType = options.callType ?? CallType.Audio;
+        const callId = options.callId ?? Math.floor(Math.random() * 2_000_000_000);
+        const codec = options.codec ?? "[]";
+        const normalizedCalleeId = String(calleeId);
+        // Step 1: Allocate call session & RTP/RTCP relay endpoints (/api/voicecall/requestcall, command 11300)
+        const step1Params = {
+            calleeId: normalizedCalleeId,
+            callId,
+            codec,
+            typeRequest: callType,
+            imei: ctx.imei,
+        };
+        const encryptedStep1 = utils.encodeAES(JSON.stringify(step1Params));
+        if (!encryptedStep1)
+            throw new ZaloApiError("Failed to encrypt requestcall params");
+        const requestCallURL = utils.makeURL(`${voiceCallService}/api/voicecall/requestcall`, {
+            zpw_type: 24,
+            params: encryptedStep1,
+        });
+        const step1Res = await utils.request(requestCallURL, {
+            method: "GET",
+        });
+        const serverInfo = await resolveResponse(ctx, step1Res, (result) => {
+            const raw = result.data;
+            return typeof raw === "string" ? JSON.parse(raw) : raw;
+        });
+        const resolvedRtpServer = serverInfo?.rtpServer ?? serverInfo?.rtpIP ?? serverInfo?.servers?.[0]?.rtpaddr ?? "";
+        const resolvedRtcpServer = serverInfo?.rtcpServer ?? serverInfo?.rtcpIP ?? serverInfo?.servers?.[0]?.rtcpaddr ?? "";
+        const rtp = parseServerEndpoint(resolvedRtpServer);
+        const rtcp = parseServerEndpoint(resolvedRtcpServer);
+        const sessId = serverInfo?.sessId ?? `${normalizedCalleeId}_${callId}_401`;
+        const resolvedCodec = serverInfo?.codec ?? codec;
+        // Step 2: Send ringing signaling request (/api/voicecall/request, command 11301)
+        const isVideo = callType === CallType.Video;
+        const extendData = JSON.stringify({
+            callType: isVideo ? 1 : 0,
+            video: {
+                codec: isVideo ? [{ name: "h264", payload: 97 }] : [],
+            },
+            newZrtc: 1,
+            platform: 5,
+            rtcpDiff: 0,
+            rtcp: [{ ip: rtcp.ip, port: rtcp.port }],
+            rtp: [{ ip: rtp.ip, port: rtp.port }],
+            status: 0,
+        });
+        const step2Params = {
+            calleeId: normalizedCalleeId,
+            rtcpAddress: rtcp.host,
+            rtpAddress: rtp.host,
+            codec: resolvedCodec,
+            session: sessId,
+            callId,
+            imei: ctx.imei,
+            subCommand: 3,
+            extendData,
+        };
+        const encryptedStep2 = utils.encodeAES(JSON.stringify(step2Params));
+        if (!encryptedStep2)
+            throw new ZaloApiError("Failed to encrypt voicecall request params");
+        const requestURL = utils.makeURL(`${voiceCallService}/api/voicecall/request`, {
+            zpw_type: 24,
+            params: encryptedStep2,
+        });
+        const step2Res = await utils.request(requestURL, {
+            method: "GET",
+        });
+        const requestResult = await utils.resolve(step2Res);
+        return {
+            callId,
+            sessId,
+            rtpServer: resolvedRtpServer,
+            rtcpServer: resolvedRtcpServer,
+            zrtpKey: serverInfo?.zrtpKey,
+            expiredTime: serverInfo?.expiredTime,
+            codec: resolvedCodec,
+            serverInfo,
+            requestResult,
+        };
+    };
+});

package/dist/apis/chat/addReaction.d.ts

@@ -0,0 +1,18 @@
+import { ThreadType, Reactions } from "../../models/index.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").API) => (icon: Reactions | CustomReaction, dest: AddReactionDestination) => Promise<AddReactionResponse>;