fix: Newly added agent not following business hours (#29529)

Co-authored-by: Kevin Aleman <11577696+KevLehman@users.noreply.github.com>

.changeset/quick-coats-protect.md

@@ -0,0 +1,6 @@
+---
+"@rocket.chat/meteor": patch
+"@rocket.chat/model-typings": patch
+---
+
+fix: newly added agent not following business hours

apps/meteor/app/lib/server/functions/saveUser.js

@@ -419,11 +419,14 @@ export const saveUser = async function (userId, userData) {
 
 	await Users.updateOne({ _id: userData._id }, updateUser);
 
-	await callbacks.run('afterSaveUser', userData);
-
 	// App IPostUserUpdated event hook
 	const userUpdated = await Users.findOneById(userId);
 
+	await callbacks.run('afterSaveUser', {
+		user: userUpdated,
+		oldUser: oldUserData,
+	});
+
 	await Apps.triggerEvent(AppEvents.IPostUserUpdated, {
 		user: userUpdated,
 		previousUser: oldUserData,

apps/meteor/app/livechat/server/business-hour/AbstractBusinessHour.ts

@@ -1,23 +1,28 @@
 import moment from 'moment-timezone';
+import { ILivechatAgentStatus } from '@rocket.chat/core-typings';
 import type { ILivechatBusinessHour, ILivechatDepartment } from '@rocket.chat/core-typings';
 import type { ILivechatBusinessHoursModel, IUsersModel } from '@rocket.chat/model-typings';
 import { LivechatBusinessHours, Users } from '@rocket.chat/models';
 import type { UpdateFilter } from 'mongodb';
 
 import type { IWorkHoursCronJobsWrapper } from '../../../../server/models/raw/LivechatBusinessHours';
+import { businessHourLogger } from '../lib/logger';
+import { filterBusinessHoursThatMustBeOpened } from './Helper';
 
 export interface IBusinessHourBehavior {
 	findHoursToCreateJobs(): Promise<IWorkHoursCronJobsWrapper[]>;
 	openBusinessHoursByDayAndHour(day: string, hour: string): Promise<void>;
 	closeBusinessHoursByDayAndHour(day: string, hour: string): Promise<void>;
 	onDisableBusinessHours(): Promise<void>;
-	onAddAgentToDepartment(options?: Record<string, any>): Promise<any>;
+	onAddAgentToDepartment(options?: { departmentId: string; agentsId: string[] }): Promise<any>;
 	onRemoveAgentFromDepartment(options?: Record<string, any>): Promise<any>;
 	onRemoveDepartment(department?: ILivechatDepartment): Promise<any>;
 	onStartBusinessHours(): Promise<void>;
 	afterSaveBusinessHours(businessHourData: ILivechatBusinessHour): Promise<void>;
 	allowAgentChangeServiceStatus(agentId: string): Promise<boolean>;
 	changeAgentActiveStatus(agentId: string, status: string): Promise<any>;
+	// If a new agent is created, this callback will be called
+	onNewAgentCreated(agentId: string): Promise<void>;
 }
 
 export interface IBusinessHourType {
@@ -44,9 +49,7 @@ export abstract class AbstractBusinessHourBehavior {
 		return this.UsersRepository.isAgentWithinBusinessHours(agentId);
 	}
 
-	// After logout, users are turned not-available by default
-	// This will turn them available unless they put themselves offline (manual status change)
-	async changeAgentActiveStatus(agentId: string, status: string): Promise<any> {
+	async changeAgentActiveStatus(agentId: string, status: ILivechatAgentStatus): Promise<any> {
 		return this.UsersRepository.setLivechatStatusIf(
 			agentId,
 			status,
@@ -56,6 +59,29 @@ export abstract class AbstractBusinessHourBehavior {
 			{ livechatStatusSystemModified: true },
 		);
 	}
+
+	async onNewAgentCreated(agentId: string): Promise<void> {
+		businessHourLogger.debug(`Executing onNewAgentCreated for agentId: ${agentId}`);
+
+		const defaultBusinessHour = await LivechatBusinessHours.findOneDefaultBusinessHour();
+		if (!defaultBusinessHour) {
+			businessHourLogger.debug(`No default business hour found for agentId: ${agentId}`);
+			return;
+		}
+
+		const businessHourToOpen = await filterBusinessHoursThatMustBeOpened([defaultBusinessHour]);
+		if (!businessHourToOpen.length) {
+			businessHourLogger.debug(
+				`No business hour to open found for agentId: ${agentId}. Default business hour is closed. Setting agentId: ${agentId} to status: ${ILivechatAgentStatus.NOT_AVAILABLE}`,
+			);
+			await Users.setLivechatStatus(agentId, ILivechatAgentStatus.NOT_AVAILABLE);
+			return;
+		}
+
+		await Users.addBusinessHourByAgentIds([agentId], defaultBusinessHour._id);
+
+		businessHourLogger.debug(`Setting agentId: ${agentId} to status: ${ILivechatAgentStatus.AVAILABLE}`);
+	}
 }
 
 export abstract class AbstractBusinessHourType {

apps/meteor/app/livechat/server/business-hour/BusinessHourManager.ts

@@ -7,16 +7,7 @@ import { Users } from '@rocket.chat/models';
 import type { IBusinessHourBehavior, IBusinessHourType } from './AbstractBusinessHour';
 import { settings } from '../../../settings/server';
 import { callbacks } from '../../../../lib/callbacks';
-
-const cronJobDayDict: Record<string, number> = {
-	Sunday: 0,
-	Monday: 1,
-	Tuesday: 2,
-	Wednesday: 3,
-	Thursday: 4,
-	Friday: 5,
-	Saturday: 6,
-};
+import { businessHourLogger } from '../lib/logger';
 
 export class BusinessHourManager {
 	private types: Map<string, IBusinessHourType> = new Map();
@@ -35,6 +26,7 @@ export class BusinessHourManager {
 
 	async startManager(): Promise<void> {
 		await this.createCronJobsForWorkHours();
+		businessHourLogger.debug('Cron jobs created, setting up callbacks');
 		this.setupCallbacks();
 		await this.behavior.onStartBusinessHours();
 	}
@@ -115,12 +107,19 @@ export class BusinessHourManager {
 			callbacks.priority.HIGH,
 			'business-hour-livechat-on-save-agent-department',
 		);
+		callbacks.add(
+			'livechat.onNewAgentCreated',
+			this.behavior.onNewAgentCreated.bind(this),
+			callbacks.priority.HIGH,
+			'business-hour-livechat-on-agent-created',
+		);
 	}
 
 	private removeCallbacks(): void {
 		callbacks.remove('livechat.removeAgentDepartment', 'business-hour-livechat-on-remove-agent-department');
 		callbacks.remove('livechat.afterRemoveDepartment', 'business-hour-livechat-after-remove-department');
 		callbacks.remove('livechat.saveAgentDepartment', 'business-hour-livechat-on-save-agent-department');
+		callbacks.remove('livechat.onNewAgentCreated', 'business-hour-livechat-on-agent-created');
 	}
 
 	private async createCronJobsForWorkHours(): Promise<void> {
@@ -137,12 +136,17 @@ export class BusinessHourManager {
 		await Promise.all(finish.map(({ day, times }) => this.scheduleCronJob(times, day, 'close', this.closeWorkHoursCallback)));
 	}
 
-	private async scheduleCronJob(items: string[], day: string, type: string, job: (day: string, hour: string) => void): Promise<void> {
+	private async scheduleCronJob(
+		items: string[],
+		day: string,
+		type: 'open' | 'close',
+		job: (day: string, hour: string) => void,
+	): Promise<void> {
 		await Promise.all(
 			items.map((hour) => {
-				const jobName = `${day}/${hour}/${type}`;
-				const time = moment(hour, 'HH:mm');
-				const scheduleAt = `${time.minutes()} ${time.hours()} * * ${cronJobDayDict[day]}`;
+				const time = moment(hour, 'HH:mm').day(day);
+				const jobName = `${time.format('dddd')}/${time.format('HH:mm')}/${type}`;
+				const scheduleAt = `${time.minutes()} ${time.hours()} * * ${time.day()}`;
 				this.addToCache(jobName);
 				return this.cronJobs.add(jobName, scheduleAt, () => job(day, hour));
 			}),

apps/meteor/app/livechat/server/business-hour/Helper.ts

@@ -4,6 +4,7 @@ import { LivechatBusinessHourTypes } from '@rocket.chat/core-typings';
 import { LivechatBusinessHours, Users } from '@rocket.chat/models';
 
 import { createDefaultBusinessHourRow } from './LivechatBusinessHours';
+import { businessHourLogger } from '../lib/logger';
 
 export const filterBusinessHoursThatMustBeOpened = async (
 	businessHours: ILivechatBusinessHour[],
@@ -52,8 +53,10 @@ export const openBusinessHourDefault = async (): Promise<void> => {
 		},
 	});
 	const businessHoursToOpenIds = (await filterBusinessHoursThatMustBeOpened(activeBusinessHours)).map((businessHour) => businessHour._id);
+	businessHourLogger.debug({ msg: 'Opening default business hours', businessHoursToOpenIds });
 	await Users.openAgentsBusinessHoursByBusinessHourId(businessHoursToOpenIds);
 	await Users.updateLivechatStatusBasedOnBusinessHours();
+	businessHourLogger.debug('Done opening default business hours');
 };
 
 export const createDefaultBusinessHourIfNotExists = async (): Promise<void> => {

apps/meteor/app/livechat/server/business-hour/Single.ts

@@ -3,6 +3,7 @@ import { LivechatBusinessHourTypes } from '@rocket.chat/core-typings';
 import type { IBusinessHourBehavior } from './AbstractBusinessHour';
 import { AbstractBusinessHourBehavior } from './AbstractBusinessHour';
 import { openBusinessHourDefault } from './Helper';
+import { businessHourLogger } from '../lib/logger';
 
 export class SingleBusinessHourBehavior extends AbstractBusinessHourBehavior implements IBusinessHourBehavior {
 	async openBusinessHoursByDayAndHour(day: string, hour: string): Promise<void> {
@@ -25,6 +26,7 @@ export class SingleBusinessHourBehavior extends AbstractBusinessHourBehavior imp
 	}
 
 	async onStartBusinessHours(): Promise<void> {
+		businessHourLogger.debug('Starting Single Business Hours');
 		return openBusinessHourDefault();
 	}
 

apps/meteor/app/livechat/server/hooks/afterUserActions.ts

@@ -1,23 +1,51 @@
 import type { IUser } from '@rocket.chat/core-typings';
-import { Users } from '@rocket.chat/models';
-import type { UsersUpdateParamsPOST } from '@rocket.chat/rest-typings';
 
 import { callbacks } from '../../../../lib/callbacks';
+import { Livechat } from '../lib/Livechat';
+import { callbackLogger } from '../lib/logger';
 
-type UserData = UsersUpdateParamsPOST['data'] & { _id: string };
+type IAfterSaveUserProps = {
+	user: IUser;
+	oldUser: IUser | null;
+};
+
+const wasAgent = (user: Pick<IUser, 'roles'> | null) => user?.roles?.includes('livechat-agent');
+const isAgent = (user: Pick<IUser, 'roles'> | null) => user?.roles?.includes('livechat-agent');
+
+const handleAgentUpdated = async (userData: IAfterSaveUserProps) => {
+	const {
+		user: { _id: userId, username },
+		user: newUser,
+		oldUser,
+	} = userData;
+
+	if (wasAgent(oldUser) && !isAgent(newUser)) {
+		callbackLogger.debug('Removing agent', userId);
+		await Livechat.removeAgent(username);
+	}
 
-const handleAgentUpdated = async (userData: UserData) => {
-	if (!userData?.roles?.includes('livechat-agent')) {
-		await Users.unsetExtension(userData._id);
+	if (!wasAgent(oldUser) && isAgent(newUser)) {
+		callbackLogger.debug('Adding agent', userId);
+		await Livechat.addAgent(username);
 	}
 };
 
-const handleDeactivateUser = async (userData: IUser) => {
-	if (userData?.roles?.includes('livechat-agent')) {
-		await Users.unsetExtension(userData._id);
+const handleDeactivateUser = async (user: IUser) => {
+	if (wasAgent(user)) {
+		callbackLogger.debug('Removing agent', user._id);
+		await Livechat.removeAgent(user.username);
 	}
 };
 
-callbacks.add('afterSaveUser', handleAgentUpdated, callbacks.priority.LOW, 'livechat-after-save-user-remove-extension');
+const handleActivateUser = async (user: IUser) => {
+	if (isAgent(user)) {
+		callbackLogger.debug('Adding agent', user._id);
+		await Livechat.addAgent(user.username);
+	}
+};
+
+callbacks.add('afterSaveUser', handleAgentUpdated, callbacks.priority.LOW, 'livechat-after-save-user-update-agent');
+
+callbacks.add('afterDeactivateUser', handleDeactivateUser, callbacks.priority.LOW, 'livechat-after-deactivate-user-remove-agent');
 
-callbacks.add('afterDeactivateUser', handleDeactivateUser, callbacks.priority.LOW, 'livechat-after-deactivate-user-remove-extension');
+callbacks.add('afterActivateUser', handleActivateUser, callbacks.priority.LOW, 'livechat-after-activate-user-add-agent');

apps/meteor/app/livechat/server/hooks/saveAnalyticsData.ts

@@ -3,7 +3,7 @@ import { LivechatRooms } from '@rocket.chat/models';
 
 import { callbacks } from '../../../../lib/callbacks';
 import { normalizeMessageFileUpload } from '../../../utils/server/functions/normalizeMessageFileUpload';
-import { callbackLogger } from '../lib/callbackLogger';
+import { callbackLogger } from '../lib/logger';
 
 callbacks.add(
 	'afterSaveMessage',

apps/meteor/app/livechat/server/lib/Livechat.js

@@ -533,6 +533,9 @@ export const Livechat = {
 		if (await addUserRolesAsync(user._id, ['livechat-agent'])) {
 			await Users.setOperator(user._id, true);
 			await this.setUserStatusLivechat(user._id, user.status !== 'offline' ? 'available' : 'not-available');
+
+			callbacks.runAsync('livechat.onNewAgentCreated', user._id);
+
 			return user;
 		}
 
@@ -571,14 +574,10 @@ export const Livechat = {
 		const { _id } = user;
 
 		if (await removeUserFromRolesAsync(_id, ['livechat-agent'])) {
-			await Users.setOperator(_id, false);
-			await Users.removeLivechatData(_id);
-			await this.setUserStatusLivechat(_id, 'not-available');
-
 			await Promise.all([
+				Users.removeAgent(_id),
 				LivechatDepartmentAgents.removeByAgentId(_id),
 				LivechatVisitors.removeContactManagerByUsername(username),
-				Users.unsetExtension(_id),
 			]);
 			return true;
 		}

apps/meteor/app/livechat/server/lib/callbackLogger.ts → apps/meteor/app/livechat/server/lib/logger.ts

@@ -1,3 +1,4 @@
 import { Logger } from '../../../../server/lib/logger/Logger';
 
 export const callbackLogger = new Logger('[Omnichannel] Callback');
+export const businessHourLogger = new Logger('Business Hour');

apps/meteor/app/livechat/server/sendMessageBySMS.ts

@@ -5,7 +5,7 @@ import { OmnichannelIntegration } from '@rocket.chat/core-services';
 import { callbacks } from '../../../lib/callbacks';
 import { settings } from '../../settings/server';
 import { normalizeMessageFileUpload } from '../../utils/server/functions/normalizeMessageFileUpload';
-import { callbackLogger } from './lib/callbackLogger';
+import { callbackLogger } from './lib/logger';
 
 callbacks.add(
 	'afterSaveMessage',

apps/meteor/app/livechat/server/startup.ts

@@ -62,10 +62,14 @@ Meteor.startup(async () => {
 	await createDefaultBusinessHourIfNotExists();
 
 	settings.watch<boolean>('Livechat_enable_business_hours', async (value) => {
+		Livechat.logger.debug(`Changing business hour type to ${value}`);
 		if (value) {
-			return businessHourManager.startManager();
+			await businessHourManager.startManager();
+			Livechat.logger.debug(`Business hour manager started`);
+			return;
 		}
-		return businessHourManager.stopManager();
+		await businessHourManager.stopManager();
+		Livechat.logger.debug(`Business hour manager stopped`);
 	});
 
 	settings.watch<string>('Livechat_Routing_Method', function (value) {