@resolveio/server-lib 12.5.54 → 12.5.55

package/src/collections/notification.collection.ts

@@ -1,51 +0,0 @@
-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

@@ -1,109 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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

@@ -1,149 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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);
-	}
-}