n8n-nodes-zalo-nnt/dist/nodes/ZaloGroup/utils/groupProcessor.js

Unofficial Zalo integration for n8n - Send messages, manage groups, user operations with QR login. No API key required, works via browser simulation.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.resolveMemberIdentifiers = resolveMemberIdentifiers;
exports.processCreateGroup = processCreateGroup;
exports.processGetGroupInfo = processGetGroupInfo;
exports.processAddGroupDeputy = processAddGroupDeputy;
exports.processAddUserToGroup = processAddUserToGroup;
exports.processChangeGroupAvatar = processChangeGroupAvatar;
exports.processChangeGroupName = processChangeGroupName;
exports.processGetAllGroups = processGetAllGroups;
exports.processCreateNote = processCreateNote;
exports.processRemoveUserFromGroup = processRemoveUserFromGroup;
exports.processReplaceGroupMembers = processReplaceGroupMembers;
exports.processGetGroupChatHistory = processGetGroupChatHistory;
exports.processJoinGroupLink = processJoinGroupLink;
exports.processLeaveGroup = processLeaveGroup;
exports.processInviteUsers = processInviteUsers;
exports.processGetBlockedMembers = processGetBlockedMembers;
exports.processBlockMember = processBlockMember;
exports.processUnblockMember = processUnblockMember;
exports.processGetPendingRequests = processGetPendingRequests;
exports.processReviewPendingRequest = processReviewPendingRequest;
exports.processGetGroupLinkInfo = processGetGroupLinkInfo;
exports.processGetGroupLinkDetail = processGetGroupLinkDetail;
exports.processEnableGroupLink = processEnableGroupLink;
exports.processDisableGroupLink = processDisableGroupLink;
exports.processUpgradeGroupToCommunity = processUpgradeGroupToCommunity;
exports.processChangeGroupOwner = processChangeGroupOwner;
exports.processRemoveGroupDeputy = processRemoveGroupDeputy;
exports.processGetGroupMembersInfo = processGetGroupMembersInfo;
exports.processGetGroupInviteBoxInfo = processGetGroupInviteBoxInfo;
exports.processGetGroupInviteBoxList = processGetGroupInviteBoxList;
exports.processJoinGroupInviteBox = processJoinGroupInviteBox;
exports.processDeleteGroupInviteBox = processDeleteGroupInviteBox;
exports.processDisperseGroup = processDisperseGroup;
exports.processEditNote = processEditNote;
exports.processGetListBoard = processGetListBoard;
exports.processGetFriendBoardList = processGetFriendBoardList;
exports.processUpdateGroupSettings = processUpdateGroupSettings;
const zaloMessage_1 = require("../../utils/zaloMessage");
const validator_1 = require("./validator");
function normalizePhoneNumber(value) {
    const compact = value.replace(/[\s.-]/g, '').replace(/^\+/, '');
    return compact.startsWith('0') ? `84${compact.slice(1)}` : compact;
}
function classifyMemberIdentifier(value) {
    const compact = value.replace(/[\s.-]/g, '');
    if (/^(?:0\d{9}|\+?84\d{9})$/.test(compact)) {
        return 'phone';
    }
    if (/^\d{11,}$/.test(compact)) {
        return 'uid';
    }
    throw new Error(`Định danh thành viên không hợp lệ: ${value}`);
}
async function resolveMemberIdentifiers(api, identifiers) {
    (0, validator_1.validateUserIds)(identifiers);
    const values = (0, validator_1.parseUserIds)(identifiers);
    const resolved = [];
    for (const input of values) {
        const type = classifyMemberIdentifier(input);
        if (type === 'uid') {
            resolved.push({ input, type, uid: input.replace(/[\s.-]/g, '') });
            continue;
        }
        const phone = normalizePhoneNumber(input);
        const user = await api.findUser(phone);
        if (!(user === null || user === void 0 ? void 0 : user.uid)) {
            throw new Error(`Không tìm thấy UID Zalo cho số điện thoại: ${input}`);
        }
        resolved.push({ input, type, uid: user.uid });
    }
    return resolved;
}
function withResolvedMembers(response, resolvedMembers) {
    if (response && typeof response === 'object' && !Array.isArray(response)) {
        return { ...response, resolvedMembers };
    }
    return { response: response, resolvedMembers };
}
async function executeWithAdminPermissionCheck(operation, operationName) {
    var _a;
    try {
        return await operation();
    }
    catch (error) {
        const errorMessage = ((_a = error === null || error === void 0 ? void 0 : error.message) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || '';
        const isPermissionError = errorMessage.includes('tham số không hợp lệ') ||
            errorMessage.includes('invalid param') ||
            errorMessage.includes('không có quyền') ||
            errorMessage.includes('permission denied');
        if (isPermissionError) {
            throw new Error(`Không có quyền thực hiện thao tác "${operationName}". ` +
                `Bạn cần là Phó Nhóm hoặc Trưởng Nhóm mới có thể thực hiện thao tác này. ` +
                `Lỗi gốc: ${error.message}`);
        }
        throw error;
    }
}
async function processCreateGroup(api, params) {
    (0, validator_1.validateGroupName)(params.groupName);
    (0, validator_1.validateUserIds)(params.userIds);
    const resolvedMembers = await resolveMemberIdentifiers(api, params.userIds);
    const response = await api.createGroup({
        name: params.groupName,
        members: resolvedMembers.map((member) => member.uid),
    });
    return withResolvedMembers(response, resolvedMembers);
}
function extractUserIdsFromMemVerList(memVerList) {
    if (!memVerList || !Array.isArray(memVerList))
        return [];
    return memVerList.map((item) => item.split('_')[0]).filter(Boolean);
}
async function getUserInfoSafe(api, userId) {
    try {
        const userInfo = await api.getUserInfo(userId);
        if (userInfo && userInfo.changed_profiles && userInfo.changed_profiles[userId]) {
            const profile = userInfo.changed_profiles[userId];
            return {
                id: userId,
                displayName: profile.displayName || profile.zaloName || '',
                avatar: profile.avatar || '',
                zaloName: profile.zaloName || '',
                gender: profile.gender,
                phoneNumber: profile.phoneNumber || '',
                isFriend: profile.isFriend === 1,
                isBlocked: profile.isBlocked === 1,
                status: profile.status || '',
            };
        }
        return {
            id: userId,
            displayName: '',
            avatar: '',
        };
    }
    catch (error) {
        console.error(`Failed to get info for user ${userId}:`, error);
        return null;
    }
}
async function processGetGroupInfo(api, params) {
    (0, validator_1.validateGroupId)(params.groupId);
    const response = await api.getGroupInfo(params.groupId);
    const groupInfo = response.gridInfoMap[params.groupId];
    if (!params.includeMembers) {
        return {
            response,
            groupInfo,
        };
    }
    const memberIds = extractUserIdsFromMemVerList((groupInfo === null || groupInfo === void 0 ? void 0 : groupInfo.memVerList) || []);
    const limit = params.memberLimit || 100;
    const limitedMemberIds = memberIds.slice(0, limit);
    const membersWithDetails = [];
    const failedMembers = [];
    const batchSize = 5;
    for (let i = 0; i < limitedMemberIds.length; i += batchSize) {
        const batch = limitedMemberIds.slice(i, i + batchSize);
        const batchResults = await Promise.all(batch.map((userId) => getUserInfoSafe(api, userId)));
        for (let j = 0; j < batchResults.length; j++) {
            const result = batchResults[j];
            if (result) {
                membersWithDetails.push(result);
            }
            else {
                failedMembers.push(batch[j]);
            }
        }
        if (i + batchSize < limitedMemberIds.length) {
            await new Promise((resolve) => setTimeout(resolve, 100));
        }
    }
    const creatorId = groupInfo === null || groupInfo === void 0 ? void 0 : groupInfo.creatorId;
    const adminIds = (groupInfo === null || groupInfo === void 0 ? void 0 : groupInfo.adminIds) || [];
    const enrichedMembers = membersWithDetails.map((member) => ({
        ...member,
        role: member.id === creatorId ? 'owner' : adminIds.includes(member.id) ? 'admin' : 'member',
    }));
    return {
        response,
        groupInfo,
        members: enrichedMembers,
        memberStats: {
            totalInGroup: (groupInfo === null || groupInfo === void 0 ? void 0 : groupInfo.totalMember) || memberIds.length,
            requested: limitedMemberIds.length,
            retrieved: membersWithDetails.length,
            failed: failedMembers.length,
            failedIds: failedMembers,
        },
    };
}
async function processAddGroupDeputy(api, params) {
    (0, validator_1.validateGroupId)(params.groupId);
    (0, validator_1.validateUserId)(params.userId);
    const response = await executeWithAdminPermissionCheck(async () => api.addGroupDeputy(params.groupId, params.userId), 'Thêm phó nhóm');
    return {
        status: 'Thành công',
        response,
    };
}
async function processAddUserToGroup(api, params) {
    (0, validator_1.validateGroupId)(params.groupId);
    (0, validator_1.validateUserIds)(params.userIds);
    const resolvedMembers = await resolveMemberIdentifiers(api, params.userIds);
    const response = await api.addUserToGroup(resolvedMembers.map((member) => member.uid), params.groupId);
    return withResolvedMembers(response, resolvedMembers);
}
async function processChangeGroupAvatar(api, params) {
    (0, validator_1.validateGroupId)(params.groupId);
    (0, validator_1.validateImageUrl)(params.imageUrl);
    const response = await executeWithAdminPermissionCheck(async () => api.changeGroupAvatar(params.groupId, params.imageUrl), 'Đổi avatar nhóm');
    return {
        status: 'Thành công',
        response,
    };
}
async function processChangeGroupName(api, params) {
    (0, validator_1.validateGroupId)(params.groupId);
    (0, validator_1.validateGroupName)(params.newName);
    const response = await executeWithAdminPermissionCheck(async () => api.changeGroupName(params.groupId, params.newName), 'Đổi tên nhóm');
    return response;
}
async function processGetAllGroups(api, params) {
    (0, validator_1.validateLimit)(params.limit);
    const response = await api.getAllGroups();
    const responseAny = response;
    const groupIds = responseAny.gridVerMap ? Object.keys(responseAny.gridVerMap) : [];
    const totalGroups = groupIds.length;
    const limitedGroupIds = groupIds.slice(0, params.limit);
    const groupsWithDetails = [];
    for (const groupId of limitedGroupIds) {
        try {
            const groupInfoResponse = await api.getGroupInfo(groupId);
            const groupInfo = groupInfoResponse.gridInfoMap[groupId];
            if (groupInfo) {
                groupsWithDetails.push({
                    groupId: groupInfo.groupId,
                    name: groupInfo.name,
                    desc: groupInfo.desc,
                    type: groupInfo.type,
                    totalMember: groupInfo.totalMember,
                    maxMember: groupInfo.maxMember,
                    creatorId: groupInfo.creatorId,
                    createdTime: groupInfo.createdTime,
                    visibility: groupInfo.visibility,
                    globalId: groupInfo.globalId,
                    avt: groupInfo.avt,
                    fullAvt: groupInfo.fullAvt,
                    version: groupInfo.version,
                    _fullInfo: groupInfo,
                });
            }
        }
        catch (error) {
            console.error(`Failed to get info for group ${groupId}:`, error);
        }
    }
    return {
        groups: groupsWithDetails,
        totalGroups,
        limitedToCount: params.limit,
        actualReturnedCount: groupsWithDetails.length,
    };
}
async function processCreateNote(api, params) {
    (0, validator_1.validateGroupId)(params.groupId);
    (0, validator_1.validateNoteContent)(params.content);
    const options = {
        title: params.content,
        pinAct: params.pinAct,
    };
    const response = await api.createNote(options, params.groupId);
    return {
        status: 'Thành công',
        response,
    };
}
async function processRemoveUserFromGroup(api, params) {
    (0, validator_1.validateGroupId)(params.groupId);
    (0, validator_1.validateUserIds)(params.userIds);
    const resolvedMembers = await resolveMemberIdentifiers(api, params.userIds);
    const response = await executeWithAdminPermissionCheck(async () => api.removeUserFromGroup(resolvedMembers.map((member) => member.uid), params.groupId), 'Xóa thành viên');
    return withResolvedMembers(response, resolvedMembers);
}
async function processReplaceGroupMembers(api, params) {
    (0, validator_1.validateGroupId)(params.groupId);
    const removedMembers = await resolveMemberIdentifiers(api, params.oldMembers);
    const addedMembers = await resolveMemberIdentifiers(api, params.newMembers);
    const removeResponse = await executeWithAdminPermissionCheck(async () => api.removeUserFromGroup(removedMembers.map((member) => member.uid), params.groupId), 'Thay thành viên - xóa thành viên cũ');
    if (removeResponse.errorMembers.length > 0) {
        throw new Error(`Không thể thay thành viên vì xóa thành viên cũ thất bại: ${removeResponse.errorMembers.join(', ')}`);
    }
    const addResponse = await api.addUserToGroup(addedMembers.map((member) => member.uid), params.groupId);
    return {
        removeResponse,
        addResponse,
        removedMembers,
        addedMembers,
    };
}
async function processGetGroupChatHistory(api, params) {
    var _a, _b, _c, _d;
    (0, validator_1.validateGroupId)(params.groupId);
    const count = (_a = params.limit) !== null && _a !== void 0 ? _a : 50;
    (0, validator_1.validateLimit)(count);
    (0, validator_1.validateTimestamp)(params.timestamp);
    const response = await api.getGroupChatHistory(params.groupId, count);
    let messages = normalizeGroupMessages(response === null || response === void 0 ? void 0 : response.groupMsgs, params.groupId);
    if (params.timestamp !== undefined) {
        const fromMs = params.timestamp * 1000;
        messages = messages.filter((msg) => msg.timestamp >= fromMs);
    }
    return {
        response,
        messages,
        totalMessages: messages.length,
        fetchedCount: Array.isArray(response === null || response === void 0 ? void 0 : response.groupMsgs) ? response.groupMsgs.length : 0,
        hasMore: Number((_b = response === null || response === void 0 ? void 0 : response.more) !== null && _b !== void 0 ? _b : 0) > 0,
        lastActionId: (_c = response === null || response === void 0 ? void 0 : response.lastActionId) !== null && _c !== void 0 ? _c : null,
        lastActionIdOther: (_d = response === null || response === void 0 ? void 0 : response.lastActionIdOther) !== null && _d !== void 0 ? _d : null,
    };
}
function normalizeGroupMessages(groupMsgs, groupId) {
    if (!Array.isArray(groupMsgs)) {
        return [];
    }
    const normalized = groupMsgs.map((msg) => {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
        const data = (_b = (_a = msg === null || msg === void 0 ? void 0 : msg.data) !== null && _a !== void 0 ? _a : msg) !== null && _b !== void 0 ? _b : {};
        const timestamp = Number((_d = (_c = data.ts) !== null && _c !== void 0 ? _c : data.timestamp) !== null && _d !== void 0 ? _d : 0);
        return {
            msgId: String((_e = data.msgId) !== null && _e !== void 0 ? _e : ''),
            cliMsgId: String((_f = data.cliMsgId) !== null && _f !== void 0 ? _f : ''),
            threadId: String((_h = (_g = msg === null || msg === void 0 ? void 0 : msg.threadId) !== null && _g !== void 0 ? _g : data.idTo) !== null && _h !== void 0 ? _h : groupId),
            senderId: String((_j = data.uidFrom) !== null && _j !== void 0 ? _j : ''),
            senderName: String((_k = data.dName) !== null && _k !== void 0 ? _k : ''),
            content: (_l = data.content) !== null && _l !== void 0 ? _l : '',
            msgType: String((_m = data.msgType) !== null && _m !== void 0 ? _m : 'unknown'),
            contentType: (0, zaloMessage_1.detectContentType)(data.msgType, data.content),
            mediaUrls: (0, zaloMessage_1.extractMediaUrls)(data.content),
            timestamp: Number.isNaN(timestamp) ? 0 : timestamp,
            isSelf: Boolean(msg === null || msg === void 0 ? void 0 : msg.isSelf),
            mentions: (_o = data.mentions) !== null && _o !== void 0 ? _o : null,
            quote: (_p = data.quote) !== null && _p !== void 0 ? _p : null,
            ttl: Number((_q = data.ttl) !== null && _q !== void 0 ? _q : 0),
        };
    });
    return normalized.sort((a, b) => (0, zaloMessage_1.compareBySortKey)((0, zaloMessage_1.messageSortKey)(a.msgId, a.timestamp), (0, zaloMessage_1.messageSortKey)(b.msgId, b.timestamp), -1));
}
async function processJoinGroupLink(api, params) {
    (0, validator_1.validateGroupLink)(params.groupLink);
    const response = await api.joinGroupLink(params.groupLink);
    return {
        status: 'Thành công',
        response,
        message: 'Đã tham gia nhóm thành công',
    };
}
async function processLeaveGroup(api, params) {
    (0, validator_1.validateGroupId)(params.groupId);
    const response = await api.leaveGroup(params.groupId, params.silent);
    return {
        status: 'Thành công',
        response,
        message: params.silent ? 'Đã rời nhóm lặng lẽ' : 'Đã rời nhóm',
    };
}
async function processInviteUsers(api, params) {
    (0, validator_1.validateUserId)(params.userId);
    (0, validator_1.validateGroupIds)(params.groupIds);
    const groupList = (0, validator_1.parseGroupIds)(params.groupIds);
    const response = await api.inviteUserToGroups(params.userId, groupList);
    return {
        response,
        invitedToGroups: groupList.length,
        groupIds: groupList,
    };
}
async function processGetBlockedMembers(api, params) {
    var _a, _b, _c;
    (0, validator_1.validateGroupId)(params.groupId);
    (0, validator_1.validatePage)(params.page);
    (0, validator_1.validateCount)(params.count);
    const payload = {
        page: (_a = params.page) !== null && _a !== void 0 ? _a : 1,
        count: (_b = params.count) !== null && _b !== void 0 ? _b : 50,
    };
    const response = await executeWithAdminPermissionCheck(async () => api.getGroupBlockedMember(payload, params.groupId), 'Lấy danh sách bị chặn');
    return {
        response,
        blockedMembers: response.blocked_members || [],
        hasMore: response.has_more || 0,
        totalReturned: ((_c = response.blocked_members) === null || _c === void 0 ? void 0 : _c.length) || 0,
    };
}
async function processBlockMember(api, params) {
    (0, validator_1.validateGroupId)(params.groupId);
    (0, validator_1.validateMemberIds)(params.memberIds);
    const memberList = (0, validator_1.parseMemberIds)(params.memberIds);
    const response = await executeWithAdminPermissionCheck(async () => api.addGroupBlockedMember(memberList, params.groupId), 'Chặn thành viên');
    return {
        status: 'Thành công',
        response,
        message: `Đã chặn ${memberList.length} thành viên`,
        blockedMembers: memberList,
    };
}
async function processUnblockMember(api, params) {
    (0, validator_1.validateGroupId)(params.groupId);
    (0, validator_1.validateMemberIds)(params.memberIds);
    const memberList = (0, validator_1.parseMemberIds)(params.memberIds);
    const response = await executeWithAdminPermissionCheck(async () => api.removeGroupBlockedMember(memberList, params.groupId), 'Bỏ chặn thành viên');
    return {
        status: 'Thành công',
        response,
        message: `Đã bỏ chặn ${memberList.length} thành viên`,
        unblockedMembers: memberList,
    };
}
async function processGetPendingRequests(api, params) {
    var _a;
    (0, validator_1.validateGroupId)(params.groupId);
    const response = await executeWithAdminPermissionCheck(async () => api.getPendingGroupMembers(params.groupId), 'Lấy yêu cầu chờ duyệt');
    return {
        response,
        pendingMembers: response.users || [],
        totalPending: ((_a = response.users) === null || _a === void 0 ? void 0 : _a.length) || 0,
        timestamp: response.time || 0,
    };
}
async function processReviewPendingRequest(api, params) {
    (0, validator_1.validateGroupId)(params.groupId);
    (0, validator_1.validateMemberIds)(params.memberIds);
    const memberList = (0, validator_1.parseMemberIds)(params.memberIds);
    const isApprove = params.action === 'approve';
    const payload = {
        members: memberList,
        isApprove,
    };
    const response = await executeWithAdminPermissionCheck(async () => api.reviewPendingMemberRequest(payload, params.groupId), 'Duyệt yêu cầu');
    return {
        status: 'Thành công',
        response,
        message: isApprove
            ? `Đã phê duyệt ${memberList.length} yêu cầu`
            : `Đã từ chối ${memberList.length} yêu cầu`,
        reviewedMembers: memberList,
        action: params.action,
    };
}
async function processGetGroupLinkInfo(api, params) {
    var _a;
    (0, validator_1.validateGroupLink)(params.link);
    const payload = {
        link: params.link,
        memberPage: (_a = params.memberPage) !== null && _a !== void 0 ? _a : 1,
    };
    const response = await api.getGroupLinkInfo(payload);
    return {
        response,
        groupId: response.groupId,
        name: response.name,
        desc: response.desc,
        totalMember: response.totalMember,
        hasMoreMember: response.hasMoreMember,
        avt: response.avt,
        fullAvt: response.fullAvt,
        currentMems: response.currentMems,
        adminIds: response.adminIds,
    };
}
async function processGetGroupLinkDetail(api, params) {
    (0, validator_1.validateGroupId)(params.groupId);
    const response = await executeWithAdminPermissionCheck(async () => api.getGroupLinkDetail(params.groupId), 'Lấy thông tin link nhóm');
    return {
        response,
        link: response.link || null,
        expirationDate: response.expiration_date || null,
        enabled: response.enabled === 1,
        status: response.enabled === 1 ? 'Đã bật' : 'Đã tắt',
    };
}
async function processEnableGroupLink(api, params) {
    (0, validator_1.validateGroupId)(params.groupId);
    const response = await executeWithAdminPermissionCheck(async () => api.enableGroupLink(params.groupId), 'Bật link mời nhóm');
    return {
        status: 'Thành công',
        response,
        link: response.link,
        expirationDate: response.expiration_date,
        enabled: response.enabled === 1,
        message: 'Đã bật link mời nhóm',
    };
}
async function processDisableGroupLink(api, params) {
    (0, validator_1.validateGroupId)(params.groupId);
    const response = await executeWithAdminPermissionCheck(async () => api.disableGroupLink(params.groupId), 'Tắt link mời nhóm');
    return {
        status: 'Thành công',
        response,
        enabled: false,
        message: 'Đã tắt link mời nhóm',
    };
}
async function processUpgradeGroupToCommunity(api, params) {
    (0, validator_1.validateGroupId)(params.groupId);
    const response = await executeWithAdminPermissionCheck(async () => api.upgradeGroupToCommunity(params.groupId), 'Nâng cấp nhóm lên cộng đồng');
    return {
        status: 'Thành công',
        response,
        message: 'Đã nâng cấp nhóm lên cộng đồng',
    };
}
async function processChangeGroupOwner(api, params) {
    (0, validator_1.validateGroupId)(params.groupId);
    (0, validator_1.validateUserId)(params.memberId);
    const response = await executeWithAdminPermissionCheck(async () => api.changeGroupOwner(params.memberId, params.groupId), 'Chuyển quyền trưởng nhóm');
    return {
        status: 'Thành công',
        response,
        newOwnerId: params.memberId,
        message: 'Đã chuyển quyền trưởng nhóm',
    };
}
async function processRemoveGroupDeputy(api, params) {
    (0, validator_1.validateGroupId)(params.groupId);
    (0, validator_1.validateMemberIds)(params.memberIds);
    const memberList = (0, validator_1.parseMemberIds)(params.memberIds);
    const response = await executeWithAdminPermissionCheck(async () => api.removeGroupDeputy(memberList, params.groupId), 'Gỡ phó nhóm');
    return {
        status: 'Thành công',
        response,
        removedDeputies: memberList,
        message: `Đã gỡ vai trò phó nhóm của ${memberList.length} thành viên`,
    };
}
async function processGetGroupMembersInfo(api, params) {
    (0, validator_1.validateMemberIds)(params.memberIds);
    const memberList = (0, validator_1.parseMemberIds)(params.memberIds);
    const response = await api.getGroupMembersInfo(memberList.length === 1 ? memberList[0] : memberList);
    return {
        response,
        profiles: response.profiles || {},
        totalRequested: memberList.length,
        totalReturned: Object.keys(response.profiles || {}).length,
    };
}
async function processGetGroupInviteBoxInfo(api, params) {
    (0, validator_1.validateGroupId)(params.groupId);
    const response = await api.getGroupInviteBoxInfo({
        groupId: params.groupId,
        mpage: params.memberPage,
        mcount: params.memberCount,
    });
    return {
        response,
        groupInfo: response.groupInfo,
        inviterInfo: response.inviterInfo,
        grCreatorInfo: response.grCreatorInfo,
        expiredTs: response.expiredTs,
    };
}
async function processGetGroupInviteBoxList(api, params) {
    (0, validator_1.validatePage)(params.page);
    (0, validator_1.validateCount)(params.invitesPerPage);
    const response = await api.getGroupInviteBoxList({
        page: params.page,
        invPerPage: params.invitesPerPage,
        mpage: params.memberPage,
        mcount: params.memberCount,
    });
    return {
        response,
        invitations: response.invitations || [],
        total: response.total || 0,
        hasMore: response.hasMore || false,
    };
}
async function processJoinGroupInviteBox(api, params) {
    (0, validator_1.validateGroupId)(params.groupId);
    const response = await api.joinGroupInviteBox(params.groupId);
    return {
        status: 'Thành công',
        response,
        message: 'Đã tham gia nhóm từ lời mời',
    };
}
async function processDeleteGroupInviteBox(api, params) {
    (0, validator_1.validateGroupIds)(params.groupIds);
    const groupList = (0, validator_1.parseGroupIds)(params.groupIds);
    const response = await api.deleteGroupInviteBox(groupList.length === 1 ? groupList[0] : groupList, params.blockFutureInvite);
    return {
        response,
        deletedInvitationIds: response.delInvitaionIds || [],
        errors: response.errMap || {},
    };
}
async function processDisperseGroup(api, params) {
    (0, validator_1.validateGroupId)(params.groupId);
    const response = await executeWithAdminPermissionCheck(async () => api.disperseGroup(params.groupId), 'Giải tán nhóm');
    return {
        status: 'Thành công',
        response,
        message: 'Đã giải tán nhóm',
    };
}
async function processEditNote(api, params) {
    (0, validator_1.validateGroupId)(params.groupId);
    (0, validator_1.validateNoteContent)(params.title);
    const response = await executeWithAdminPermissionCheck(async () => api.editNote({ title: params.title, topicId: params.topicId, pinAct: params.pinAct }, params.groupId), 'Sửa ghi chú');
    return {
        status: 'Thành công',
        response,
    };
}
async function processGetListBoard(api, params) {
    (0, validator_1.validateGroupId)(params.groupId);
    const response = await api.getListBoard({ page: params.page, count: params.count }, params.groupId);
    return {
        response,
        items: response.items,
        count: response.count,
    };
}
async function processGetFriendBoardList(api, params) {
    if (!params.conversationId || params.conversationId.trim() === '') {
        throw new Error('Conversation ID is required and must be a non-empty string');
    }
    const response = await api.getFriendBoardList(params.conversationId);
    return {
        response,
        data: response.data,
        version: response.version,
    };
}
async function processUpdateGroupSettings(api, params) {
    (0, validator_1.validateGroupId)(params.groupId);
    const { groupId, ...options } = params;
    const response = await executeWithAdminPermissionCheck(async () => api.updateGroupSettings(options, groupId), 'Cập nhật cài đặt nhóm');
    return {
        status: 'Thành công',
        response,
        message: 'Đã cập nhật cài đặt nhóm',
    };
}
//# sourceMappingURL=groupProcessor.js.map