[NEW] Rocket.cat message for users when an app previously requested is installed

apps/meteor/app/apps/client/orchestrator.ts

@@ -7,7 +7,7 @@ import type { IPermission } from '@rocket.chat/apps-engine/definition/permission
 import type { IAppStorageItem } from '@rocket.chat/apps-engine/server/storage/IAppStorageItem';
 import { Meteor } from 'meteor/meteor';
 import { Tracker } from 'meteor/tracker';
-import type { AppScreenshot, Serialized } from '@rocket.chat/core-typings';
+import type { AppScreenshot, AppRequestFilter, Pagination, IRestResponse, Serialized, AppRequest } from '@rocket.chat/core-typings';
 
 import type { App } from '../../../client/views/admin/apps/types';
 import { dispatchToastMessage } from '../../../client/lib/toast';
@@ -234,6 +234,28 @@ class AppClientOrchestrator {
 		throw new Error('Failed to build external url');
 	}
 
+	public async appRequests(
+		appId: string,
+		filter: AppRequestFilter,
+		sort: string,
+		pagination: Pagination,
+	): Promise<IRestResponse<AppRequest>> {
+		try {
+			const response: IRestResponse<AppRequest> = await APIClient.get(
+				`/apps/app-request?appId=${appId}&q=${filter}&sort=${sort}&limit=${pagination.limit}&offset=${pagination.offset}`,
+			);
+
+			const restResponse = {
+				data: response.data,
+				meta: response.meta,
+			};
+
+			return restResponse;
+		} catch (e: unknown) {
+			throw new Error('Could not get the list of app requests');
+		}
+	}
+
 	public async getCategories(): Promise<Serialized<ICategory[]>> {
 		const result = await APIClient.get('/apps', { categories: 'true' });
 

apps/meteor/app/apps/server/appRequestsCron.ts

@@ -0,0 +1,70 @@
+import { Meteor } from 'meteor/meteor';
+import { HTTP } from 'meteor/http';
+import { SyncedCron } from 'meteor/littledata:synced-cron';
+
+import { settings } from '../../settings/server';
+import { Apps } from './orchestrator';
+import { getWorkspaceAccessToken } from '../../cloud/server';
+import { appRequestNotififyForUsers } from './marketplace/appRequestNotifyUsers';
+
+export const appsNotifyAppRequests = Meteor.bindEnvironment(function _appsNotifyAppRequests() {
+	try {
+		const installedApps = Promise.await(Apps.installedApps({ enabled: true }));
+		if (!installedApps || installedApps.length === 0) {
+			return;
+		}
+
+		const workspaceUrl = settings.get<string>('Site_Url');
+		const token = Promise.await(getWorkspaceAccessToken());
+		const baseUrl = Apps.getMarketplaceUrl();
+		if (!baseUrl) {
+			Apps.debugLog(`could not load marketplace base url to send app requests notifications`);
+			return;
+		}
+
+		const options = {
+			headers: {
+				Authorization: `Bearer ${token}`,
+			},
+		};
+
+		const pendingSentUrl = `${baseUrl}/v1/app-request/sent/pending`;
+		const result = HTTP.get(pendingSentUrl, options);
+		const data = result.data?.data;
+		const filtered = installedApps.filter((app) => data.indexOf(app.getID()) !== -1);
+
+		filtered.forEach((app) => {
+			const appId = app.getID();
+			const appName = app.getName();
+
+			const usersNotified = Promise.await<(string | Error)[]>(
+				appRequestNotififyForUsers(baseUrl, workspaceUrl, appId, appName)
+					.then((response) => {
+						// Mark all app requests as sent
+						HTTP.post(`${baseUrl}/v1/app-request/markAsSent/${appId}`, options);
+						return response;
+					})
+					.catch((err) => {
+						Apps.debugLog(`could not send app request notifications for app ${appId}. Error: ${err}`);
+						return err;
+					}),
+			);
+
+			const errors = usersNotified.filter((batch) => batch instanceof Error);
+			if (errors.length > 0) {
+				Apps.debugLog(`Some batches of users could not be notified for app ${appId}. Errors: ${errors}`);
+			}
+		});
+	} catch (err) {
+		Apps.debugLog(err);
+	}
+});
+
+// Scheduling as every 12 hours to avoid multiple instances hiting the marketplace at the same time
+SyncedCron.add({
+	name: 'Apps-Request-End-Users:notify',
+	schedule: (parser) => parser.text('every 12 hours'),
+	job() {
+		appsNotifyAppRequests();
+	},
+});

apps/meteor/app/apps/server/communication/rest.js

@@ -885,5 +885,34 @@ export class AppsRestApi {
 				},
 			},
 		);
+
+		this.api.addRoute(
+			'app-request',
+			{ authRequired: true },
+			{
+				async get() {
+					const baseUrl = orchestrator.getMarketplaceUrl();
+					const { appId, q = '', sort = '', limit = 25, offset = 0 } = this.queryParams;
+					const headers = getDefaultHeaders();
+
+					const token = await getWorkspaceAccessToken();
+					if (token) {
+						headers.Authorization = `Bearer ${token}`;
+					}
+
+					try {
+						const data = HTTP.get(`${baseUrl}/v1/app-request?appId=${appId}&q=${q}&sort=${sort}&limit=${limit}&offset=${offset}`, {
+							headers,
+						});
+
+						return API.v1.success({ data });
+					} catch (e) {
+						orchestrator.getRocketChatLogger().error('Error getting all non sent app requests from the Marketplace:', e.message);
+
+						return API.v1.failure(e.message);
+					}
+				},
+			},
+		);
 	}
 }

apps/meteor/app/apps/server/index.ts

@@ -1,3 +1,4 @@
 import './cron';
+import './appRequestsCron';
 
 export { Apps, AppEvents } from './orchestrator';

apps/meteor/app/apps/server/marketplace/appRequestNotifyUsers.ts

@@ -0,0 +1,99 @@
+import { HTTP } from 'meteor/http';
+import { TAPi18n } from 'meteor/rocketchat:tap-i18n';
+import type { AppRequest, IUser, Pagination } from '@rocket.chat/core-typings';
+
+import { API } from '../../../api/server';
+import { getWorkspaceAccessToken } from '../../../cloud/server';
+import { sendDirectMessageToUsers } from '../../../../server/lib/sendDirectMessageToUsers';
+
+const ROCKET_CAT_USERID = 'rocket.cat';
+const DEFAULT_LIMIT = 100;
+
+const notifyBatchOfUsersError = (error: Error) => {
+	return new Error(`could not notify the batch of users. Error ${error}`);
+};
+
+const notifyBatchOfUsers = async (appName: string, learnMoreUrl: string, appRequests: AppRequest[]): Promise<string[]> => {
+	const batchRequesters = appRequests.reduce((acc: string[], appRequest: AppRequest) => {
+		// Prevent duplicate requesters
+		if (!acc.includes(appRequest.requester.id)) {
+			acc.push(appRequest.requester.id);
+		}
+
+		return acc;
+	}, []);
+
+	const msgFn = (user: IUser): string => {
+		const defaultLang = user.language || 'en';
+		const msg = `${TAPi18n.__('App_request_enduser_message', { appname: appName, learnmore: learnMoreUrl, lng: defaultLang })}`;
+
+		return msg;
+	};
+
+	try {
+		return await sendDirectMessageToUsers(ROCKET_CAT_USERID, batchRequesters, msgFn);
+	} catch (e) {
+		throw e;
+	}
+};
+
+export const appRequestNotififyForUsers = async (
+	marketplaceBaseUrl: string,
+	workspaceUrl: string,
+	appId: string,
+	appName: string,
+): Promise<(string | Error)[]> => {
+	try {
+		const token = await getWorkspaceAccessToken();
+		const headers = {
+			Authorization: `Bearer ${token}`,
+		};
+
+		// First request
+		const pagination: Pagination = { limit: DEFAULT_LIMIT, offset: 0 };
+
+		// First request to get the total and the first batch
+		const data = HTTP.get(
+			`${marketplaceBaseUrl}/v1/app-request?appId=${appId}&q=notification-not-sent&limit=${pagination.limit}&offset=${pagination.offset}`,
+			{ headers },
+		);
+
+		const appRequests = API.v1.success({ data });
+		const { total } = appRequests.body.data.data.meta;
+
+		if (total === undefined || total === 0) {
+			return [];
+		}
+
+		// Calculate the number of loops - 1 because the first request was already made
+		const loops = Math.ceil(total / pagination.limit) - 1;
+		const requestsCollection = [];
+		const learnMore = `${workspaceUrl}admin/marketplace/all/info/${appId}`;
+
+		// Notify first batch
+		requestsCollection.push(
+			Promise.resolve(appRequests.body.data.data.data)
+				.then((response) => notifyBatchOfUsers(appName, learnMore, response))
+				.catch(notifyBatchOfUsersError),
+		);
+
+		// Batch requests
+		for (let i = 0; i < loops; i++) {
+			pagination.offset += pagination.limit;
+
+			const request = HTTP.get(
+				`${marketplaceBaseUrl}/v1/app-request?appId=${appId}&q=notification-not-sent&limit=${pagination.limit}&offset=${pagination.offset}`,
+				{ headers },
+			);
+
+			requestsCollection.push(notifyBatchOfUsers(appName, learnMore, request.data.data));
+		}
+
+		const finalResult = await Promise.all(requestsCollection);
+
+		// Return the list of users that were notified
+		return finalResult.flat();
+	} catch (e) {
+		throw e;
+	}
+};

apps/meteor/app/apps/server/orchestrator.js

@@ -191,6 +191,14 @@ export class AppServerOrchestrator {
 		return this._manager.updateAppsMarketplaceInfo(apps).then(() => this._manager.get());
 	}
 
+	async installedApps(filter = {}) {
+		if (!this.isLoaded()) {
+			return;
+		}
+
+		return this._manager.get(filter);
+	}
+
 	async triggerEvent(event, ...payload) {
 		if (!this.isLoaded()) {
 			return;

apps/meteor/client/views/admin/apps/AppMenu.js

@@ -65,12 +65,12 @@ function AppMenu({ app, isAppDetailsPage, ...props }) {
 	}, [setModal]);
 
 	const confirmAction = useCallback(
-		(permissionsGranted) => {
+		async (permissionsGranted) => {
 			setModal(null);
 
-			marketplaceActions[action]({ ...app, permissionsGranted }).then(() => {
-				setLoading(false);
-			});
+			await marketplaceActions[action]({ ...app, permissionsGranted });
+
+			setLoading(false);
 		},
 		[setModal, action, app, setLoading],
 	);

apps/meteor/packages/rocketchat-i18n/i18n/en.i18n.json

@@ -5118,6 +5118,7 @@
   "Version": "Version",
   "Version_version": "Version __version__",
   "App_version_incompatible_tooltip": "App incompatible with Rocket.Chat version",
+  "App_request_enduser_message": "The app you requested, __appname__ has just been installed on this workspace.  [Click here to learn more](__learnmore__).",
   "Video_Conference_Description": "Configure conferencing calls for your workspace.",
   "Video_Chat_Window": "Video Chat",
   "Video_Conference": "Conference Call",

apps/meteor/server/lib/sendDirectMessageToUsers.ts

@@ -0,0 +1,34 @@
+import type { IUser } from '@rocket.chat/core-typings';
+import { Users } from '@rocket.chat/models';
+
+import { SystemLogger } from './logger/system';
+import { executeSendMessage } from '../../app/lib/server/methods/sendMessage';
+import { createDirectMessage } from '../methods/createDirectMessage';
+
+export async function sendDirectMessageToUsers(
+	fromId = 'rocket.cat',
+	toIds: string[],
+	messageFn: (user: IUser) => string,
+): Promise<string[]> {
+	const fromUser = await Users.findOneById(fromId, { projection: { _id: 1 } });
+	if (!fromUser) {
+		throw new Error(`User not found: ${fromId}`);
+	}
+
+	const users = Users.findByIds(toIds, { projection: { _id: 1, username: 1, language: 1 } });
+	const success: string[] = [];
+
+	users.forEach((user: IUser) => {
+		try {
+			const { rid } = createDirectMessage([user.username], fromId);
+			const msg = typeof messageFn === 'function' ? messageFn(user) : messageFn;
+
+			executeSendMessage(fromId, { rid, msg });
+			success.push(user._id);
+		} catch (error) {
+			SystemLogger.error(error);
+		}
+	});
+
+	return success;
+}

packages/core-typings/src/AppRequests.ts

@@ -0,0 +1,27 @@
+export type AppRequestFilter = 'unseen' | 'seen' | 'notification-sent' | 'notification-not-sent';
+
+export type AppRequestEndUser = {
+	id: string;
+	username: string;
+	name: string;
+	nickname: string;
+	emails: string[];
+};
+
+export type AppRequest = {
+	id: string;
+	appId: string;
+
+	requester: AppRequestEndUser;
+	admins: AppRequestEndUser[];
+
+	workspaceId: string;
+	mesage: string;
+
+	seen: boolean;
+	seenAt: string;
+	notificationSent: boolean;
+	notificationSentAt: string;
+
+	createdAt: string;
+};

packages/core-typings/src/MarketplaceRest.ts

@@ -0,0 +1,17 @@
+export type PaginationMeta = {
+	total: number;
+	limit: number;
+	offset: number;
+	sort: string;
+	filter: string;
+};
+
+export type Pagination = {
+	offset: number;
+	limit: number;
+};
+
+export interface IRestResponse<T> {
+	data: T[];
+	meta: PaginationMeta;
+}

packages/core-typings/src/index.ts

@@ -1,6 +1,8 @@
 export * from './Apps';
 export * from './AppOverview';
 export * from './FeaturedApps';
+export * from './AppRequests';
+export * from './MarketplaceRest';
 export * from './IRoom';
 export * from './UIKit';
 export * from './IMessage';