feat: Outbound Comms endpoints

apps/meteor/ee/app/livechat-enterprise/server/api/lib/outbound.ts

@@ -0,0 +1,33 @@
+import type { IOutboundMessageProviders } from '@rocket.chat/apps-engine/definition/outboundComunication';
+import type { IOutboundProvider } from '@rocket.chat/core-typings';
+
+import { OutboundMessageProvider } from '../../../../../../server/lib/OutboundMessageProvider';
+
+export class OutboundMessageProviderService {
+	private readonly provider: OutboundMessageProvider;
+
+	constructor() {
+		this.provider = new OutboundMessageProvider();
+	}
+
+	private isProviderValid(type?: string): type is 'phone' | 'email' {
+		return type === 'phone' || type === 'email';
+	}
+
+	public listOutboundProviders(type?: string): IOutboundProvider[] {
+		if (type !== undefined && !this.isProviderValid(type)) {
+			throw new Error('Invalid type');
+		}
+
+		const providers = this.provider.getOutboundMessageProviders(type);
+
+		return providers.map<IOutboundProvider>((provider: IOutboundMessageProviders) => {
+			return {
+				providerId: provider.appId,
+				providerName: provider.name,
+				supportsTemplates: true,
+				providerType: provider.type,
+			};
+		});
+	}
+}

apps/meteor/ee/app/livechat-enterprise/server/api/outbound.ts

@@ -0,0 +1,35 @@
+import { API } from '../../../../../app/api/server';
+import { isGETOutboundProviderParams } from '../outboundcomms/rest';
+import { OutboundMessageProviderService } from './lib/outbound';
+
+const outboundMessageProvider = new OutboundMessageProviderService();
+
+API.v1.addRoute(
+	'omnichannel/outbound/providers',
+	{ authRequired: true, validateParams: isGETOutboundProviderParams },
+	{
+		async get() {
+			const { type } = this.queryParams;
+
+			const providers = outboundMessageProvider.listOutboundProviders(type);
+
+			try {
+				return API.v1.success({
+					providers,
+				});
+			} catch (error) {
+				return API.v1.failure(error);
+			}
+		},
+	},
+);
+
+API.v1.addRoute(
+	'omnichannel/outbound/providers/:id/metadata',
+	{ authRequired: true },
+	{
+		async get() {
+			return API.v1.success();
+		},
+	},
+);

apps/meteor/tests/unit/app/livechat/server/outbound/outbound.spec.ts

@@ -0,0 +1,52 @@
+import { OutboundMessageProviderService } from '../../../../../../ee/app/livechat-enterprise/server/api/lib/outbound';
+
+jest.mock('./outbound', () => {
+	return {
+		OutboundMessageProvider: jest.fn().mockImplementation(() => {
+			return {
+				getOutboundMessageProviders: jest.fn((type?: string) => {
+					if (type === 'phone') {
+						return [{ appId: '1', name: 'PhoneProvider', type: 'phone' }];
+					}
+					if (type === 'email') {
+						return [{ appId: '2', name: 'EmailProvider', type: 'email' }];
+					}
+					return [
+						{ appId: '1', name: 'PhoneProvider', type: 'phone' },
+						{ appId: '2', name: 'EmailProvider', type: 'email' },
+					];
+				}),
+			};
+		}),
+	};
+});
+
+describe('OutboundMessageProviderService', () => {
+	let service: OutboundMessageProviderService;
+
+	beforeEach(() => {
+		service = new OutboundMessageProviderService();
+	});
+
+	it('should return all providers when type is not specified', () => {
+		const result = service.listOutboundProviders();
+		expect(result).toEqual([
+			{ providerId: '1', providerName: 'PhoneProvider', supportsTemplates: true, providerType: 'phone' },
+			{ providerId: '2', providerName: 'EmailProvider', supportsTemplates: true, providerType: 'email' },
+		]);
+	});
+
+	it('should return phone providers when type is "phone"', () => {
+		const result = service.listOutboundProviders('phone');
+		expect(result).toEqual([{ providerId: '1', providerName: 'PhoneProvider', supportsTemplates: true, providerType: 'phone' }]);
+	});
+
+	it('should return email providers when type is "email"', () => {
+		const result = service.listOutboundProviders('email');
+		expect(result).toEqual([{ providerId: '2', providerName: 'EmailProvider', supportsTemplates: true, providerType: 'email' }]);
+	});
+
+	it('should throw an error when type is invalid', () => {
+		expect(() => service.listOutboundProviders('invalid')).toThrow('Invalid type');
+	});
+});