[NEW] Add new endpoint 'livechat/agent.status' & deprecate changeLivechatStatus meteor method

apps/meteor/app/livechat/server/api/v1/agent.ts

@@ -1,8 +1,11 @@
-import { isGETAgentNextToken } from '@rocket.chat/rest-typings';
+import { isGETAgentNextToken, isPOSTLivechatAgentStatusProps } from '@rocket.chat/rest-typings';
+import { Users } from '@rocket.chat/models';
+import { ILivechatAgentStatus } from '@rocket.chat/core-typings';
 
 import { API } from '../../../../api/server';
 import { findRoom, findGuest, findAgent, findOpenRoom } from '../lib/livechat';
 import { Livechat } from '../../lib/Livechat';
+import { hasPermissionAsync } from '../../../../authorization/server/functions/hasPermission';
 
 API.v1.addRoute('livechat/agent.info/:rid/:token', {
 	async get() {
@@ -58,3 +61,49 @@ API.v1.addRoute(
 		},
 	},
 );
+
+API.v1.addRoute(
+	'livechat/agent.status',
+	{ authRequired: true, permissionsRequired: ['view-l-room'], validateParams: isPOSTLivechatAgentStatusProps },
+	{
+		async post() {
+			const { status, agentId: inputAgentId } = this.bodyParams;
+
+			const agentId = inputAgentId || this.userId;
+
+			const agent = await Users.findOneAgentById(agentId, {
+				projection: {
+					status: 1,
+					statusLivechat: 1,
+				},
+			});
+			if (!agent) {
+				return API.v1.notFound('Agent not found');
+			}
+
+			const newStatus: ILivechatAgentStatus =
+				status ||
+				(agent.statusLivechat === ILivechatAgentStatus.AVAILABLE ? ILivechatAgentStatus.NOT_AVAILABLE : ILivechatAgentStatus.AVAILABLE);
+			if (newStatus === agent.statusLivechat) {
+				return API.v1.success({ status: agent.statusLivechat });
+			}
+
+			if (agentId !== this.userId) {
+				if (!(await hasPermissionAsync(this.userId, 'manage-livechat-agents'))) {
+					return API.v1.unauthorized();
+				}
+				Livechat.setUserStatusLivechat(agentId, newStatus);
+
+				return API.v1.success({ status: newStatus });
+			}
+
+			if (!Livechat.allowAgentChangeServiceStatus(newStatus, agentId)) {
+				return API.v1.failure('error-business-hours-are-closed');
+			}
+
+			Livechat.setUserStatusLivechat(agentId, newStatus);
+
+			return API.v1.success({ status: newStatus });
+		},
+	},
+);

apps/meteor/app/livechat/server/methods/changeLivechatStatus.js

@@ -3,9 +3,14 @@ import { Meteor } from 'meteor/meteor';
 import { Livechat } from '../lib/Livechat';
 import { hasPermission } from '../../../authorization';
 import Users from '../../../models/server/models/Users';
+import { methodDeprecationLogger } from '../../../lib/server/lib/deprecationWarningLogger';
 
 Meteor.methods({
 	'livechat:changeLivechatStatus'({ status, agentId = Meteor.userId() } = {}) {
+		methodDeprecationLogger.warn(
+			'livechat:changeLivechatStatus will be deprecated in future versions of Rocket.Chat. Use livechat/agent.status API instead.',
+		);
+
 		const uid = Meteor.userId();
 
 		if (!uid || !agentId) {
@@ -22,8 +27,14 @@ Meteor.methods({
 		});
 
 		if (!agent) {
-			throw new Meteor.Error('error-not-allowed', 'Not allowed', {
-				method: 'livechat:saveAgentInfo',
+			throw new Meteor.Error('error-not-allowed', 'Invalid Agent Id', {
+				method: 'livechat:changeLivechatStatus',
+			});
+		}
+
+		if (status && !['available', 'not-available'].includes(status)) {
+			throw new Meteor.Error('error-not-allowed', 'Invalid Status', {
+				method: 'livechat:changeLivechatStatus',
 			});
 		}
 

apps/meteor/client/lib/userData.ts

@@ -1,4 +1,4 @@
-import type { IUser, IUserDataEvent } from '@rocket.chat/core-typings';
+import type { ILivechatAgent, IUser, IUserDataEvent } from '@rocket.chat/core-typings';
 import { Serialized } from '@rocket.chat/core-typings';
 import { Meteor } from 'meteor/meteor';
 import { ReactiveVar } from 'meteor/reactive-var';
@@ -29,12 +29,11 @@ type RawUserData = Serialized<
 		| 'active'
 		| 'defaultRoom'
 		| 'customFields'
-		| 'statusLivechat'
 		| 'oauth'
 		| 'createdAt'
 		| '_updatedAt'
 		| 'avatarETag'
-	>
+	> & { statusLivechat?: ILivechatAgent['statusLivechat'] }
 >;
 
 const updateUser = (userData: IUser): void => {

apps/meteor/client/sidebar/sections/OmnichannelSection.tsx

@@ -9,6 +9,7 @@ import { OmniChannelCallDialPad, OmnichannelCallToggle, OmnichannelLivechatToggl
 
 const OmnichannelSection = (props: typeof Box): ReactElement => {
 	const t = useTranslation();
+
 	const isCallEnabled = useIsCallEnabled();
 	const isCallReady = useIsCallReady();
 	const hasPermissionToSeeContactCenter = usePermission('view-omnichannel-contact-center');

apps/meteor/client/sidebar/sections/actions/OmnichannelLivechatToggle.tsx

@@ -1,19 +1,19 @@
 import { Sidebar } from '@rocket.chat/fuselage';
 import { useMutableCallback } from '@rocket.chat/fuselage-hooks';
-import { useMethod, useToastMessageDispatch, useTranslation } from '@rocket.chat/ui-contexts';
+import { useEndpoint, useToastMessageDispatch, useTranslation } from '@rocket.chat/ui-contexts';
 import React, { ReactElement } from 'react';
 
 import { useOmnichannelAgentAvailable } from '../../../hooks/omnichannel/useOmnichannelAgentAvailable';
 
 export const OmnichannelLivechatToggle = (): ReactElement => {
 	const t = useTranslation();
 	const agentAvailable = useOmnichannelAgentAvailable();
-	const changeAgentStatus = useMethod('livechat:changeLivechatStatus');
+	const changeAgentStatus = useEndpoint('POST', '/v1/livechat/agent.status');
 	const dispatchToastMessage = useToastMessageDispatch();
 
 	const handleAvailableStatusChange = useMutableCallback(async () => {
 		try {
-			await changeAgentStatus();
+			await changeAgentStatus({});
 		} catch (error: unknown) {
 			dispatchToastMessage({ type: 'error', message: error });
 		}

apps/meteor/client/views/omnichannel/agents/AgentEdit.tsx

@@ -1,7 +1,7 @@
 import type { ILivechatAgent, ILivechatDepartment, ILivechatDepartmentAgents } from '@rocket.chat/core-typings';
 import { Field, TextInput, Button, Margins, Box, MultiSelect, Icon, Select } from '@rocket.chat/fuselage';
 import { useMutableCallback } from '@rocket.chat/fuselage-hooks';
-import { useToastMessageDispatch, useRoute, useSetting, useMethod, useTranslation } from '@rocket.chat/ui-contexts';
+import { useToastMessageDispatch, useRoute, useSetting, useMethod, useTranslation, useEndpoint } from '@rocket.chat/ui-contexts';
 import React, { useMemo, useRef, useState, FC, ReactElement } from 'react';
 
 import { getUserEmailAddress } from '../../../../lib/getUserEmailAddress';
@@ -76,14 +76,14 @@ const AgentEdit: FC<AgentEditProps> = ({ data, userDepartments, availableDepartm
 	const { handleDepartments, handleStatus, handleVoipExtension } = handlers;
 	const { departments, status, voipExtension } = values as {
 		departments: string[];
-		status: string;
+		status: ILivechatAgent['statusLivechat'];
 		voipExtension: string;
 	};
 
 	const MaxChats = useMaxChatsPerAgent();
 
 	const saveAgentInfo = useMethod('livechat:saveAgentInfo');
-	const saveAgentStatus = useMethod('livechat:changeLivechatStatus');
+	const saveAgentStatus = useEndpoint('POST', '/v1/livechat/agent.status');
 
 	const dispatchToastMessage = useToastMessageDispatch();
 

apps/meteor/server/services/meteor/service.ts

@@ -1,7 +1,6 @@
 import { Meteor } from 'meteor/meteor';
 import { ServiceConfiguration } from 'meteor/service-configuration';
 import { MongoInternals } from 'meteor/mongo';
-import type { IUser } from '@rocket.chat/core-typings';
 import { Users } from '@rocket.chat/models';
 
 import { metrics } from '../../../app/metrics';
@@ -190,7 +189,7 @@ export class MeteorService extends ServiceClassInternal implements IMeteor {
 			switch (clientAction) {
 				case 'updated':
 				case 'inserted':
-					const agent: IUser | undefined = await Users.findOneAgentById(id, {
+					const agent = await Users.findOneAgentById(id, {
 						projection: {
 							status: 1,
 							statusLivechat: 1,

apps/meteor/tests/data/livechat/businessHours.ts

@@ -0,0 +1,74 @@
+import { api, credentials, methodCall, request } from "../api-data";
+import { updateSetting } from "../permissions.helper"
+
+export const makeDefaultBusinessHourActiveAndClosed = async () => {
+	// enable settings
+	await updateSetting('Livechat_enable_business_hours', true);
+	await updateSetting('Livechat_business_hour_type', 'Single');
+
+	// create business hours
+	const { body: { businessHour } } = await request
+		.get(api('livechat/business-hour?type=default'))
+		.set(credentials)
+		.send();
+
+	const workHours = businessHour.workHours as { start: string; finish: string; day: string, open: boolean }[];
+	const allEnabledWorkHours = workHours.map((workHour) => {
+		workHour.open = true;
+		workHour.start = '00:00';
+		workHour.finish = '00:01'; // if a job runs between 00:00 and 00:01, then this test will fail :P
+		return workHour;
+	});
+
+	const enabledBusinessHour = {
+		...businessHour,
+		workHours: allEnabledWorkHours,
+	}
+
+	await request.post(methodCall('livechat:saveBusinessHour'))
+		.set(credentials)
+		.send({
+			message: JSON.stringify({
+				method: 'livechat:saveBusinessHour',
+				params: [enabledBusinessHour],
+				id: 'id',
+				msg: 'method',
+			}),
+		});
+}
+
+export const disableDefaultBusinessHour = async () => {
+	// disable settings
+	await updateSetting('Livechat_enable_business_hours', false);
+	await updateSetting('Livechat_business_hour_type', 'Single');
+
+	// create business hours
+	const { body: { businessHour } } = await request
+		.get(api('livechat/business-hour?type=default'))
+		.set(credentials)
+		.send();
+
+	const workHours = businessHour.workHours as { start: string; finish: string; day: string, open: boolean }[];
+	const allDisabledWorkHours = workHours.map((workHour) => {
+		workHour.open = false;
+		workHour.start = '00:00';
+		workHour.finish = '23:59';
+		return workHour;
+	});
+
+	const disabledBusinessHour = {
+		...businessHour,
+		workHours: allDisabledWorkHours,
+	}
+
+	await request.post(methodCall('livechat:saveBusinessHour'))
+		.set(credentials)
+		.send({
+			message: JSON.stringify({
+				method: 'livechat:saveBusinessHour',
+				params: [disabledBusinessHour],
+				id: 'id',
+				msg: 'method',
+			}),
+		});
+}

apps/meteor/tests/data/users.helper.js

@@ -60,3 +60,16 @@ export const getUserStatus = (userId) =>
 				resolve(res.body);
 			});
 	});
+
+
+export const getMe = (overrideCredential = credentials) =>
+	new Promise((resolve) => {
+		request
+			.get(api('me'))
+			.set(overrideCredential)
+			.expect('Content-Type', 'application/json')
+			.expect(200)
+			.end((end, res) => {
+				resolve(res.body);
+			});
+	});