@resolveio/server-lib 12.5.52 → 12.5.54

package/src/collections/monitor-mongo.collection.ts

@@ -0,0 +1,69 @@
+import { ResolveIOServer } from '../index';
+import { MongoManagerCollection, MongoManagerModel } from '../managers/mongo.manager';
+import { MonitorMongoModel } from '../models/monitor-mongo.model';
+
+let schema: any = {
+	_id: {
+		type: String,
+		optional: true
+	},
+	metadata: {
+		type: Object
+	},
+	'metadata.client': {
+		type: String
+	},
+	'metadata.instance': {
+		type: String
+	},
+	date: {
+		type: Date
+	},
+	method: {
+		type: String
+	},
+	doc_collection: {
+		type: String
+	},
+	duration: {
+		type: Number
+	},
+	query: {
+		type: String
+	}
+};
+
+export let MonitorMongos: MongoManagerCollection<MonitorMongoModel> = null;
+
+initializeCollection();
+
+function initializeCollection() {
+	if (ResolveIOServer && ResolveIOServer.getMainDB()) {
+		const model = new MongoManagerModel<MonitorMongoModel>({
+			collectionName: 'monitor-mongos',
+			schema: schema,
+			useVersionCollection: false,
+			useReportBuilder: false,
+			reportBuilderLookupTables: [],
+			timestamps: false,
+			createLogs: false,
+			checkSchema: false,
+			collectionOptions: {
+				timeseries: {
+					timeField: 'date',
+					granularity: 'seconds',
+					metaField: 'metadata'
+				},
+				expireAfterSeconds: 60 * 60 * 24 * 3
+			}
+		});
+		MonitorMongos = model.collection_main;
+		MonitorMongos.createIndex({'metadata.client': 1, date: 1});
+		MonitorMongos.createIndex({'metadata.client': 1, 'metadata.instance': 1, date: 1});
+	}
+	else {
+		setTimeout(() => {
+			initializeCollection();
+		}, 1);
+	}
+}

package/src/collections/notification.collection.ts

@@ -0,0 +1,51 @@
+import { ResolveIOServer } from '../index';
+import { MongoManagerCollection, MongoManagerModel } from '../managers/mongo.manager';
+import { NotificationModel } from '../models/notification.model';
+
+let schema: any = {
+	_id: {
+		type: String,
+		optional: true
+	},
+	__v: {
+		type: Number,
+		optional: true
+	},
+	updatedAt: {
+		type: Date,
+		optional: true
+	},
+	createdAt: {
+		type: Date,
+		optional: true
+	},
+	name: {
+		type: String
+	}
+};
+
+export let Notifications: MongoManagerCollection<NotificationModel> = null;
+
+initializeCollection();
+
+function initializeCollection() {
+	if (ResolveIOServer && ResolveIOServer.getMainDB()) {
+		const model = new MongoManagerModel<NotificationModel>({
+			collectionName: 'notifications',
+			schema: schema,
+			useVersionCollection: false,
+			useReportBuilder: false,
+			reportBuilderLookupTables: [],
+			timestamps: true,
+			createLogs: false,
+			checkSchema: true,
+			collectionOptions: null
+		});
+		Notifications = model.collection_main;
+	}
+	else {
+		setTimeout(() => {
+			initializeCollection();
+		}, 1);
+	}
+}

package/src/collections/report-builder-dashboard-builder.collection.ts

@@ -0,0 +1,109 @@
+import { ResolveIOServer } from '../index';
+import { MongoManagerCollection, MongoManagerModel } from '../managers/mongo.manager';
+import { ReportBuilderDashboardBuilderModel } from '../models/report-builder-dashboard-builder.model';
+
+let schema: any = {
+	_id: {
+		type: String,
+		optional: true
+	},
+	__v: {
+		type: Number,
+		optional: true
+	},
+	updatedAt: {
+		type: Date,
+		optional: true
+	},
+	createdAt: {
+		type: Date,
+		optional: true
+	},
+	name: {
+		type: String
+	},
+	date_created: {
+		type: Date
+	},
+	id_user_created: {
+		type: String
+	},
+	user_created: {
+		type: String
+	},
+	num_rows: {
+		type: Number
+	},
+	num_columns: {
+		type: Number
+	},
+	report_rows: {
+		type: Array
+	},
+	'report_rows.$': {
+		type: Object
+	},
+	'report_rows.$.report_columns': {
+		type: Array
+	},
+	'report_rows.$.report_columns.$': {
+		type: Object
+	},
+	'report_rows.$.report_columns.$.id_report': {
+		type: String
+	},
+	'report_rows.$.report_columns.$.report_name': {
+		type: String
+	},
+	'report_rows.$.report_columns.$.report_type': {
+		type: String
+	},
+	'report_rows.$.report_columns.$.display_type': {
+		type: String
+	},
+	'report_rows.$.report_columns.$.display_values': {
+		type: Array
+	},
+	'report_rows.$.report_columns.$.display_values.$': {
+		type: String
+	},
+	'report_rows.$.report_columns.$.display_text': {
+		type: String
+	},
+	'report_rows.$.report_columns.$.display_value': {
+		type: String
+	},
+	other: {
+		type: Object,
+		blackbox: true,
+		optional: true
+	}
+};
+
+export let ReportBuilderDashboardBuilders: MongoManagerCollection<ReportBuilderDashboardBuilderModel> = null;
+
+initializeCollection();
+
+function initializeCollection() {
+	if (ResolveIOServer && ResolveIOServer.getMainDB()) {
+		const model = new MongoManagerModel<ReportBuilderDashboardBuilderModel>({
+			collectionName: 'report-builder-dashboard-builders',
+			schema: schema,
+			useVersionCollection: false,
+			useReportBuilder: false,
+			reportBuilderLookupTables: [],
+			timestamps: true,
+			createLogs: true,
+			checkSchema: true,
+			collectionOptions: null
+		});
+		ReportBuilderDashboardBuilders = model.collection_main;
+		ReportBuilderDashboardBuilders.createIndex({name: 1});
+		ReportBuilderDashboardBuilders.createIndex({date_created: 1});
+	}
+	else {
+		setTimeout(() => {
+			initializeCollection();
+		}, 1);
+	}
+}

package/src/collections/report-builder-library.collection.ts

@@ -0,0 +1,89 @@
+import { ResolveIOServer } from '../index';
+import { MongoManagerCollection, MongoManagerModel } from '../managers/mongo.manager';
+import { ReportBuilderLibraryModel } from '../models/report-builder-library.model';
+
+let schema: any = {
+	_id: {
+		type: String,
+		optional: true
+	},
+	__v: {
+		type: Number,
+		optional: true
+	},
+	updatedAt: {
+		type: Date,
+		optional: true
+	},
+	createdAt: {
+		type: Date,
+		optional: true
+	},
+	name: {
+		type: String
+	},
+	id_user_create: {
+		type: String
+	},
+	user_create: {
+		type: String
+	},
+	date: {
+		type: Date
+	},
+	reports: {
+		type: Array
+	},
+	'reports.$': {
+		type: Object
+	},
+	'reports.$.id_report': {
+		type: String
+	},
+	'reports.$.report': {
+		type: String
+	},
+	user_groups: {
+		type: Array
+	},
+	'user_groups.$': {
+		type: Object
+	},
+	'user_groups.$.id_user_group': {
+		type: String
+	},
+	'user_groups.$.user_group': {
+		type: String
+	}
+};
+
+
+
+export let ReportBuilderLibraries: MongoManagerCollection<ReportBuilderLibraryModel> = null;
+
+initializeCollection();
+
+function initializeCollection() {
+	if (ResolveIOServer && ResolveIOServer.getMainDB()) {
+		const model = new MongoManagerModel<ReportBuilderLibraryModel>({
+			collectionName: 'report-builder-libraries',
+			schema: schema,
+			useVersionCollection: false,
+			useReportBuilder: false,
+			reportBuilderLookupTables: [],
+			timestamps: true,
+			createLogs: true,
+			checkSchema: true,
+			collectionOptions: null
+		});
+		ReportBuilderLibraries = model.collection_main;
+		ReportBuilderLibraries.createIndex({name: 1});
+		ReportBuilderLibraries.createIndex({id_user_create: 1});
+		ReportBuilderLibraries.createIndex({'user_groups.id_user_group': 1});
+	}
+	else {
+		setTimeout(() => {
+			initializeCollection();
+		}, 1);
+	}
+}

package/src/collections/report-builder-report.collection.ts

@@ -0,0 +1,149 @@
+import { ResolveIOServer } from '../index';
+import { MongoManagerCollection, MongoManagerModel } from '../managers/mongo.manager';
+import { ReportBuilderReportModel } from '../models/report-builder-report.model';
+
+let schema: any = {
+	_id: {
+		type: String,
+		optional: true
+	},
+	__v: {
+		type: Number,
+		optional: true
+	},
+	updatedAt: {
+		type: Date,
+		optional: true
+	},
+	createdAt: {
+		type: Date,
+		optional: true
+	},
+	collection_root: {
+		type: String
+	},
+	report_name: {
+		type: String
+	},
+	fields_sort: {
+		type: Array
+	},
+	'fields_sort.$': {
+		type: Object
+	},
+	'fields_sort.$.field': {
+		type: String
+	},
+	'fields_sort.$.order': {
+		type: String
+	},
+	fields_filter: {
+		type: Array
+	},
+	'fields_filter.$': {
+		type: Object,
+		blackbox: true
+	},
+	fields_custom: {
+		type: Array
+	},
+	'fields_custom.$': {
+		type: Object,
+		blackbox: true
+	},
+	fields_selected: {
+		type: Array
+	},
+	'fields_selected.$': {
+		type: Object,
+		blackbox: true
+	},
+	fields_total: {
+		type: Array
+	},
+	'fields_total.$': {
+		type: Object,
+		blackbox: true
+	},
+	fields_link: {
+		type: Array
+	},
+	'fields_link.$': {
+		type: Object,
+		blackbox: true
+	},
+	id_user: {
+		type: String
+	},
+	user: {
+		type: String
+	},
+	date_created: {
+		type: Date
+	},
+	shared_users: {
+		type: Array
+	},
+	'shared_users.$': {
+		type: String
+	},
+	type: {
+		type: String
+	},
+	groups_row: {
+		type: Array
+	},
+	'groups_row.$': {
+		type: Object,
+		blackbox: true
+	},
+	groups_column: {
+		type: Array
+	},
+	'groups_column.$': {
+		type: Object,
+		blackbox: true
+	},
+	group_type: {
+		type: String
+	},
+	id_date_field: {
+		type: String,
+		optional: true
+	},
+	date_interval: {
+		type: String,
+		optional: true
+	}
+};
+
+export let ReportBuilderReports: MongoManagerCollection<ReportBuilderReportModel> = null;
+export let ReportBuilderReportVersions: MongoManagerCollection<ReportBuilderReportModel> = null;
+
+initializeCollection();
+
+function initializeCollection() {
+	if (ResolveIOServer && ResolveIOServer.getMainDB()) {
+		const model = new MongoManagerModel<ReportBuilderReportModel>({
+			collectionName: 'report-builder-reports',
+			schema: schema,
+			useVersionCollection: true,
+			useReportBuilder: false,
+			reportBuilderLookupTables: [],
+			timestamps: true,
+			createLogs: true,
+			checkSchema: true,
+			collectionOptions: null
+		});
+		ReportBuilderReports = model.collection_main;
+		ReportBuilderReports.createIndex({id_user: 1});
+		ReportBuilderReports.createIndex({shared_users: 1});
+		ReportBuilderReports.createIndex({report_name: 1, collection_root: 1});
+		ReportBuilderReportVersions = model.collection_version;
+	}
+	else {
+		setTimeout(() => {
+			initializeCollection();
+		}, 1);
+	}
+}

package/src/collections/user-group.collection.ts

@@ -0,0 +1,90 @@
+import { ResolveIOServer } from '../index';
+import { MongoManagerCollection, MongoManagerModel } from '../managers/mongo.manager';
+import { UserGroupModel } from '../models/user-group.model';
+
+let schema: any = {
+	_id: {
+		type: String,
+		optional: true
+	},
+	__v: {
+		type: Number,
+		optional: true
+	},
+	updatedAt: {
+		type: Date,
+		optional: true
+	},
+	createdAt: {
+		type: Date,
+		optional: true
+	},
+	name: {
+		type: String
+	},
+	permissions: {
+		type: Array
+	},
+	'permissions.$': {
+		type:  Object
+	},
+	'permissions.$.name': {
+		type: String
+	},
+	'permissions.$.selected': {
+		type: Boolean
+	},
+	'permissions.$.views': {
+		type: Array
+	},
+	'permissions.$.views.$': {
+		type: Object
+	},
+	'permissions.$.views.$.link': {
+		type: String
+	},
+	'permissions.$.views.$.selected': {
+		type: Boolean
+	},
+	notifications: {
+		type: Array
+	},
+	'notifications.$': {
+		type:  Object
+	},
+	'notifications.$.name': {
+		type: String
+	},
+	'notifications.$.selected': {
+		type: Boolean
+	}
+};
+
+export let UserGroups: MongoManagerCollection<UserGroupModel> = null;
+export let UserGroupVersions: MongoManagerCollection<UserGroupModel> = null;
+
+initializeCollection();
+
+function initializeCollection() {
+	if (ResolveIOServer && ResolveIOServer.getMainDB()) {
+		const model = new MongoManagerModel<UserGroupModel>({
+			collectionName: 'user-groups',
+			schema: schema,
+			useVersionCollection: true,
+			useReportBuilder: true,
+			reportBuilderLookupTables: [],
+			timestamps: true,
+			createLogs: false,
+			checkSchema: true,
+			collectionOptions: null
+		});
+		UserGroups = model.collection_main;
+		UserGroups.createIndex({name: 1});
+		UserGroupVersions = model.collection_version;
+	}
+	else {
+		setTimeout(() => {
+			initializeCollection();
+		}, 1);
+	}
+}

package/src/collections/user-guide.collection.ts

@@ -0,0 +1,57 @@
+import { ResolveIOServer } from '../index';
+import { MongoManagerCollection, MongoManagerModel } from '../managers/mongo.manager';
+import { UserGuideModel } from '../models/user-guide.model';
+
+let schema: any = {
+	_id: {
+		type: String,
+		optional: true
+	},
+	__v: {
+		type: Number,
+		optional: true
+	},
+	updatedAt: {
+		type: Date,
+		optional: true
+	},
+	createdAt: {
+		type: Date,
+		optional: true
+	},
+	link: {
+		type: String
+	},
+	label: {
+		type: String
+	},
+	message: {
+		type: String
+	},
+};
+
+export let UserGuides: MongoManagerCollection<UserGuideModel> = null;
+
+initializeCollection();
+
+function initializeCollection() {
+	if (ResolveIOServer && ResolveIOServer.getMainDB()) {
+		const model = new MongoManagerModel<UserGuideModel>({
+			collectionName: 'user-guides',
+			schema: schema,
+			useVersionCollection: false,
+			useReportBuilder: false,
+			reportBuilderLookupTables: [],
+			timestamps: true,
+			createLogs: false,
+			checkSchema: true,
+			collectionOptions: null
+		});
+		UserGuides = model.collection_main;
+	}
+	else {
+		setTimeout(() => {
+			initializeCollection();
+		}, 1);
+	}
+}