@resolveio/server-lib 12.5.53 → 12.5.54

package/src/publications/logs.ts

@@ -0,0 +1,164 @@
+import SimpleSchema from 'simpl-schema';
+import { Logs } from '../collections/log.collection';
+import { SubscriptionManager } from '../managers/subscription.manager';
+import { LogMethodLatencies } from '../collections/log-method-latency.collection';
+import { LogSubscriptions } from '../collections/log-subscription.collection';
+
+export function loadLogPublications(subscriptionManager: SubscriptionManager) {
+	subscriptionManager.publications({
+		logsWithType: {
+			function: (type: string) => {        
+				if (type === 'all') { 
+					return Logs.find({}, {sort: {createdAt: -1}});
+				}
+				return Logs.find({type: <any>type}, {sort: {createdAt: -1}});
+			},
+			check: new SimpleSchema({
+				type: {
+					type: String
+				}
+			}),
+			collections: ['logs']
+		},
+		logsWithTypes: {
+			function: (types: string[]) => {
+				return Logs.find({type: {$in: <any>types}}, {sort: {createdAt: -1}});
+			},
+			check: new SimpleSchema({
+				types: {
+					type: Array
+				},
+				'types.$': {
+					type: String
+				}
+			}),
+			collections: ['logs']
+		},
+		logsWithIdDocument: {
+			function: (id_document: string) => {
+				return Logs.find({id_document: id_document}, {sort: {createdAt: -1}});
+			},
+			check: new SimpleSchema({
+				id_document: {
+					type: String
+				}
+			}),
+			collections: ['logs']
+		},
+		logsWithMethod: {
+			function: (method: string) => {
+				return Logs.find({method: method}, {sort: {createdAt: -1}});
+			},
+			check: new SimpleSchema({
+				method: {
+					type: String
+				}
+			}),
+			collections: ['logs']
+		},
+		logsWithRoute: {
+			function: (route: string) => {
+				return Logs.find({route: route}, {sort: {createdAt: -1}});
+			},
+			check: new SimpleSchema({
+				route: {
+					type: String
+				}
+			}),
+			collections: ['logs']
+		},
+		logsWithCollection: {
+			function: (collection: string) => {
+				return Logs.find({collection: collection}, {sort: {createdAt: -1}});
+			},
+			check: new SimpleSchema({
+				collection: {
+					type: String
+				}
+			}),
+			collections: ['logs']
+		},
+		methodlatencies: {
+			function: () => {   
+				return LogMethodLatencies.find({}, {sort: {date_start: -1}});
+			},
+			collections: ['log-method-latencies'],
+		},
+		// superadminAPM: {
+		// 	check: new SimpleSchema({
+		// 		date_start: {
+		// 			type: Date
+		// 		},
+		// 		date_end: {
+		// 			type: Date
+		// 		}
+		// 	}),
+		// 	function: function(date_start: Date, date_end: Date) {
+		// 		return new Promise(async (resolve, reject) => {
+		// 			let latencies = await LogMethodLatencies.aggregate([
+		// 				{
+		// 					$match: {
+		// 						$and: [
+		// 							{
+		// 								createdAt: {$gte: date_start}
+		// 							},
+		// 							{
+		// 								createdAt: {$lte: date_end}
+		// 							}
+		// 						]
+		// 					}
+		// 				},
+		// 				{
+		// 					$group: {
+		// 						_id: '$method',
+		// 						method: {$first: '$method'},
+		// 						count: {$sum: 1},
+		// 						latency_min: {$min: '$latency_ms'},
+		// 						latency_avg: {$avg: '$latency_ms'},
+		// 						latency_max: {$max: '$latency_ms'}
+		// 					}
+		// 				},
+		// 				{
+		// 					$sort: {
+		// 						latency_avg: -1
+		// 					}
+		// 				}
+		// 			]);
+
+		// 			let subscriptions = await LogSubscriptions.aggregate([
+		// 				{
+		// 					$match: {
+		// 						$and: [
+		// 							{
+		// 								createdAt: {$gte: date_start}
+		// 							},
+		// 							{
+		// 								createdAt: {$lte: date_end}
+		// 							}
+		// 						]
+		// 					}
+		// 				},
+		// 				{
+		// 					$group: {
+		// 						_id: '$subscription',
+		// 						subscription: {$first: '$subscription'},
+		// 						count: {$sum: 1}
+		// 					}
+		// 				},
+		// 				{
+		// 					$sort: {
+		// 						count: -1
+		// 					}
+		// 				}
+		// 			]);
+
+		// 			resolve({
+		// 				methods: latencies,
+		// 				subscriptions: subscriptions
+		// 			});
+		// 		});
+		// 	},
+		// 	collections: ['log-method-latencies', 'log-subscriptions'],
+		// }
+	});
+}

package/src/publications/method-responses.ts

@@ -0,0 +1,13 @@
+import { SubscriptionManager } from '../managers/subscription.manager';
+import { MethodResponses } from '../collections/method-response.collection';
+
+export function loadMethodResponsePublications(subscriptionManager: SubscriptionManager) {
+	subscriptionManager.publications({
+		methodresponses: {
+			function: () => {
+				return MethodResponses.find({});
+			},
+			collections: ['method-responses']
+		}
+	});
+}

package/src/publications/notifications.ts

@@ -0,0 +1,13 @@
+import { Notifications } from '../collections/notification.collection';
+import { SubscriptionManager } from '../managers/subscription.manager';
+
+export function loadNotificationPublications(subscriptionManager: SubscriptionManager) {
+	subscriptionManager.publications({
+		notifications: {
+			function: () => {
+				return Notifications.find({}, {sort: {name: 1}});
+			},
+			collections: ['notifications']
+		}
+	});
+}

package/src/publications/report-builder-dashboard-builders.ts

@@ -0,0 +1,39 @@
+import SimpleSchema from 'simpl-schema';
+import { SubscriptionManager } from '../managers/subscription.manager';
+import { ReportBuilderDashboardBuilders } from '../collections/report-builder-dashboard-builder.collection';
+
+export function loadReportBuilderDashboardBuilderPublications(subscriptionManager: SubscriptionManager) {
+	subscriptionManager.publications({
+		reportbuilderdashboards: {
+			function: () => {
+				return ReportBuilderDashboardBuilders.find({}, {sort: {name: 1}});
+			},
+			collections: ['report-builder-dashboard-builders']
+		},
+		reportbuilderdashboardWithId: {
+			check: new SimpleSchema({
+				id_dashboard: {
+					type: String
+				}
+			}),
+			function: (id_dashboard: string) => {
+				return ReportBuilderDashboardBuilders.aggregate([
+					{
+						$match: {
+							_id: id_dashboard
+						}
+					},
+					{
+						$lookup: {
+							from: 'report-builder-reports',
+							localField: 'report_rows.report_columns.id_report',
+							foreignField: '_id',
+							as: 'dbReportBuilderReports'
+						}
+					}
+				]);
+			},
+			collections: ['report-builder-dashboard-builders']
+		}
+	});
+}

package/src/publications/report-builder-libraries.ts

@@ -0,0 +1,41 @@
+import SimpleSchema from 'simpl-schema';
+import { SubscriptionManager } from '../managers/subscription.manager';
+import { ReportBuilderLibraries } from '../collections/report-builder-library.collection';
+import { Users } from '../collections/user.collection';
+import { UserGroups } from '../collections/user-group.collection';
+
+export function loadReportBuilderLibraryPublications(subscriptionManager: SubscriptionManager) {
+	subscriptionManager.publications({
+		reportbuilderlibraries: {
+			function: () => {
+				return ReportBuilderLibraries.find({}, {sort: {name: 1}});
+			},
+			collections: ['report-builder-libraries']
+		},
+		reportbuilderlibrariesWithIdUser: {
+			check: new SimpleSchema({
+				id_user: {
+					type: String
+				}
+			}),
+			function: (id_user: string) => {
+				return ReportBuilderLibraries.find({id_user_create: id_user}, {sort: {name: 1}});
+			},
+			collections: ['users', 'report-builder-libraries']
+		},
+		reportbuilderlibrariesForUser: {
+			check: new SimpleSchema({
+				id_user: {
+					type: String
+				}
+			}),
+			function: async (id_user: string) => {
+				let user = await Users.findById(id_user);
+				let userGroups = await UserGroups.find({name: {$in: user.roles.groups.map(a => a.name)}});
+
+				return ReportBuilderLibraries.find({'user_groups.id_user_group': {$in: userGroups.map(a => a._id)}}, {sort: {name: 1}});
+			},
+			collections: ['users', 'report-builder-libraries']
+		},
+	});
+}

package/src/publications/report-builder-reports.ts

@@ -0,0 +1,48 @@
+import SimpleSchema from 'simpl-schema';
+import { ReportBuilderReports } from '../collections/report-builder-report.collection';
+import { CollectionDocument } from '../models/collection-document.model';
+import { SubscriptionManager } from '../managers/subscription.manager';
+
+export function loadReportBuilderReportPublications(subscriptionManager: SubscriptionManager) {
+	subscriptionManager.publications({
+		reportbuilderreports: {
+			function: () => {
+				return ReportBuilderReports.find({}, {sort: {report_name: 1}});
+			},
+			collections: ['report-builder-reports']
+		},
+		reportbuilderreportsWithIdUser: {
+			check: new SimpleSchema({
+				id_user: {
+					type: String
+				}
+			}),
+			function: (id_user: string) => {
+				return ReportBuilderReports.find({id_user : id_user});
+			},
+			collections: ['report-builder-reports']
+		},
+		reportbuilderreportWithId: {
+			check: new SimpleSchema({
+				id: {
+					type: String
+				}
+			}),
+			function: (id: string) => {
+				return ReportBuilderReports.findOne({_id: id});
+			},
+			collections: ['report-builder-reports']
+		},
+		reportbuilderreportsWithCustomerId: {
+			check: new SimpleSchema({
+				id: {
+					type: String
+				}
+			}),
+			function: (id: string) => {
+				return ReportBuilderReports.find({shared_users: {$in: [id]}});
+			},
+			collections: ['report-builder-reports']
+		}
+	});
+}

package/src/publications/super-admin.ts

@@ -0,0 +1,13 @@
+import { SubscriptionManager } from '../managers/subscription.manager';
+import { LoggedInUsers } from '../collections/logged-in-users.collection';
+
+export function loadSuperAdminPublications(subscriptionManager: SubscriptionManager) {
+	subscriptionManager.publications({
+		loggedInUsers: {
+			function: function() {
+				return LoggedInUsers.find({}, {sort: {user: 1}});
+			},
+			collections: ['logged-in-users']
+		}
+	});
+}

package/src/publications/user-groups.ts

@@ -0,0 +1,12 @@
+import { UserGroups } from '../collections/user-group.collection';
+
+export function loadUserGroupPublications(subscriptionManager) {
+	subscriptionManager.publications({
+		usergroups: {
+			function: () => {
+				return UserGroups.find({}, {sort: {name: 1}});
+			},
+			collections: ['user-groups']
+		}
+	});
+}

package/src/publications/user-guides.ts

@@ -0,0 +1,12 @@
+import { UserGuides } from '../collections/user-guide.collection';
+
+export function loadUserGuidePublications(subscriptionManager) {
+	subscriptionManager.publications({
+		userGuides: {
+			function: () => {
+				return UserGuides.find({}, {sort: {name: 1}});
+			},
+			collections: ['user-guides']
+		}
+	});
+}