@softtynet/zca-js 2.3.3 → 2.3.5

package/dist/apis/friend/getFriendProfilesV2.js

@@ -0,0 +1,38 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const getFriendProfilesV2Factory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/friend/getprofiles/v2`);
+    /**
+     * Lấy hàng loạt hồ sơ chi tiết của danh sách bạn bè kèm trạng thái online qua `/api/social/friend/getprofiles/v2` (command 11140)
+     *
+     * @param friendIds Mảng UID cần lấy hồ sơ (có thể kèm hậu tố `_version` hoặc truyền UID thuần)
+     * @param options Tùy chọn truy vấn
+     * @throws {ZaloApiError}
+     */
+    return async function getFriendProfilesV2(friendIds, options = {}) {
+        const rawIds = Array.isArray(friendIds) ? friendIds : [friendIds];
+        if (rawIds.length === 0) {
+            throw new ZaloApiError("Missing friendIds");
+        }
+        const friendPversionMap = rawIds.map((id) => (id.includes("_") ? id : `${id}_0`));
+        const params = {
+            phonebook_version: options.phonebookVersion ?? 0,
+            friend_pversion_map: friendPversionMap,
+            avatar_size: options.avatarSize ?? 120,
+            language: options.language ?? ctx.language ?? "vi",
+            show_online_status: options.showOnlineStatus !== false ? 1 : 0,
+            imei: ctx.imei,
+        };
+        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/friend/getFriendsActivePCWeb.d.ts

@@ -0,0 +1,6 @@
+export type GetFriendsActivePCWebResponse = {
+    uids?: string[];
+    activeUsers?: unknown[];
+    [key: string]: unknown;
+};
+export declare const getFriendsActivePCWebFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => () => Promise<GetFriendsActivePCWebResponse>;

package/dist/apis/friend/getFriendsActivePCWeb.js

@@ -0,0 +1,15 @@
+import { apiFactory } from "../../utils.js";
+export const getFriendsActivePCWebFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/friend/active-pcweb`);
+    /**
+     * Lấy danh sách bạn bè đang hoạt động trên Zalo PC / Web qua `/api/social/friend/active-pcweb` (command 12072)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getFriendsActivePCWeb() {
+        const response = await utils.request(serviceURL, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/friend/verifyFriend.d.ts

@@ -0,0 +1,11 @@
+export type VerifyFriendOptions = {
+    phonebookVersion?: number;
+    avatarSize?: number;
+    language?: string;
+};
+export type VerifyFriendResponse = {
+    profiles?: Record<string, unknown>;
+    unchangeds_profile?: string[];
+    [key: string]: unknown;
+};
+export declare const verifyFriendFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (friendIds: string | string[], options?: VerifyFriendOptions) => Promise<VerifyFriendResponse>;

package/dist/apis/friend/verifyFriend.js

@@ -0,0 +1,37 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const verifyFriendFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/friend/verify`);
+    /**
+     * Kiểm tra và xác thực danh sách bạn bè qua `/api/social/friend/verify` (command 11138)
+     *
+     * @param friendIds Danh sách UID bạn bè cần xác thực
+     * @param options Tùy chọn truy vấn
+     * @throws {ZaloApiError}
+     */
+    return async function verifyFriend(friendIds, options = {}) {
+        const rawIds = Array.isArray(friendIds) ? friendIds : [friendIds];
+        if (rawIds.length === 0) {
+            throw new ZaloApiError("Missing friendIds");
+        }
+        const friendPversionMap = rawIds.map((id) => (id.includes("_") ? id : `${id}_0`));
+        const params = {
+            phonebook_version: options.phonebookVersion ?? 0,
+            friend_pversion_map: friendPversionMap,
+            avatar_size: options.avatarSize ?? 120,
+            language: options.language ?? ctx.language ?? "vi",
+            imei: ctx.imei,
+        };
+        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/group/analyseGroup.d.ts

@@ -0,0 +1,4 @@
+export type AnalyseGroupResponse = {
+    [key: string]: unknown;
+};
+export declare const analyseGroupFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (groupId: string) => Promise<AnalyseGroupResponse>;

package/dist/apis/group/analyseGroup.js

@@ -0,0 +1,28 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const analyseGroupFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/analyse`);
+    /**
+     * Lấy dữ liệu phân tích/thống kê của nhóm qua `/api/group/analyse` (command 12407)
+     *
+     * @param groupId ID của nhóm
+     * @throws {ZaloApiError}
+     */
+    return async function analyseGroup(groupId) {
+        if (!groupId) {
+            throw new ZaloApiError("Missing groupId");
+        }
+        const cleanGroupId = groupId.startsWith("g") ? groupId.slice(1) : groupId;
+        const params = {
+            grid: cleanGroupId,
+        };
+        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/group/checkQuotaCommunityMember.d.ts

@@ -0,0 +1,6 @@
+export type CheckQuotaCommunityMemberResponse = {
+    status?: number;
+    canUpgrade?: boolean | number;
+    [key: string]: unknown;
+};
+export declare const checkQuotaCommunityMemberFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (groupId: string, uid: string) => Promise<CheckQuotaCommunityMemberResponse>;

package/dist/apis/group/checkQuotaCommunityMember.js

@@ -0,0 +1,34 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const checkQuotaCommunityMemberFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/quota/members-comm`);
+    /**
+     * Kiểm tra điều kiện/hạn mức thành viên Cộng đồng đối với một thành viên cụ thể trong nhóm (command 12182)
+     *
+     * @param groupId ID của nhóm
+     * @param uid UID của thành viên cần kiểm tra
+     * @throws {ZaloApiError}
+     */
+    return async function checkQuotaCommunityMember(groupId, uid) {
+        if (!groupId) {
+            throw new ZaloApiError("Missing groupId");
+        }
+        if (!uid) {
+            throw new ZaloApiError("Missing uid");
+        }
+        const cleanGroupId = groupId.startsWith("g") ? groupId.slice(1) : groupId;
+        const params = {
+            language: ctx.language || "vi",
+            grId: cleanGroupId,
+            uid: String(uid),
+        };
+        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/group/getE2eeGroupList.d.ts

@@ -0,0 +1,7 @@
+export type GetE2eeGroupListResponse = {
+    version?: number;
+    gridVerMap?: Record<string, string>;
+    e2eeGroups?: string[];
+    [key: string]: unknown;
+};
+export declare const getE2eeGroupListFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => () => Promise<GetE2eeGroupListResponse>;

package/dist/apis/group/getE2eeGroupList.js

@@ -0,0 +1,15 @@
+import { apiFactory } from "../../utils.js";
+export const getE2eeGroupListFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/getlg/e2ee`);
+    /**
+     * Lấy danh sách các nhóm đang bật mã hóa đầu cuối E2EE (command 12146)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getE2eeGroupList() {
+        const response = await utils.request(serviceURL, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/group/getGroupCloudMessagePath.d.ts

@@ -0,0 +1,19 @@
+import { GroupMessage } from "../../models/index.js";
+export type GetGroupCloudMessagePathOptions = {
+    groupId: string;
+    globalMsgId: string | number;
+    count?: number;
+    reverse?: number | boolean;
+    rGlobalMsgId?: string | number;
+    rOwnerId?: string;
+    rClientMsgId?: string | number;
+};
+export type GetGroupCloudMessagePathResponse = {
+    lastMsgId?: string | number;
+    minMsgId?: string | number;
+    maxMsgId?: string | number;
+    hasMore?: boolean;
+    groupMsgs: GroupMessage[];
+    [key: string]: unknown;
+};
+export declare const getGroupCloudMessagePathFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (options: GetGroupCloudMessagePathOptions) => Promise<GetGroupCloudMessagePathResponse>;

package/dist/apis/group/getGroupCloudMessagePath.js

@@ -0,0 +1,51 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { GroupMessage } from "../../models/index.js";
+import { apiFactory, preParseJsonIds } from "../../utils.js";
+export const getGroupCloudMessagePathFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group_cloud_message[0]}/api/cm/getpath`);
+    /**
+     * Lấy chuỗi tin nhắn nhóm theo đường dẫn nhảy tới một tin nhắn cụ thể (`globalMsgId` / `rGlobalMsgId`) qua `/api/cm/getpath` (command 12504)
+     *
+     * @param options Cấu hình truy vấn đường dẫn tin nhắn nhóm
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupCloudMessagePath(options) {
+        if (!options?.groupId) {
+            throw new ZaloApiError("Missing groupId");
+        }
+        const cleanGroupId = options.groupId.startsWith("g") ? options.groupId.slice(1) : options.groupId;
+        const params = {
+            groupId: cleanGroupId,
+            globalMsgId: options.globalMsgId,
+            count: options.count ?? 50,
+            reverse: typeof options.reverse === "boolean" ? (options.reverse ? 1 : 0) : (options.reverse ?? 0),
+        };
+        if (options.rGlobalMsgId !== undefined && options.rOwnerId) {
+            params.rGlobalMsgId = options.rGlobalMsgId;
+            params.rOwnerId = options.rOwnerId;
+            if (options.rClientMsgId !== undefined) {
+                params.rClientMsgId = options.rClientMsgId;
+            }
+        }
+        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, nretry: 0 }), {
+            method: "GET",
+        });
+        return utils.resolve(response, (result) => {
+            let data = result.data;
+            if (typeof data === "string") {
+                data = JSON.parse(preParseJsonIds(data));
+            }
+            const rawObj = (data && typeof data === "object" ? data : {});
+            const rawMsgs = Array.isArray(rawObj.groupMsgs) ? rawObj.groupMsgs : [];
+            const groupMsgs = rawMsgs.map((m) => new GroupMessage(ctx.uid, m));
+            return {
+                ...rawObj,
+                groupMsgs,
+            };
+        });
+    };
+});

package/dist/apis/group/getMultiGroupCloudMessages.d.ts

@@ -0,0 +1,5 @@
+export type GetMultiGroupCloudMessagesResponse = {
+    groupMsgs?: Record<string, unknown[]>;
+    [key: string]: unknown;
+};
+export declare const getMultiGroupCloudMessagesFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (groupIds: string[], nretry?: number) => Promise<GetMultiGroupCloudMessagesResponse>;

package/dist/apis/group/getMultiGroupCloudMessages.js

@@ -0,0 +1,29 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const getMultiGroupCloudMessagesFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group_cloud_message[0]}/api/cm/mget`);
+    /**
+     * Đồng bộ nhanh tin nhắn Cloud của nhiều nhóm cùng lúc theo danh sách `groupIds` (command 12503 - `syncCloudMsgFirstLogin`)
+     *
+     * @param groupIds Danh sách ID nhóm cần tải tin nhắn Cloud
+     * @param nretry Số lần thử lại (mặc định: `0`)
+     * @throws {ZaloApiError}
+     */
+    return async function getMultiGroupCloudMessages(groupIds, nretry = 0) {
+        if (!Array.isArray(groupIds) || groupIds.length === 0) {
+            throw new ZaloApiError("Missing groupIds");
+        }
+        const cleanGroupIds = groupIds.map((gid) => (gid.startsWith("g") ? gid.slice(1) : gid));
+        const params = {
+            groupIds: cleanGroupIds,
+        };
+        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, nretry }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/media/getPersonalMedia.d.ts

@@ -0,0 +1,8 @@
+import type { GetConversationMediaResponse, MediaStoreType } from "./getConversationMedia.js";
+export type GetPersonalMediaOptions = {
+    mediaType?: MediaStoreType;
+    limit?: number;
+    lastId?: number | string;
+    lastFetchId?: number;
+};
+export declare const getPersonalMediaFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (options?: GetPersonalMediaOptions) => Promise<GetConversationMediaResponse>;

package/dist/apis/media/getPersonalMedia.js

@@ -0,0 +1,31 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const getPersonalMediaFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.media_store_send2me[0]}/api/media/oneone/list`);
+    /**
+     * Lấy danh sách Kho Lưu Trữ Ảnh/Video (`"media"`), File (`"file"`), hoặc Link (`"link"`) trong Cloud của tôi (Send2Me) (command 12220)
+     *
+     * @param options Tùy chọn truy vấn (`mediaType`, `limit`, `lastId`, `lastFetchId`)
+     * @throws {ZaloApiError}
+     */
+    return async function getPersonalMedia(options = {}) {
+        const params = {
+            media_type: options.mediaType ?? "media",
+            limit: options.limit ?? 20,
+        };
+        if (options.lastId !== undefined) {
+            params.last_id = options.lastId;
+        }
+        if (options.lastFetchId !== undefined && !Number.isNaN(options.lastFetchId)) {
+            params.lastFetchId = options.lastFetchId;
+        }
+        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/media/getPersonalMediaPreview.d.ts

@@ -0,0 +1,3 @@
+import type { MediaStoreItem } from "./getConversationMedia.js";
+export type GetPersonalMediaPreviewResponse = MediaStoreItem[];
+export declare const getPersonalMediaPreviewFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (limit?: number) => Promise<GetPersonalMediaPreviewResponse>;

package/dist/apis/media/getPersonalMediaPreview.js

@@ -0,0 +1,24 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const getPersonalMediaPreviewFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.media_store_send2me[0]}/api/media/oneone/preview`);
+    /**
+     * Lấy danh sách xem trước nhanh Kho Lưu Trữ trong Cloud của tôi (Send2Me) (command 12221)
+     *
+     * @param limit Số lượng mục tối đa (mặc định: `50`)
+     * @throws {ZaloApiError}
+     */
+    return async function getPersonalMediaPreview(limit = 50) {
+        const params = {
+            limit,
+        };
+        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",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/media/removePersonalMedia.d.ts

@@ -0,0 +1,9 @@
+import type { MediaStoreType } from "./getConversationMedia.js";
+export type RemovePersonalMediaOptions = {
+    mediaType: MediaStoreType;
+    mediaId: number | string | Array<number | string>;
+};
+export type RemovePersonalMediaResponse = {
+    [key: string]: unknown;
+};
+export declare const removePersonalMediaFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (options: RemovePersonalMediaOptions) => Promise<RemovePersonalMediaResponse>;

package/dist/apis/media/removePersonalMedia.js

@@ -0,0 +1,28 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const removePersonalMediaFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.media_store_send2me[0]}/api/media/oneone/remove`);
+    /**
+     * Xóa mục lưu trữ trong Kho Lưu Trữ Cloud của tôi (Send2Me) (command 12222)
+     *
+     * @param options Thông tin mục cần xóa (`mediaType`, `mediaId`)
+     * @throws {ZaloApiError}
+     */
+    return async function removePersonalMedia(options) {
+        if (!options?.mediaType || options.mediaId === undefined) {
+            throw new ZaloApiError("Missing mediaType or mediaId");
+        }
+        const params = {
+            media_type: options.mediaType,
+            media_id: options.mediaId,
+        };
+        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",
+        });
+        return utils.resolve(response);
+    };
+});