@juzi/wechaty-puppet-whatsapp
Version:
Wechaty Puppet for WhatsApp
283 lines • 11.4 kB
JavaScript
/* eslint-disable no-redeclare */
import * as PUPPET from '@juzi/wechaty-puppet';
import { FileBox, log } from '../config.js';
import { WA_ERROR_TYPE } from '../exception/error-type.js';
import WAError from '../exception/whatsapp-error.js';
import { contactRawPayload } from './contact.js';
import { isRoomId } from '../helper/miscellaneous.js';
import { parserRoomRawPayload } from '../helper/pure-function/room-raw-payload-parser.js';
import { getMessageMediaFromFilebox } from '../helper/pure-function/messageMedia.js';
const PRE = 'MIXIN_ROOM';
export async function roomList() {
log.verbose(PRE, 'roomList()');
const cacheManager = await this.manager.getCacheManager();
const roomIdList = await cacheManager.getRoomIdList();
return roomIdList;
}
/**
* Filter friend list and non-friend list from member id list
* @param { PuppetWhatsApp } this
* @param { string[] } memberIdList
* @returns { friendsList: string[]; nonFriendsList: string[]; }
*/
async function checkRoomMember(memberIdList) {
const friendsList = [];
const nonFriendsList = [];
for (const memberId of memberIdList) {
const memberPayload = await this.manager.getContactById(memberId);
if (memberPayload.isMyContact) {
friendsList.push(memberId);
}
else {
nonFriendsList.push(memberId);
}
}
const botId = this.manager.whatsAppManager.getBotId();
if (!friendsList.includes(botId)) {
friendsList.push(botId);
}
return {
friendsList,
nonFriendsList,
};
}
async function updateRoomRawPayloadToCache(roomId, params) {
const { name, avatar, memberIdList } = params;
const cacheManager = await this.manager.getCacheManager();
const roomInCache = await cacheManager.getContactOrRoomRawPayload(roomId);
if (roomInCache) {
if (name) {
roomInCache.name = name;
}
if (avatar) {
roomInCache.avatar = avatar;
}
if (memberIdList && memberIdList.length > 0) {
await cacheManager.setRoomMemberIdList(roomId, memberIdList);
}
await cacheManager.setContactOrRoomRawPayload(roomId, roomInCache);
}
return roomInCache;
}
export async function roomCreate(contactIdList, topic) {
log.verbose(PRE, 'roomCreate(%s, %s)', contactIdList, topic);
const { friendsList, nonFriendsList } = await checkRoomMember.call(this, contactIdList);
const group = await this.manager.createRoom(topic, friendsList);
const roomId = group.gid._serialized;
if (roomId) {
if (nonFriendsList.length > 0) {
await addMemberListToRoom.call(this, roomId, nonFriendsList);
}
await updateRoomRawPayloadToCache.call(this, roomId, {
memberIdList: contactIdList,
name: topic,
});
return roomId;
}
else {
throw WAError(WA_ERROR_TYPE.ERR_CREATE_ROOM, `An error occurred while creating the group, detail: ${contactIdList}, topic: ${topic}`);
}
}
export async function roomAdd(roomId, contactId) {
log.verbose(PRE, 'roomAdd(%s, %s)', roomId, contactId);
await addMemberListToRoom.call(this, roomId, contactId);
}
async function addMemberListToRoom(roomId, contactIds) {
const roomChat = await this.manager.getRoomChatById(roomId);
const contactIdList = Array.isArray(contactIds) ? contactIds : [contactIds];
const result = await roomChat.addParticipants(contactIdList);
const cacheManager = await this.manager.getCacheManager();
const successContactIdList = [];
if (typeof result === 'string') {
throw WAError(WA_ERROR_TYPE.ERR_ADD_ROOM, `cannot add contact: ${contactIdList.join(', ')} to room ${roomId}, ${result}`);
}
for (const key in result) {
const item = result[key];
for (const contactId in item) {
const contactResult = item[contactId];
if (Number(contactResult?.code) === 200) {
log.silly(PRE, `add member ${contactId} to room ${roomId} succeded`);
successContactIdList.push(contactId);
}
else {
switch (Number(contactResult?.code)) {
case 409:
log.warn(PRE, `add member ${contactId} to room ${roomId} failed, contact is already in room`);
break;
default:
log.warn(PRE, `add member ${contactId} to room ${roomId} failed for unknown reason`);
}
}
}
}
await cacheManager.addRoomMemberToList(roomId, successContactIdList);
}
export async function roomDel(roomId, contactIds) {
log.verbose(PRE, 'roomDel(%s, %s)', roomId, contactIds);
const roomChat = await this.manager.getRoomChatById(roomId);
const contactIdList = Array.isArray(contactIds) ? contactIds : [contactIds];
await roomChat.removeParticipants(contactIdList);
const cacheManager = await this.manager.getCacheManager();
await cacheManager.removeRoomMemberFromList(roomId, contactIdList);
}
export async function roomQuit(roomId) {
log.verbose(PRE, 'roomQuit(%s)', roomId);
const roomChat = await this.manager.getRoomChatById(roomId);
await roomChat.leave();
const cacheManager = await this.manager.getCacheManager();
await cacheManager.deleteContactOrRoom(roomId);
await cacheManager.deleteRoomMemberIdList(roomId);
}
export async function roomAvatar(roomId, avatar) {
log.verbose(PRE, 'roomAvatar(%s)', roomId);
if (avatar) {
const media = await getMessageMediaFromFilebox(avatar);
const roomChat = await this.manager.getRoomChatById(roomId);
const result = await roomChat.setPicture(media);
if (!result) {
throw WAError(WA_ERROR_TYPE.ERR_ROOM_AVATAR_SET_FAILED, `can not set room avatar, room id: ${roomId}`);
}
}
else {
const payload = await this.roomPayload(roomId);
if (payload.avatar) {
return FileBox.fromUrl(payload.avatar);
}
throw WAError(WA_ERROR_TYPE.ERR_ROOM_AVATAR_NOT_FOUND, `can not find this room avatar, room id: ${roomId}`);
}
}
export async function roomTopic(roomId, topic) {
log.verbose(PRE, 'roomTopic(%s, %s)', roomId, topic);
if (typeof topic === 'undefined') {
const payload = await this.roomPayload(roomId);
return payload.topic;
}
const roomChat = await this.manager.getRoomChatById(roomId);
if (roomChat.isGroup) {
await roomChat.setSubject(topic);
}
await this.dirtyPayload(PUPPET.types.Payload.Room, roomId);
}
export async function roomQRCode(roomId) {
log.verbose(PRE, 'roomQRCode(%s)', roomId);
const roomChat = await this.manager.getRoomChatById(roomId);
const code = await roomChat.getInviteCode();
const url = `https://chat.whatsapp.com/${code}`;
return url;
}
/**
* Get member id list from cache
* @param { PuppetWhatsApp } this whatsapp client
* @param { string } roomId roomId
* @returns { string[] } member id list
*/
export async function roomMemberList(roomId) {
log.verbose(PRE, 'roomMemberList(%s)', roomId);
const cacheManager = await this.manager.getCacheManager();
const memberList = await cacheManager.getRoomMemberIdList(roomId);
if (memberList.length === 0) {
return this.manager.syncRoomMemberList(roomId);
}
return memberList;
}
export async function roomMemberRawPayload(roomId, contactId) {
log.verbose(PRE, 'roomMemberRawPayload(%s, %s)', roomId, contactId);
const member = await contactRawPayload.call(this, contactId);
return {
avatar: member.avatar,
id: member.id._serialized,
name: member.pushname || member.name || '',
// roomAlias : contact.name,
};
}
export async function roomMemberRawPayloadParser(rawPayload) {
log.verbose(PRE, 'roomMemberRawPayloadParser(%s)', JSON.stringify(rawPayload));
return rawPayload;
}
export async function roomAnnounce(roomId, text) {
if (typeof text === 'undefined') {
const roomChat = await this.manager.getRoomChatById(roomId);
return roomChat.description;
}
const roomChat = await this.manager.getRoomChatById(roomId);
await roomChat.setDescription((text || undefined));
await this.dirtyPayload(PUPPET.types.Payload.Room, roomId);
}
/**
*
* Room Invitation
*
*/
export async function roomInvitationAccept(roomInvitationId) {
log.verbose(PRE, 'roomInvitationAccept(%s)', roomInvitationId);
const info = await roomInvitationRawPayload.call(this, roomInvitationId);
if (Object.keys(info).length === 1) {
await this.manager.acceptRoomInvite(info.inviteCode);
}
else {
await this.manager.acceptPrivateRoomInvite(info);
}
}
export async function roomInvitationRawPayload(roomInvitationId) {
log.verbose(PRE, 'roomInvitationRawPayload(%s)', roomInvitationId);
const cacheManager = await this.manager.getCacheManager();
const info = await cacheManager.getRoomInvitationRawPayload(roomInvitationId);
if (info) {
return info;
}
else {
return {
inviteCode: roomInvitationId,
};
}
}
/**
*
* @param this PuppetWhatsapp
* @param rawPayload Partial<InviteV4Data>
* @returns Partial<InviteV4Data>
* TODO: Here we return Partial<InviteV4Data> for roomInvitationAccept usage, We may need other fields required by RoomInvitationPayload
*/
export async function roomInvitationRawPayloadParser(rawPayload) {
log.verbose(PRE, 'roomInvitationRawPayloadParser(%s)', JSON.stringify(rawPayload));
return rawPayload;
}
export async function roomRawPayload(id) {
log.verbose(PRE, 'roomRawPayload(%s)', id);
if (!isRoomId(id)) {
throw WAError(WA_ERROR_TYPE.ERR_ROOM_NOT_FOUND, `please check room id: ${id} again.`);
}
const cacheManager = await this.manager.getCacheManager();
const room = await cacheManager.getContactOrRoomRawPayload(id);
const roomAnnounce = await this.roomAnnounce(id);
if (room) {
room.announce = roomAnnounce;
return room;
}
else {
try {
const rawRoom = await this.manager.getContactById(id);
const avatar = await rawRoom.getProfilePicUrl() || '';
const room = Object.assign(rawRoom, { avatar, announce: roomAnnounce });
await cacheManager.setContactOrRoomRawPayload(id, room);
return room;
}
catch (error) {
throw WAError(WA_ERROR_TYPE.ERR_ROOM_NOT_FOUND, `roomRawPayload(${id}) not found.`);
}
}
}
export async function roomRawPayloadParser(roomPayload) {
const roomId = roomPayload.id._serialized;
try {
const roomChat = await this.manager.getRoomChatById(roomId);
const result = parserRoomRawPayload(roomPayload, roomChat);
log.verbose(PRE, 'roomRawPayloadParser roomPayload(%s) roomChat(%s) result(%s)', JSON.stringify(roomPayload), JSON.stringify(roomChat), JSON.stringify(result));
return result;
}
catch (error) {
log.error(PRE, `roomRawPayloadParser(${roomId}) failed, error message: ${error.message}`);
throw WAError(WA_ERROR_TYPE.ERR_ROOM_NOT_FOUND, `roomRawPayloadParser(${roomId}) failed, error message: ${error.message}`);
}
}
//# sourceMappingURL=room.js.map