feat: update Livechat_enabled_when_agent_idle setting to not include offline agents in the query

.changeset/purple-boxes-shout.md

@@ -0,0 +1,6 @@
+---
+'@rocket.chat/models': minor
+'@rocket.chat/meteor': minor
+---
+
+Updates omnichannel routing so agents with `offline` status are always excluded from assignment. The `Livechat_enabled_when_agent_idle` setting now only affects agents with `away` status.

apps/meteor/tests/e2e/omnichannel/omnichannel-assign-room-tags.spec.ts

@@ -53,16 +53,27 @@ test.describe('OC - Tags Visibility', () => {
 		});
 	});
 
-	test.beforeAll('Create conversations', async ({ api }) => {
-		conversations = await Promise.all([
-			createConversation(api, { visitorName: visitorA.name, agentId: 'user1', departmentId: departmentA.data._id }),
-			createConversation(api, { visitorName: visitorB.name, agentId: 'user1', departmentId: departmentB.data._id }),
-		]);
-	});
-
 	test.beforeEach(async ({ page }) => {
 		poOmnichannel = new HomeOmnichannel(page);
 		await page.goto('/');
+		await poOmnichannel.waitForHome();
+	});
+
+	test.beforeEach(async ({ api }) => {
+		if (conversations.length === 0) {
+			conversations = await Promise.all([
+				createConversation(api, {
+					visitorName: visitorA.name,
+					agentId: 'user1',
+					departmentId: departmentA.data._id,
+				}),
+				createConversation(api, {
+					visitorName: visitorB.name,
+					agentId: 'user1',
+					departmentId: departmentB.data._id,
+				}),
+			]);
+		}
 	});
 
 	test.afterAll(async ({ api }) => {

apps/meteor/tests/e2e/omnichannel/omnichannel-custom-field-usage.spec.ts

@@ -34,7 +34,7 @@ test.describe.serial('OC - Custom fields usage, scope : room and visitor', () =>
 	test.beforeAll('Set up agent, manager and custom fields', async ({ api }) => {
 		[agent, manager] = await Promise.all([createAgent(api, 'user1'), createManager(api, 'user1')]);
 
-		[roomCustomField, visitorCustomField, conversation] = await Promise.all([
+		[roomCustomField, visitorCustomField] = await Promise.all([
 			createCustomField(api, {
 				field: roomCustomFieldLabel,
 				label: roomCustomFieldName,
@@ -45,12 +45,19 @@ test.describe.serial('OC - Custom fields usage, scope : room and visitor', () =>
 				label: visitorCustomFieldName,
 				scope: 'visitor',
 			}),
-			createConversation(api, {
-				visitorName: visitor.name,
-				agentId: 'user1',
-				visitorToken,
-			}),
 		]);
+	});
+
+	test.beforeEach(async ({ page, api }) => {
+		poHomeChannel = new HomeOmnichannel(page);
+		await page.goto('/');
+		await poHomeChannel.waitForHome();
+
+		conversation = await createConversation(api, {
+			visitorName: visitor.name,
+			agentId: 'user1',
+			visitorToken,
+		});
 
 		await setVisitorCustomFieldValue(api, {
 			token: visitorToken,
@@ -59,12 +66,6 @@ test.describe.serial('OC - Custom fields usage, scope : room and visitor', () =>
 		});
 	});
 
-	test.beforeEach(async ({ page }) => {
-		poHomeChannel = new HomeOmnichannel(page);
-		await page.goto('/');
-		await poHomeChannel.waitForHome();
-	});
-
 	test.afterAll('Remove agent, manager, custom fields and conversation', async () => {
 		await Promise.all([agent.delete(), manager.delete(), roomCustomField.delete(), visitorCustomField.delete(), conversation.delete()]);
 	});

apps/meteor/tests/e2e/omnichannel/omnichannel-livechat-agent-idle-setting.spec.ts

@@ -0,0 +1,127 @@
+import type { Page } from '@playwright/test';
+
+import { createFakeVisitor } from '../../mocks/data';
+import { IS_EE } from '../config/constants';
+import { createAuxContext } from '../fixtures/createAuxContext';
+import { Users } from '../fixtures/userStates';
+import { HomeOmnichannel } from '../page-objects';
+import { OmnichannelLiveChat } from '../page-objects/omnichannel';
+import { setSettingValueById } from '../utils';
+import { createAgent } from '../utils/omnichannel/agents';
+import { test, expect } from '../utils/test';
+
+test.use({ storageState: Users.user1.state });
+
+test.describe('OC - Routing to Idle Agents', () => {
+	test.skip(!IS_EE, 'Enterprise Edition Only');
+
+	let poHomeOmnichannel: HomeOmnichannel;
+	let poLivechat: OmnichannelLiveChat;
+
+	let livechatPage: Page | undefined;
+
+	let agent: Awaited<ReturnType<typeof createAgent>>;
+	let visitor: { name: string; email: string };
+
+	const routingMethods = ['Auto_Selection', 'Load_Balancing', 'Load_Rotation'];
+
+	test.beforeAll(async ({ api }) => {
+		agent = await createAgent(api, 'user1');
+		await expect(agent.response).toBeOK();
+
+		const settingResponses = await Promise.all([
+			setSettingValueById(api, 'Accounts_Default_User_Preferences_idleTimeLimit', 300),
+			setSettingValueById(api, 'Omnichannel_enable_department_removal', true),
+		]);
+
+		for (const response of settingResponses) {
+			await expect(response).toBeOK();
+		}
+	});
+
+	test.beforeEach(async ({ page, browser, api }) => {
+		visitor = createFakeVisitor();
+		poHomeOmnichannel = new HomeOmnichannel(page);
+		await poHomeOmnichannel.page.goto('/');
+		await poHomeOmnichannel.waitForHome();
+
+		({ page: livechatPage } = await createAuxContext(browser, Users.user1, '/livechat', false));
+		poLivechat = new OmnichannelLiveChat(livechatPage, api);
+	});
+
+	test.afterEach(async ({ api }) => {
+		if (livechatPage) {
+			await livechatPage.context().close();
+		}
+
+		await expect(await setSettingValueById(api, 'Accounts_Default_User_Preferences_idleTimeLimit', 300)).toBeOK();
+	});
+
+	test.afterAll(async ({ api }) => {
+		const responses = await Promise.all([
+			agent.delete(),
+			setSettingValueById(api, 'Livechat_Routing_Method', 'Auto_Selection'),
+			setSettingValueById(api, 'Livechat_enabled_when_agent_idle', false),
+			setSettingValueById(api, 'Omnichannel_enable_department_removal', false),
+		]);
+
+		for (const response of responses) {
+			await expect(response).toBeOK();
+		}
+	});
+
+	routingMethods.forEach((routingMethod) => {
+		test.describe(`Routing method: ${routingMethod}`, () => {
+			test(`should not route to idle agents`, async ({ api }) => {
+				await test.step(`Setup routing method to ${routingMethod} and ignore idle agents`, async () => {
+					await expect(await setSettingValueById(api, 'Livechat_Routing_Method', routingMethod)).toBeOK();
+					await expect(await setSettingValueById(api, 'Livechat_enabled_when_agent_idle', false)).toBeOK();
+				});
+
+				await test.step('Visitor tries to initiate a conversation with the away agent', async () => {
+					await poLivechat.openAnyLiveChat();
+					await poLivechat.sendMessage(visitor, false);
+					await poLivechat.onlineAgentMessage.fill('Hello from visitor');
+
+					// Force Agent to become away by idle timeout
+					await expect(await setSettingValueById(api, 'Accounts_Default_User_Preferences_idleTimeLimit', 1)).toBeOK();
+					await poHomeOmnichannel.page.reload();
+					await expect(poHomeOmnichannel.navbar.getUserStatusBadge('away')).toBeVisible();
+
+					await poLivechat.btnSendMessageToOnlineAgent.click();
+				});
+
+				await test.step('Verify visitor is not taken by agent', async () => {
+					await expect(
+						poLivechat.alertMessage('Error starting a new conversation: Sorry, no online agents [no-agent-online]'),
+					).toBeVisible();
+				});
+			});
+
+			test(`should route to agents even if they are idle when setting is enabled`, async ({ api }) => {
+				await test.step(`Setup routing method to ${routingMethod} and allow idle agents`, async () => {
+					await expect(await setSettingValueById(api, 'Livechat_Routing_Method', routingMethod)).toBeOK();
+					await expect(await setSettingValueById(api, 'Livechat_enabled_when_agent_idle', true)).toBeOK();
+				});
+
+				await test.step('Force agent to become away by idle timeout', async () => {
+					await expect(await setSettingValueById(api, 'Accounts_Default_User_Preferences_idleTimeLimit', 1)).toBeOK();
+					await poHomeOmnichannel.page.reload();
+					await expect(poHomeOmnichannel.navbar.getUserStatusBadge('away')).toBeVisible();
+				});
+
+				await test.step('Visitor initiates chat', async () => {
+					await poLivechat.openAnyLiveChatAndSendMessage({
+						liveChatUser: visitor,
+						message: 'test message',
+						isOffline: false,
+					});
+				});
+
+				await test.step('Verify chat is served to an agent', async () => {
+					await expect(poLivechat.headerTitle).toHaveText(agent.data.username);
+				});
+			});
+		});
+	});
+});

apps/meteor/tests/e2e/omnichannel/omnichannel-livechat.spec.ts

@@ -265,8 +265,10 @@ test.describe('OC - Livechat - Close chat using widget', () => {
 	let poLiveChat: OmnichannelLiveChat;
 	let agent: Awaited<ReturnType<typeof createAgent>>;
 
-	test.beforeAll(async ({ api }) => {
+	test.beforeAll(async ({ api, browser }) => {
 		agent = await createAgent(api, 'user1');
+
+		await createAuxContext(browser, Users.user1, '/', true);
 	});
 
 	test.beforeEach(async ({ page, api }) => {