2023-01-25 19:03:02 +00:00
|
|
|
import axios from 'axios';
|
|
|
|
|
2023-02-08 16:06:06 +00:00
|
|
|
import data, { Data, TDataChannels, TDataGroups, TDataTeams, TDataUsers, TUserRegularChannels } from '../data';
|
2023-01-25 19:03:02 +00:00
|
|
|
|
|
|
|
const TEAM_TYPE = {
|
|
|
|
PUBLIC: 0,
|
|
|
|
PRIVATE: 1
|
|
|
|
};
|
|
|
|
|
|
|
|
const { server } = data;
|
|
|
|
|
|
|
|
const rocketchat = axios.create({
|
|
|
|
baseURL: `${server}/api/v1/`,
|
|
|
|
headers: {
|
|
|
|
'Content-Type': 'application/json;charset=UTF-8'
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
const login = async (username: string, password: string) => {
|
|
|
|
console.log(`Logging in as user ${username}`);
|
|
|
|
const response = await rocketchat.post('login', {
|
|
|
|
user: username,
|
|
|
|
password
|
|
|
|
});
|
2023-02-16 14:39:56 +00:00
|
|
|
const { authToken, userId } = response.data.data;
|
2023-01-25 19:03:02 +00:00
|
|
|
rocketchat.defaults.headers.common['X-User-Id'] = userId;
|
|
|
|
rocketchat.defaults.headers.common['X-Auth-Token'] = authToken;
|
|
|
|
return { authToken, userId };
|
|
|
|
};
|
|
|
|
|
|
|
|
const createUser = async (username: string, password: string, name: string, email: string) => {
|
|
|
|
console.log(`Creating user ${username}`);
|
|
|
|
try {
|
|
|
|
await rocketchat.post('users.create', {
|
|
|
|
username,
|
|
|
|
password,
|
|
|
|
name,
|
|
|
|
email
|
|
|
|
});
|
|
|
|
} catch (error) {
|
|
|
|
console.log(JSON.stringify(error));
|
|
|
|
throw new Error('Failed to create user');
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
const createChannelIfNotExists = async (channelname: string) => {
|
|
|
|
console.log(`Creating public channel ${channelname}`);
|
|
|
|
try {
|
|
|
|
const room = await rocketchat.post('channels.create', {
|
|
|
|
name: channelname
|
|
|
|
});
|
|
|
|
return room;
|
|
|
|
} catch (createError) {
|
|
|
|
try {
|
|
|
|
// Maybe it exists already?
|
|
|
|
const room = rocketchat.get(`channels.info?roomName=${channelname}`);
|
|
|
|
return room;
|
|
|
|
} catch (infoError) {
|
|
|
|
console.log(JSON.stringify(createError));
|
|
|
|
console.log(JSON.stringify(infoError));
|
|
|
|
throw new Error('Failed to find or create public channel');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
const createTeamIfNotExists = async (teamname: string) => {
|
|
|
|
console.log(`Creating private team ${teamname}`);
|
|
|
|
try {
|
|
|
|
await rocketchat.post('teams.create', {
|
|
|
|
name: teamname,
|
|
|
|
type: TEAM_TYPE.PRIVATE
|
|
|
|
});
|
|
|
|
} catch (createError) {
|
|
|
|
try {
|
|
|
|
// Maybe it exists already?
|
|
|
|
await rocketchat.get(`teams.info?teamName=${teamname}`);
|
|
|
|
} catch (infoError) {
|
|
|
|
console.log(JSON.stringify(createError));
|
|
|
|
console.log(JSON.stringify(infoError));
|
|
|
|
throw new Error('Failed to find or create private team');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
const createGroupIfNotExists = async (groupname: string) => {
|
|
|
|
console.log(`Creating private group ${groupname}`);
|
|
|
|
try {
|
|
|
|
await rocketchat.post('groups.create', {
|
|
|
|
name: groupname
|
|
|
|
});
|
|
|
|
} catch (createError) {
|
|
|
|
try {
|
|
|
|
// Maybe it exists already?
|
|
|
|
await rocketchat.get(`groups.info?roomName=${groupname}`);
|
|
|
|
} catch (infoError) {
|
|
|
|
console.log(JSON.stringify(createError));
|
|
|
|
console.log(JSON.stringify(infoError));
|
|
|
|
throw new Error('Failed to find or create private group');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
const changeChannelJoinCode = async (roomId: string, joinCode: string) => {
|
|
|
|
console.log(`Changing channel Join Code ${roomId}`);
|
|
|
|
try {
|
|
|
|
await rocketchat.post('method.call/saveRoomSettings', {
|
|
|
|
message: JSON.stringify({
|
|
|
|
msg: 'method',
|
2023-02-20 20:37:19 +00:00
|
|
|
// @ts-ignore
|
2023-02-08 16:06:06 +00:00
|
|
|
id: globalThis.random,
|
2023-01-25 19:03:02 +00:00
|
|
|
method: 'saveRoomSettings',
|
|
|
|
params: [roomId, { joinCode }]
|
|
|
|
})
|
|
|
|
});
|
|
|
|
} catch (createError) {
|
|
|
|
console.log(JSON.stringify(createError));
|
|
|
|
throw new Error('Failed to create protected channel');
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
const sendMessage = async (user: { username: string; password: string }, channel: string, msg: string, tmid?: string) => {
|
|
|
|
console.log(`Sending message to ${channel}`);
|
|
|
|
try {
|
|
|
|
await login(user.username, user.password);
|
|
|
|
const response = await rocketchat.post('chat.postMessage', { channel, msg, tmid });
|
|
|
|
return response.data;
|
|
|
|
} catch (infoError) {
|
|
|
|
console.log(JSON.stringify(infoError));
|
|
|
|
throw new Error('Failed to find or create private group');
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
const setup = async () => {
|
2023-02-20 20:37:19 +00:00
|
|
|
// @ts-ignore
|
2023-02-08 16:06:06 +00:00
|
|
|
const data = new Data(globalThis.random);
|
|
|
|
|
2023-01-25 19:03:02 +00:00
|
|
|
await login(data.adminUser, data.adminPassword);
|
|
|
|
|
|
|
|
for (const userKey in data.users) {
|
|
|
|
if (Object.prototype.hasOwnProperty.call(data.users, userKey)) {
|
|
|
|
const user = data.users[userKey as TDataUsers];
|
|
|
|
await createUser(user.username, user.password, user.username, user.email);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (const channelKey in data.channels) {
|
|
|
|
if (Object.prototype.hasOwnProperty.call(data.channels, channelKey)) {
|
|
|
|
const channel = data.channels[channelKey as TDataChannels];
|
|
|
|
const {
|
|
|
|
data: {
|
|
|
|
channel: { _id }
|
|
|
|
}
|
|
|
|
} = await createChannelIfNotExists(channel.name);
|
|
|
|
|
|
|
|
if ('joinCode' in channel) {
|
|
|
|
await changeChannelJoinCode(_id, channel.joinCode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
await login(data.users.regular.username, data.users.regular.password);
|
|
|
|
|
|
|
|
for (const channelKey in data.userRegularChannels) {
|
|
|
|
if (Object.prototype.hasOwnProperty.call(data.userRegularChannels, channelKey)) {
|
|
|
|
const channel = data.userRegularChannels[channelKey as TUserRegularChannels];
|
|
|
|
await createChannelIfNotExists(channel.name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (const groupKey in data.groups) {
|
|
|
|
if (Object.prototype.hasOwnProperty.call(data.groups, groupKey)) {
|
|
|
|
const group = data.groups[groupKey as TDataGroups];
|
|
|
|
await createGroupIfNotExists(group.name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (const teamKey in data.teams) {
|
|
|
|
if (Object.prototype.hasOwnProperty.call(data.teams, teamKey)) {
|
|
|
|
const team = data.teams[teamKey as TDataTeams];
|
|
|
|
await createTeamIfNotExists(team.name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
const get = (endpoint: string) => {
|
|
|
|
console.log(`GET /${endpoint}`);
|
|
|
|
return rocketchat.get(endpoint);
|
|
|
|
};
|
|
|
|
|
2023-02-16 14:39:56 +00:00
|
|
|
const post = async (endpoint: string, body: any) => {
|
2023-02-20 20:37:19 +00:00
|
|
|
// @ts-ignore
|
2023-02-16 14:39:56 +00:00
|
|
|
const data = new Data(globalThis.random);
|
|
|
|
await login(data.users.regular.username, data.users.regular.password);
|
2023-01-25 19:03:02 +00:00
|
|
|
console.log(`POST /${endpoint} ${JSON.stringify(body)}`);
|
|
|
|
return rocketchat.post(endpoint, body);
|
|
|
|
};
|
|
|
|
|
|
|
|
export { setup, sendMessage, get, post, login };
|