@resolveio/server-lib 1.0.0-rc14 → 1.0.0-rc15

package/index.d.ts

@@ -6,10 +6,464 @@ export declare class ResolveIOServer {
     private static _mainServer;
     private static _client;
     constructor(serverConfig: any, client: string);
-    static connectAndRun(): Promise<void>;
+    static connectAndRun(): Promise<{}>;
     static getClientName(): string;
     static getMainServer(): ResolveIOMainServer;
     static getMainDB(): any;
     static getSupportDB(): any;
 }
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=index.d.ts.map
+export declare function loadCloudConvertMethods(methodManager: MethodManager): void;
+export declare function loadCollectionMethods(methodManager: MethodManager): void;
+export declare function loadLogMethods(methodManager: MethodManager): void;
+export declare function loadPDFMethods(methodManager: MethodManager): void;
+export declare function loadCronJobMethods(methodManager: MethodManager): void;
+export declare function loadAWSMethods(methodManager: MethodManager): void;
+export declare function loadCounterMethods(methodManager: MethodManager): void;
+export declare function loadAccountMethods(methodManager: MethodManager): void;
+export declare function loadFlagMethods(methodManager: MethodManager): void;
+export declare function deepCopy(obj: any): any;
+export declare function dateReviver(key: any, value: any): any;
+export declare function getMongoUpdates(currDoc: any, modifiedDoc: any, incVersion: any): any;
+export declare function getMongoMergeUpdatedDoc(f_doc: any, currentDoc: any, oldDoc: any): any;
+export declare function mergeUpdates(...updatesToMerge: any[]): {
+    $set: {};
+    $unset: {};
+    $inc: {};
+    $push: {};
+    $pull: {};
+};
+export declare function getDeepDiff(doc1: any, doc2: any): any;
+export declare function applyMongoUpdate(uDoc: any, delta: any): any;
+export declare function getBinarySize(string: any): number;
+export declare function loadSuperAdminPublications(subscriptionManager: SubscriptionManager): void;
+export declare function loadLogPublications(subscriptionManager: SubscriptionManager): void;
+export declare function loadMethodResponsePublications(subscriptionManager: SubscriptionManager): void;
+export declare function loadSupportTicketPublications(subscriptionManager: any): void;
+export declare function loadFilePublications(subscriptionManager: SubscriptionManager): void;
+export declare function loadAppStatusPublications(subscriptionManager: SubscriptionManager): void;
+export declare function loadMethodCallsPublications(subscriptionManager: SubscriptionManager): void;
+export declare function loadCronJobPublications(subscriptionManager: SubscriptionManager): void;
+export declare function loadAppVersionPublications(subscriptionManager: SubscriptionManager): void;
+export declare function loadFlagsPublications(subscriptionManager: SubscriptionManager): void;
+export declare class CronManager {
+    private _cronManager;
+    private _mainServer;
+    constructor(mainServer: any);
+    private loadCronJobs;
+    private doesCronJobExist;
+    private doesCronJobNameExist;
+    private addCronJob;
+    private updateCronJob;
+    private removeCronJob;
+    private startCronJob;
+    private stopCronJob;
+    private stopAllCronJobs;
+    checkCronJobsForUpdates(): Promise<void>;
+    private runCronJob;
+}
+export declare class SubscriptionManager {
+    private _mainServer;
+    private _publications;
+    private _subscriptions;
+    private _wss;
+    private _sendQueue;
+    private _runningQueue;
+    private serverConfig;
+    constructor(mainServer: any, wss: WebSocket.Server, serverConfig: any);
+    publications(method: SubscriptionModel): void;
+    loggedInLatency(ws: WebSocket): Promise<void>;
+    subscribe(ws: WebSocket, messageId: number, publication: string, ...subscriptionData: any[]): Promise<void>;
+    unsubscribe(ws: WebSocket, messageId: number, publication: string, ...subscriptionData: any[]): Promise<void>;
+    unsubscribeAll(ws: WebSocket): Promise<void>;
+    private getPublicationCollections;
+    private tailOpLog;
+    private tailOpLogSupport;
+    private resendPubsForDelete;
+    private checkPubsForChanges;
+    private checkSupportPubsForChanges;
+    private sendPubDataOnce;
+    private sendPubData;
+    private sendWS;
+}
+export declare class SupportManager {
+    private _mainServer;
+    _supportMethods: SupportMethodModel;
+    private _mailer;
+    private _aws;
+    private serverConfig;
+    private _sendQueue;
+    private _runningQueue;
+    constructor(mainServer: any, serverConfig: any);
+    getMainServer(): ResolveIOMainServer;
+    supportMethods(supportMethod: SupportMethodModel): void;
+    callSupportMethod(ws: WebSocket, messageId: any, supportMethod: any, ...methodData: any[]): void;
+    private sendWS;
+    sendEmail(sendTo: string, subject: string, text?: string, html?: string, attachments?: any[]): void;
+}
+export declare class QueueMethodManager {
+    private _mainServer;
+    private _sendQueue;
+    private _runningQueue;
+    private _runningMethodResponse;
+    constructor(mainServer: any);
+    addMethodToQueue(id_ws: string, id_user: string, user: string, messageId: string, method: string, data: any[]): void;
+    runMethodQueue(count?: number): Promise<void>;
+    addMethodResponse(update: QueueMethodModel, response: ServerResponseModel): void;
+    runMethodResponse(): Promise<void>;
+}
+export declare class MethodManager {
+    private _mainServer;
+    _methods: MethodModel;
+    private _mailer;
+    private _imap;
+    private _aws;
+    private serverConfig;
+    private _sendQueue;
+    private _runningQueue;
+    constructor(mainServer: any, serverConfig: any);
+    getMainServer(): ResolveIOMainServer;
+    methods(method: MethodModel): void;
+    callMethodCron(method: string, ...methodData: any[]): void;
+    callMethodQueue(update: QueueMethodModel): void;
+    callMethod(ws: WebSocket, messageId: any, method: any, ...methodData: any[]): void;
+    callMethodInternal(method: any, ...methodData: any[]): Promise<any>;
+    private sendWS;
+    sendEmail(sendTo: string, subject: string, text?: string, html?: string, attachments?: any[]): void;
+    getAWS(): aws.S3;
+    readFile(fileName: any): Promise<{}>;
+    readImage(fileName: any): Promise<{}>;
+}
+export interface SelectDataLabelModel {
+    data: string;
+    label: string;
+    selected: boolean;
+    type: string;
+    subData: string;
+    subtype: string;
+    subLabel: string;
+}
+export interface ServerResponseModel {
+    messageId: number;
+    hasError: boolean;
+    data: any;
+}
+export interface CronJobModel extends CollectionDocument {
+    name: string;
+    repeat: boolean;
+    time_to_run: string;
+    method_run: string;
+    method_run_data?: Object;
+    method_complete?: string;
+    method_complete_data?: Object;
+    running: boolean;
+    timezone?: string;
+    next_run?: Date;
+}
+export interface PaginationOptions {
+    limit: number;
+    skip: number;
+    sort: {
+        [key: string]: number;
+    };
+    fields: {
+        [key: string]: number;
+    };
+}
+export declare const PaginationOptionsSchema: any;
+export interface QueueMethodModel extends CollectionDocument {
+    method: string;
+    method_data: any[];
+    id_ws: string;
+    messageId: number;
+    id_user: string;
+    user: string;
+}
+export interface LogModel extends CollectionDocument {
+    date: Date;
+    type: string;
+    title: string;
+    message: string;
+    payload: any;
+    method: string;
+    user: string;
+    messageId: string;
+}
+export interface UserModel extends CollectionDocument {
+    attempts: number;
+    last: Date;
+    services?: any;
+    fullname: string;
+    username?: string;
+    email?: string;
+    roles?: string[];
+    active?: boolean;
+    readonly?: boolean;
+    phonenumber?: string;
+    other?: object;
+}
+export interface MethodResponseModel extends CollectionDocument {
+    id_user: string;
+    message_id: string;
+    method: string;
+    data: string;
+    response: any;
+}
+export interface LoggedInUserModel extends CollectionDocument {
+    date: Date;
+    id_user: string;
+    user: string;
+    id_ws: string;
+    app_version?: number;
+    latency?: number;
+}
+export interface CollectionDocument {
+    _id?: any;
+    __v?: number;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+export interface MethodModel {
+    [key: string]: MethodAllModel;
+}
+export interface MethodAllModel {
+    check?: SimpleSchema;
+    function: (...parameters: any[]) => Promise<any | any[]>;
+    skipValidation?: boolean;
+    skipQueue?: boolean;
+}
+export interface MethodCallModel extends CollectionDocument {
+    id_user: string;
+    message_id: string;
+    method: string;
+    data: string;
+}
+export interface CronJobHistoryModel extends CollectionDocument {
+    name: string;
+    reoccuring: boolean;
+    time_to_run: string;
+    method_name: string;
+    server_restart: boolean;
+    passed: boolean;
+    error: Object;
+    start_time: Date;
+    end_time: Date;
+}
+export interface SupportTicketModel extends CollectionDocument {
+    type: string;
+    priority: string;
+    issue: string;
+    support_ticket_number: number;
+    support_ticket_number_string: string;
+    status: SupportTicketStatus;
+    client: string;
+    id_client: string;
+    messages: SupportTicketMessageModel[];
+    date_created: Date;
+    date_created_string: string;
+    id_user_created: string;
+    user_created: string;
+    billable: boolean;
+    work_logs: SupportTicketWorkLogModel[];
+    date_investigation: Date;
+    date_closed: Date;
+}
+export interface SupportTicketMessageModel {
+    message: string;
+    id_user: string;
+    user: string;
+    date: Date;
+    type: SupportTicketMessageType;
+}
+export interface SupportTicketWorkLogModel {
+    note: string;
+    id_user: string;
+    user: string;
+    date_start: Date;
+    date_end?: Date;
+    time_spent?: number;
+    time_spent_string?: string;
+}
+export interface AppVersionModel extends CollectionDocument {
+    version: number;
+}
+export interface DialogInputFieldModel {
+    label: string;
+    form: string;
+    data: string | number | boolean;
+    validators: any[];
+    validatorErrors: string[];
+    validatorMsg: string[];
+    placeholder?: string;
+    required?: boolean;
+    disabled?: boolean;
+    type?: DialogInputFieldTypes;
+    options?: DialogInputFieldSelectOptions[];
+}
+export interface DialogInputFieldSelectOptions {
+    value: string | number;
+    text: string;
+}
+export interface DialogSelectWithButtonsOptionModel {
+    value: string | number;
+    text: string;
+}
+export interface AppStatusModel extends CollectionDocument {
+    message: string;
+}
+export interface QueueResponseModel extends CollectionDocument {
+    method: string;
+    method_data: any[];
+    id_ws: string;
+    messageId: number;
+    id_user: string;
+    user: string;
+    response: any;
+}
+export interface ModulePermissionModel {
+    name: string;
+    views: ModulePermissionViewModel[];
+    approval?: ModulePermissionApprovalModel;
+}
+export interface ModulePermissionViewModel {
+    link: string;
+    label: string;
+}
+export interface ModulePermissionApprovalModel {
+    type: string;
+}
+export interface FileModel extends CollectionDocument {
+    name: string;
+    size: number;
+    key: string;
+    type: string;
+    order: number;
+    status?: string;
+}
+export interface SubscriptionModel {
+    [key: string]: SubscriptionPubModel;
+}
+export interface SubscriptionPubModel {
+    check?: SimpleSchema;
+    preFunction?: (...parameters: any[]) => Promise<Object>;
+    function: (...parameters: any[]) => Promise<any | any[]>;
+    collections: string[];
+    fetchFunction?: (document: Object, ...parameters: any[]) => boolean;
+    ws_specific?: boolean;
+}
+export interface ActiveSubscriptionModel {
+    publication: string;
+    preSubscriptionData?: Object;
+    subscriptionData: any[];
+    collections: string[];
+    clients: ActiveSubscriptionClientModel[];
+}
+export interface ActiveSubscriptionClientModel {
+    id_user: string;
+    messageId: number;
+    id_socket: string;
+}
+export interface ActiveClientSubscriptionModel {
+    messageId: number;
+    subscription: string;
+    parameters: any[];
+    subject: any;
+}
+export interface SupportMethodModel {
+    [key: string]: SupportMethodAllModel;
+}
+export interface SupportMethodAllModel {
+    check?: SimpleSchema;
+    function: (...parameters: any[]) => Promise<any | any[]>;
+    skipValidation?: boolean;
+}
+export interface ActiveSubscriptionModel extends CollectionDocument {
+    date: Date;
+    publication: string;
+    subData: string | Object;
+    collections: string[];
+    clients: ActiveSubscriptionClientModel[];
+}
+export interface ActiveSubscriptionClientModel {
+    id_user: string;
+    messageId: number;
+    id_socket: string;
+}
+export interface CounterModel extends CollectionDocument {
+    count: number;
+    type: string;
+}
+export interface FlagModel extends CollectionDocument {
+    type: string;
+    value?: boolean;
+}
+export declare function setupHealthRoutes(app: any, serverConfig: any): void;
+export declare function setupAuthRoutes(mainServer: ResolveIOMainServer, app: any, serverConfig: any): void;
+export default class ResolveIOMainServer {
+    private _app;
+    private _server;
+    private _port;
+    private _wss;
+    private _serverConfig;
+    private _resolveioServer;
+    private _subscriptionManager;
+    private _methodManager;
+    private _queueManager;
+    private _cronManager;
+    private _supportManager;
+    constructor(mainServer: any, serverConfig: any);
+    getWS(id_ws: string): any;
+    getWSList(): any[];
+    getCronManager(): CronManager;
+    getMethodManager(): MethodManager;
+    getSubscriptionManager(): SubscriptionManager;
+    getQueueManager(): QueueMethodManager;
+    getSupportManager(): SupportManager;
+    private createServer;
+    private setUpMongoose;
+    private setUpPassport;
+    private listen;
+    unsubscribeWS(ws: WebSocket): void;
+}
+export declare function loadServerCronJobs(): Promise<void>;
+export declare function loadServerInit(): Promise<void>;
+export declare function loadSupportCollectionMethods(supportManager: SupportManager): void;
+export declare function loadAWSMethods(supportManager: SupportManager): void;
+export declare function loadSupportMethods(supportManager: SupportManager): void;
+export declare function loadCounterMethods(supportManager: SupportManager): void;
+export declare const Logs: Model<ResolveIOModel>;
+export declare const LogVersions: Model<ResolveIOModel>;
+export declare const LoggedInUsers: Model<ResolveIOModel>;
+export declare const LoggedInUserVersions: Model<ResolveIOModel>;
+export declare const QueueFlags: Model<ResolveIOModel>;
+export declare const QueueFlagVersions: Model<ResolveIOModel>;
+export declare const Users: PassportLocalModel<ResolveIOModel>;
+export declare const UserVersions: Model<ResolveIOModel>;
+export declare const ActiveSubscriptions: Model<ResolveIOModel>;
+export declare const ActiveSubscriptionVersions: Model<ResolveIOModel>;
+export declare const AppStatus: Model<ResolveIOModel>;
+export declare const AppStatusVersions: Model<ResolveIOModel>;
+export declare const MethodResponses: Model<ResolveIOModel>;
+export declare const MethodCalls: Model<ResolveIOModel>;
+export declare const CronJobHistory: Model<ResolveIOModel>;
+export declare const CronJobHistoryVersions: Model<ResolveIOModel>;
+export declare const QueueResponses: Model<ResolveIOModel>;
+export declare const QueueResponseVersions: Model<ResolveIOModel>;
+export declare const AppVersions: Model<ResolveIOModel>;
+export declare const AppVersionVersions: Model<ResolveIOModel>;
+export declare const Flags: Model<ResolveIOModel>;
+export declare const FlagVersions: Model<ResolveIOModel>;
+export declare const CronJobs: Model<ResolveIOModel>;
+export declare const CronJobVersions: Model<ResolveIOModel>;
+export declare let SupportTickets: Model<ResolveIOModel>;
+export declare let SupportTicketVersions: Model<ResolveIOModel>;
+export declare const QueueMethods: Model<ResolveIOModel>;
+export declare const QueueMethodVersions: Model<ResolveIOModel>;
+export declare const Counters: Model<ResolveIOModel>;
+export declare let SupportCounters: Model<ResolveIOModel>;
+export declare const CounterVersions: Model<ResolveIOModel>;
+export declare let SupportCounterVersions: Model<ResolveIOModel>;
+export declare const Files: Model<ResolveIOModel>;
+export declare let SupportFiles: Model<ResolveIOModel>;
+export declare const FileVersions: Model<ResolveIOModel>;
+export declare let SupportFileVersions: Model<ResolveIOModel>;

package/index.js

@@ -45,11 +45,39 @@ var ResolveIOServer = /** @class */ (function () {
         return __awaiter(this, void 0, void 0, function () {
             var _this = this;
             return __generator(this, function (_a) {
-                if (ResolveIOServer._serverConfig['ROOT_URL'] !== 'http://localhost:4200') {
-                    mongoose.createConnection(ResolveIOServer._serverConfig['RESOLVEIO_SUPPORT_MONGO_URL'], { useNewUrlParser: true }).then(function (db) { return __awaiter(_this, void 0, void 0, function () {
-                        var _this = this;
-                        return __generator(this, function (_a) {
-                            ResolveIOServer._supportDB = db;
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        if (ResolveIOServer._serverConfig['ROOT_URL'] !== 'http://localhost:4200') {
+                            mongoose.createConnection(ResolveIOServer._serverConfig['RESOLVEIO_SUPPORT_MONGO_URL'], { useNewUrlParser: true }).then(function (db) { return __awaiter(_this, void 0, void 0, function () {
+                                var _this = this;
+                                return __generator(this, function (_a) {
+                                    ResolveIOServer._supportDB = db;
+                                    mongoose.createConnection(ResolveIOServer._serverConfig['MONGO_URL'], { useNewUrlParser: true }).then(function (dbMain) { return __awaiter(_this, void 0, void 0, function () {
+                                        var serverApp;
+                                        return __generator(this, function (_a) {
+                                            switch (_a.label) {
+                                                case 0:
+                                                    ResolveIOServer._mainDB = dbMain;
+                                                    return [4 /*yield*/, Promise.resolve().then(function () { return require('./server-app'); })];
+                                                case 1:
+                                                    serverApp = (_a.sent()).default;
+                                                    ResolveIOServer._mainServer = new serverApp(this, ResolveIOServer._serverConfig);
+                                                    resolve();
+                                                    return [2 /*return*/];
+                                            }
+                                        });
+                                    }); }, function (err) {
+                                        process.exit();
+                                        reject();
+                                    });
+                                    return [2 /*return*/];
+                                });
+                            }); }, function (err) {
+                                process.exit();
+                                reject();
+                            });
+                        }
+                        else {
+                            ResolveIOServer._supportDB = null;
                             mongoose.createConnection(ResolveIOServer._serverConfig['MONGO_URL'], { useNewUrlParser: true }).then(function (dbMain) { return __awaiter(_this, void 0, void 0, function () {
                                 var serverApp;
                                 return __generator(this, function (_a) {
@@ -60,38 +88,16 @@ var ResolveIOServer = /** @class */ (function () {
                                         case 1:
                                             serverApp = (_a.sent()).default;
                                             ResolveIOServer._mainServer = new serverApp(this, ResolveIOServer._serverConfig);
+                                            resolve();
                                             return [2 /*return*/];
                                     }
                                 });
                             }); }, function (err) {
                                 process.exit();
+                                reject();
                             });
-                            return [2 /*return*/];
-                        });
-                    }); }, function (err) {
-                        process.exit();
-                    });
-                }
-                else {
-                    ResolveIOServer._supportDB = null;
-                    mongoose.createConnection(ResolveIOServer._serverConfig['MONGO_URL'], { useNewUrlParser: true }).then(function (dbMain) { return __awaiter(_this, void 0, void 0, function () {
-                        var serverApp;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    ResolveIOServer._mainDB = dbMain;
-                                    return [4 /*yield*/, Promise.resolve().then(function () { return require('./server-app'); })];
-                                case 1:
-                                    serverApp = (_a.sent()).default;
-                                    ResolveIOServer._mainServer = new serverApp(this, ResolveIOServer._serverConfig);
-                                    return [2 /*return*/];
-                            }
-                        });
-                    }); }, function (err) {
-                        process.exit();
-                    });
-                }
-                return [2 /*return*/];
+                        }
+                    })];
             });
         });
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@resolveio/server-lib",
-  "version": "1.0.0-rc14",
+  "version": "1.0.0-rc15",
   "description": "",
   "main": "index.ts",
   "scripts": {