@resolveio/server-lib 22.3.48 → 22.3.50

package/src/models/subscription.model.ts

@@ -0,0 +1,73 @@
+import SimpleSchema from 'simpl-schema';
+import { QueryMeta } from '../util/subscription-dependency-context';
+
+
+export interface SubscriptionModel {
+	[key: string]: SubscriptionPubModel;
+}
+
+export interface SubscriptionPubModel {
+	/* 
+		Name: check
+		Type: SimpleSchema
+		Inputs: N/A
+		Outputs: N/A
+		Reason: Define schema - Checks publication parameters to make sure all are valid
+		Required: Only if function has publication parameters
+	*/
+	check?: SimpleSchema;
+
+	/* 
+		Name: function
+		Type: Function
+		Inputs: 0 or more publication parameters (ie: id_bulktank: string)
+		Outputs: Promise<any | any[]>
+		Reason: Runs publication query to get data to send to client
+		Required: Always
+	*/
+	// eslint-disable-next-line no-unused-vars
+	function: (...parameters: any[]) => Promise<any | any[]>;
+
+	/* 
+		Name: collections
+		Type: Array
+		Inputs: N/A
+		Outputs: N/A
+		Reason: All collections which will be watching oplog to re-run this pub
+		Required: Always
+	*/
+	collections: string[];
+
+	/* 
+		Name: user_specific
+		Type: Boolean
+		Inputs: N/A
+		Outputs: N/A
+		Reason: Use if user is needed (ie 'users' publication, only send 'Admin' if 'super-admin' role)
+		Required: Only if function has parameter/s
+		- Low performance as if runs pub for each user, only use if needed
+	*/
+	user_specific?: boolean;
+}
+
+export interface ActiveSubscriptionModel {
+	publication: string;
+	subscriptionKey: string;
+	subscriptionData: any[];
+	collections: string[];
+	clients: ActiveSubscriptionClientModel[];
+	cacheId: number;
+	running: boolean;
+	runAgain: boolean;
+	collectionDependencies: Map<string, Set<string>>;
+	collectionFilters: Map<string, any[]>;
+	watchAllCollections: Set<string>;
+	collectionQueryMeta: Map<string, QueryMeta[]>;
+}
+
+export interface ActiveSubscriptionClientModel {
+	id_user: string;
+	messageId: number;
+	id_socket: string;
+	messageRoute: string;
+}

package/src/models/support-ticket.model.ts

@@ -0,0 +1,104 @@
+import { CollectionDocument } from './collection-document.model';
+
+export interface SupportTicketModel extends CollectionDocument {
+	type: SupportTicketType;
+	priority: SupportTicketPriority;
+	issue: string;
+	ai_recommendations?: SupportTicketAiRecommendationsModel;
+	support_ticket_number: number;
+	support_ticket_number_string: string;
+	status: SupportTicketStatus;
+	substatus: SupportTicketSubstatus;
+	client: string;
+	id_client: string;
+	url_ticket?: string;
+	messages: SupportTicketMessageModel[];
+	date_created: Date;
+	date_created_string: string;
+	id_user_created: string;
+	user_created: string;
+	billable: boolean;
+	date_investigation?: Date;
+	date_closed?: Date;
+	files: string[];
+	current_watchers: SupportTicketWatchersModel[];
+	client_user: SupportTicketClientUserModel;
+	users_assigned: SupportTicketUserAssignedModel[];
+	estimated_billable_hours?: number;
+	billable_hours?: number;
+	bill_description: string;
+	tasks: SupportTicketTaskModel[];
+	notes: SupportTicketNoteModel[];
+	difficulty: number;
+}
+
+export interface SupportTicketAiRecommendationsModel {
+	source?: string;
+	hidden_from_client?: boolean;
+	created_at?: Date;
+	source_message_id?: string;
+	summary?: string;
+	internal_recommendations?: string;
+	code_change_recommendations?: string;
+}
+
+export interface SupportTicketClientUserModel {
+	id_user: string;
+	user: string;
+	email: string;
+}
+
+export type SupportTicketPriority = 'High' | 'Low';
+
+export type SupportTicketSubstatus =
+	| 'New'
+	| 'Work In Progress'
+	| 'Idle'
+	| 'Awaiting Customer Interaction'
+	| 'Awaiting Customer Response'
+	| 'Awaiting Validation'
+	| 'Awaiting Internal Review';
+export type SupportTicketType = 'System Impairment' | 'Request New Feature' | 'General Inquery';
+export type SupportTicketStatus = 'Active' | 'Review' | 'Closed' | 'Opened' | 'Resolved';
+
+export interface SupportTicketMessageModel {
+	message: string;
+	id_user: string;
+	user: string;
+	date: Date;
+	type: SupportTicketMessageType;
+	internal?: boolean;
+	visibility?: 'public' | 'internal';
+	badge?: string;
+	source?: string;
+}
+
+type SupportTicketMessageType = 'ResolveIO' | 'Client';
+
+export interface SupportTicketWatchersModel {
+	user: string;
+	id_user: string;
+	email: string;
+}
+
+export interface SupportTicketTaskModel {
+	description: string;
+	completed: boolean;
+	id_user?: string;
+	user?: string;
+	date_created: Date;
+	date_completed?: Date;
+}
+
+export interface SupportTicketNoteModel {
+	description: string;
+	id_user: string;
+	user: string;
+	date_created: Date;
+}
+
+export interface SupportTicketUserAssignedModel  {
+	id_user: string;
+	user: string;
+	date_created: Date;
+} 

package/src/models/user-group.model.ts

@@ -0,0 +1,24 @@
+import { CollectionDocument } from './collection-document.model';
+
+export interface UserGroupModel extends CollectionDocument {
+	name: string;
+	landing_page?: string;
+	permissions: UserGroupPermissionModel[];
+	notifications: UserGroupNotificationModel[];
+}
+
+export interface UserGroupNotificationModel {
+	name: string;
+	selected: boolean;
+}
+
+export interface UserGroupPermissionModel {
+	name: string;
+	selected: boolean;
+	views: UserGroupViewModel[];
+}
+
+export interface UserGroupViewModel {
+	link: string;
+	selected: boolean;
+}

package/{models/user-guide.model.d.ts → src/models/user-guide.model.ts}

@@ -1,6 +1,7 @@
 import { CollectionDocument } from './collection-document.model';
+
 export interface UserGuideModel extends CollectionDocument {
-    link: string;
-    label: string;
-    message: string;
-}
+	link: string;
+	label: string;
+	message: string;
+}

package/src/models/user.model.ts

@@ -0,0 +1,96 @@
+import { CollectionDocument } from './collection-document.model';
+
+export interface UserModel extends CollectionDocument {
+	roles: UserRoleModel;
+	username: string;
+	email: string;
+	fullname: string;
+	active: boolean;
+	phonenumber: string;
+	readonly: boolean;
+	other: OtherObject;
+
+	//security
+	attempts: number;
+	salt: string;
+	hash: string;
+
+	last?: Date;
+	settings?: UserSettingsModel;
+	services?: Object;
+
+	is_customer?: boolean;
+}
+
+export interface StickySelectOption {
+	value: any;
+	label?: string;
+}
+
+export interface StickySelectPreference {
+	key: string;
+	defaultValue: any;
+	defaultLabel?: string;
+	multiple?: boolean;
+	options?: StickySelectOption[];
+	updatedAt?: string;
+}
+
+export interface UserSettingsModel {
+	table_color: string;
+	table_font_color: string;
+	secondary_table_color: string;
+	secondary_table_font_color: string;
+	tertiary_table_color: string;
+	tertiary_table_font_color: string;
+	font_size: number;
+	collapsable_menu: boolean;
+	entries_per_page: string
+	warning_color: string;
+	warning_font_color: string;
+	warning_hover_color: string;
+	success_color: string;
+	success_font_color: string;
+	success_hover_color: string;
+	danger_color: string;
+	danger_font_color: string;
+	danger_hover_color: string;
+	info_color: string;
+	info_font_color: string;
+	info_hover_color: string;
+	primary_color: string;
+	primary_font_color: string;
+	primary_hover_color: string;
+	secondary_color: string;
+	secondary_font_color: string;
+	secondary_hover_color: string;
+	routing_preference: string;
+	opening_route: string;
+	rio_select_search_mode?: string;
+}
+
+export interface UserRoleModel {
+	super_admin: boolean;
+	approvals: UserRoleApprovalModel[];
+	groups: UserRoleGroupModel[];
+	notifications: string[];
+	miscs: string[];
+}
+
+export interface UserRoleApprovalModel {
+	type: string; // po or afe or chemical
+	key_1?: string; // department or accounting code
+	key_2?: string; // order type
+	key_3?: string; // other/additional
+	name: string; // approval name
+}
+
+export interface UserRoleGroupModel {
+	name: string;
+	views: string[];
+	yards?: string[];
+}
+
+export interface OtherObject {
+    [key: string]: any;
+}

package/src/publications/ai-terminal.ts

@@ -0,0 +1,73 @@
+import SimpleSchema from 'simpl-schema';
+import { AiTerminalConversations } from '../collections/ai-terminal-conversation.collection';
+import { AiTerminalMessages } from '../collections/ai-terminal-message.collection';
+
+export function loadAiTerminalPublications(subscriptionManager) {
+	subscriptionManager.publications({
+		aiTerminalConversations: {
+			function: function(id_client?: string, id_app?: string, status?: string) {
+				const idUser = normalizeOptionalString(this?.id_user || '');
+				if (!idUser) {
+					return [];
+				}
+				const query: any = {
+					id_user: idUser
+				};
+				if (id_client) {
+					query.id_client = id_client;
+				}
+				if (id_app) {
+					query.id_app = id_app;
+				}
+				if (status) {
+					query.status = status;
+				}
+				return AiTerminalConversations.find(query, { sort: { updatedAt: -1 }, limit: 200 });
+			},
+			check: new SimpleSchema({
+				id_client: {
+					type: String,
+					optional: true
+				},
+				id_app: {
+					type: String,
+					optional: true
+				},
+				status: {
+					type: String,
+					optional: true
+				}
+			}),
+			collections: ['ai-terminal-conversations']
+		},
+		aiTerminalMessages: {
+			function: async function(id_conversation: string, limit?: number) {
+				const idUser = normalizeOptionalString(this?.id_user || '');
+				if (!idUser) {
+					return [];
+				}
+				const conversation = await AiTerminalConversations.findById(id_conversation);
+				if (!conversation || normalizeOptionalString(conversation.id_user) !== idUser) {
+					return [];
+				}
+				const limitValue = Number.isFinite(Number(limit)) ? Math.min(Math.max(Number(limit), 1), 400) : 200;
+				return AiTerminalMessages.find({ id_conversation }, { sort: { createdAt: 1 }, limit: limitValue });
+			},
+			check: new SimpleSchema({
+				id_conversation: {
+					type: String
+				},
+				limit: {
+					type: Number,
+					optional: true
+				}
+			}),
+			collections: ['ai-terminal-messages']
+		}
+	});
+}
+
+function normalizeOptionalString(value: any): string {
+	const raw = typeof value === 'string' ? value.trim() : '';
+	return raw || '';
+}

package/src/publications/app-settings.ts

@@ -0,0 +1,25 @@
+import SimpleSchema from 'simpl-schema';
+import { AppSettings } from '../collections/app-setting.collection';
+import { SubscriptionManager } from '../managers/subscription.manager';
+
+export function loadAppSettingsPublications(subscriptionManager: SubscriptionManager) {
+	subscriptionManager.publications({
+		appSettings: {
+			function: function() {
+				return AppSettings.find({}, { sort: { company_name: 1 } });
+			},
+			collections: ['app-settings']
+		},
+		appSettingById: {
+			check: new SimpleSchema({
+				id_app_setting: {
+					type: String
+				}
+			}),
+			function: function(id_app_setting: string) {
+				return AppSettings.findById(id_app_setting);
+			},
+			collections: ['app-settings']
+		}
+	});
+}

package/src/publications/app-status.ts

@@ -0,0 +1,13 @@
+import { SubscriptionManager } from '../managers/subscription.manager';
+import { AppStatus } from '../collections/app-status.collection';
+
+export function loadAppStatusPublications(subscriptionManager: SubscriptionManager) {
+	subscriptionManager.publications({
+		appstatus: {
+			function: function() {
+				return AppStatus.findOne({}, {sort: {createdAt: -1}});
+			},
+			collections: ['app-statuses']
+		}
+	});
+}

package/src/publications/cron-jobs.ts

@@ -0,0 +1,40 @@
+import SimpleSchema from 'simpl-schema';
+import { CronJobs } from '../collections/cron-job.collection';
+import { Users } from '../collections/user.collection';
+import { SubscriptionManager } from '../managers/subscription.manager';
+
+export function loadCronJobPublications(subscriptionManager: SubscriptionManager) {
+	subscriptionManager.publications({
+		cronjobs: {
+			function: function() {
+				return CronJobs.find({}, {sort: {name: 1}});
+			},
+			collections: ['cron-jobs']
+		},
+		cronjobsReportBuilderWithIdUser: {
+			function: async function(id_user: string) {
+				const user = await Users.findById(id_user);
+				const query: any = {
+					$and: [
+						{method_run_data: {$exists: 1}},
+						{'method_run_data.type': 'Report Builder Scheduled Job'}
+					]
+				};
+
+				if (!user?.roles?.super_admin) {
+					query.$and.push({'method_run_data.id_user': id_user});
+				}
+
+				return await CronJobs.find(query);
+			},
+			check: new SimpleSchema({
+				id_user: {
+					type: String,
+					optional: true
+				}
+			}),
+			collections: ['cron-jobs'],
+			user_specific: true
+		}
+	});
+}

package/src/publications/customer-notifications.ts

@@ -0,0 +1,101 @@
+import SimpleSchema from 'simpl-schema';
+import { CustomerNotifications } from '../collections/customer-notification.collection';
+import { Users } from '../collections/user.collection';
+import { SubscriptionManager } from '../managers/subscription.manager';
+
+const DEFAULT_USER_LIMIT = 100;
+const DEFAULT_ADMIN_LIMIT = 250;
+const MAX_LIMIT = 500;
+
+function normalizeLimit(value: any, fallback: number): number {
+	const parsed = Number(value);
+	if (!Number.isFinite(parsed) || parsed <= 0) {
+		return fallback;
+	}
+	return Math.min(Math.floor(parsed), MAX_LIMIT);
+}
+
+function normalizeId(value: any): string {
+	return String(value || '').trim();
+}
+
+function buildNotExpiredQuery(): Record<string, any> {
+	return {
+		$or: [
+			{
+				expires_at: {
+					$exists: false
+				}
+			},
+			{
+				expires_at: null
+			},
+			{
+				expires_at: {
+					$gt: new Date()
+				}
+			}
+		]
+	};
+}
+
+export function loadCustomerNotificationPublications(subscriptionManager: SubscriptionManager) {
+	subscriptionManager.publications({
+		userNotificationCenter: {
+			function: async function(id_user: string, limit?: number) {
+				const idUser = normalizeId(id_user);
+				if (!idUser) {
+					return [];
+				}
+
+				const query: Record<string, any> = {
+					id_user: idUser,
+					...buildNotExpiredQuery()
+				};
+
+				return await CustomerNotifications.find(query, {
+					sort: {
+						createdAt: -1
+					},
+					limit: normalizeLimit(limit, DEFAULT_USER_LIMIT)
+				});
+			},
+			check: new SimpleSchema({
+				limit: {
+					type: SimpleSchema.Integer,
+					optional: true
+				}
+			}),
+			collections: ['customer-notifications'],
+			user_specific: true
+		},
+		customerNotificationsAdmin: {
+			function: async function(id_user: string, limit?: number) {
+				const idUser = normalizeId(id_user);
+				if (!idUser) {
+					return [];
+				}
+
+				const user = await Users.findById(idUser);
+				if (!user?.roles?.super_admin) {
+					return [];
+				}
+
+				return await CustomerNotifications.find(buildNotExpiredQuery(), {
+					sort: {
+						createdAt: -1
+					},
+					limit: normalizeLimit(limit, DEFAULT_ADMIN_LIMIT)
+				});
+			},
+			check: new SimpleSchema({
+				limit: {
+					type: SimpleSchema.Integer,
+					optional: true
+				}
+			}),
+			collections: ['customer-notifications'],
+			user_specific: true
+		}
+	});
+}

package/src/publications/files.ts

@@ -0,0 +1,33 @@
+import SimpleSchema from 'simpl-schema';
+import { Files } from '../collections/file.collection';
+import { SubscriptionManager } from '../managers/subscription.manager';
+
+export function loadFilePublications(subscriptionManager: SubscriptionManager) {
+	subscriptionManager.publications({
+		fileWithId: {
+			function: function(id_file: string) {
+				return Files.findById(id_file);
+			},
+			check: new SimpleSchema({
+				id_file: {
+					type: String
+				}
+			}),
+			collections: ['files']
+		},
+		filesIn: {
+			function: function(id_files: string[]) {
+				return Files.find({_id: {$in: id_files}}, {sort: {name: 1}});
+			},
+			check: new SimpleSchema({
+				id_files: {
+					type: Array
+				},
+				'id_files.$': {
+					type: String
+				}
+			}),
+			collections: ['files']
+		}
+	});
+}

package/src/publications/flags-update.ts

@@ -0,0 +1,19 @@
+import SimpleSchema from 'simpl-schema';
+import { SubscriptionManager } from '../managers/subscription.manager';
+import { FlagUpdates } from '../collections/flag-update.collection';
+
+export function loadFlagsUpdatePublications(subscriptionManager: SubscriptionManager) {
+	subscriptionManager.publications({
+		flagUpdateWithType: {
+			function: function(flagType: string) {
+				return FlagUpdates.findOne({type: flagType});
+			},
+			check: new SimpleSchema({
+				flagType: {
+					type: String
+				}
+			}),
+			collections: ['flag-updates']
+		}
+	});
+}

package/src/publications/flags.ts

@@ -0,0 +1,19 @@
+import SimpleSchema from 'simpl-schema';
+import { SubscriptionManager } from '../managers/subscription.manager';
+import { Flags } from '../collections/flag.collection';
+
+export function loadFlagsPublications(subscriptionManager: SubscriptionManager) {
+	subscriptionManager.publications({
+		flagWithType: {
+			function: function(flagType: string) {
+				return Flags.findOne({type: flagType});
+			},
+			check: new SimpleSchema({
+				flagType: {
+					type: String
+				}
+			}),
+			collections: ['flags']
+		}
+	});
+}