@resolveio/server-lib 3.2.11 → 3.2.12

package/collections/support-ticket.collection.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var mongoose_1 = require("mongoose");
+var simpl_schema_1 = require("simpl-schema");
+var index_1 = require("../index");
+var schema = {
+    _id: {
+        type: String,
+        optional: true
+    },
+    __v: {
+        type: Number,
+        optional: true
+    },
+    updatedAt: {
+        type: Date,
+        optional: true
+    },
+    createdAt: {
+        type: Date,
+        optional: true
+    },
+    type: {
+        type: String
+    },
+    priority: {
+        type: String
+    },
+    issue: {
+        type: String
+    },
+    support_ticket_number: {
+        type: Number
+    },
+    support_ticket_number_string: {
+        type: String
+    },
+    status: {
+        type: String
+    },
+    substatus: {
+        type: String
+    },
+    client: {
+        type: String
+    },
+    id_client: {
+        type: String
+    },
+    messages: {
+        type: Array
+    },
+    'messages.$': {
+        type: Object
+    },
+    'messages.$.message': {
+        type: String
+    },
+    'messages.$.id_user': {
+        type: String
+    },
+    'messages.$.user': {
+        type: String
+    },
+    'messages.$.date': {
+        type: Date
+    },
+    'messages.$.type': {
+        type: String
+    },
+    date_created: {
+        type: Date
+    },
+    date_created_string: {
+        type: String
+    },
+    id_user_created: {
+        type: String
+    },
+    user_created: {
+        type: String
+    },
+    billable: {
+        type: Boolean
+    },
+    date_investigation: {
+        type: Date,
+        optional: true,
+    },
+    date_closed: {
+        type: Date,
+        optional: true,
+    },
+    files: {
+        type: Array
+    },
+    'files.$': {
+        type: String
+    },
+    current_watchers: {
+        type: Array
+    },
+    'current_watchers.$': {
+        type: Object
+    },
+    'current_watchers.$.user': {
+        type: String
+    },
+    'current_watchers.$.id_user': {
+        type: String
+    },
+    'current_watchers.$.email': {
+        type: String
+    },
+    client_user: {
+        type: Object
+    },
+    'client_user.id_user': {
+        type: String
+    },
+    'client_user.user': {
+        type: String
+    },
+    'client_user.email': {
+        type: String
+    },
+    id_user_assigned: {
+        type: String
+    },
+    user_assigned: {
+        type: String
+    },
+    resolveio_status: {
+        type: String
+    },
+    estimated_billable_hours: {
+        type: Number,
+        optional: true
+    },
+    billable_hours: {
+        type: Number,
+        optional: true
+    },
+    bill_description: {
+        type: String
+    },
+    tasks: {
+        type: Array,
+        optional: true
+    },
+    'tasks.$': {
+        type: Object
+    },
+    'tasks.$.description': {
+        type: String
+    },
+    'tasks.$.completed': {
+        type: Boolean
+    },
+    'tasks.$.id_user': {
+        type: String,
+        optional: true
+    },
+    'tasks.$.user': {
+        type: String,
+        optional: true
+    },
+    'tasks.$.date_created': {
+        type: Date
+    },
+    'tasks.$.date_completed': {
+        type: Date,
+        optional: true
+    },
+};
+var DefaultSchema = new mongoose_1.Schema(schema, {
+    skipVersioning: true,
+    versionKey: false,
+    timestamps: true
+});
+exports.SupportTickets = null;
+if (index_1.ResolveIOServer.getSupportDB()) {
+    exports.SupportTickets = index_1.ResolveIOServer.getSupportDB().model('support-tickets', DefaultSchema);
+    exports.SupportTickets['simplschema'] = new simpl_schema_1.default(schema);
+}
+schema._id = {
+    type: mongoose_1.Schema.Types.Mixed
+};
+var VersionSchema = new mongoose_1.Schema(schema, {
+    skipVersioning: true,
+    versionKey: false,
+    timestamps: true
+});
+if (index_1.ResolveIOServer.getSupportDB()) {
+    exports.SupportTickets['versionCollection'] = 'support-tickets.versions';
+}
+exports.SupportTicketVersions = null;
+if (index_1.ResolveIOServer.getSupportDB()) {
+    exports.SupportTicketVersions = index_1.ResolveIOServer.getSupportDB().model(exports.SupportTickets['versionCollection'], VersionSchema);
+}

package/collections/user.collection.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="passport-local-mongoose" />
+import { Model, PassportLocalDocument, PassportLocalModel } from 'mongoose';
+import { UserModel } from '../models/user.model';
+interface ResolveIOModel extends UserModel, PassportLocalDocument {
+}
+export declare const Users: PassportLocalModel<ResolveIOModel>;
+export declare let ClientUsers: PassportLocalModel<ResolveIOModel>;
+export declare const UserVersions: Model<ResolveIOModel>;
+export {};

package/collections/user.collection.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var mongoose_1 = require("mongoose");
+var passportLocalMongoose = require("passport-local-mongoose");
+var simpl_schema_1 = require("simpl-schema");
+var index_1 = require("../index");
+var schema = {
+    _id: {
+        type: String,
+        optional: true
+    },
+    __v: {
+        type: Number,
+        optional: true
+    },
+    updatedAt: {
+        type: Date,
+        optional: true
+    },
+    createdAt: {
+        type: Date,
+        optional: true
+    },
+    readonly: {
+        type: Boolean,
+        optional: true
+    },
+    active: {
+        type: Boolean
+    },
+    attempts: {
+        type: Number,
+        optional: true
+    },
+    last: {
+        type: Date,
+        optional: true
+    },
+    services: {
+        type: Object,
+        optional: true
+    },
+    'services.enrollment': {
+        type: String,
+        optional: true
+    },
+    'services.forgot_password': {
+        type: String,
+        optional: true
+    },
+    'services.reset_password': {
+        type: String,
+        optional: true
+    },
+    username: {
+        type: String,
+        optional: true
+    },
+    email: {
+        type: String,
+        optional: true
+    },
+    fullname: {
+        type: String
+    },
+    roles: {
+        type: Array
+    },
+    'roles.$': {
+        type: String
+    },
+    phonenumber: {
+        type: String,
+        optional: true
+    },
+    other: {
+        type: Object,
+        blackbox: true,
+        optional: true
+    },
+    assets: {
+        type: Array,
+        optional: true
+    },
+    'assets.$': {
+        type: Object
+    },
+    'assets.$.type': {
+        type: String
+    },
+    'assets.$.id_asset': {
+        type: String
+    },
+    'assets.$.asset_number': {
+        type: String
+    },
+    'assets.$.ownership': {
+        type: String
+    },
+    'assets.$.ownership_driver': {
+        type: String
+    },
+    'assets.$.date_start': {
+        type: Date
+    },
+    'assets.$.date_end': {
+        type: Date,
+        optional: true
+    },
+    id_function: {
+        type: String,
+        optional: true
+    },
+    customer: {
+        type: String,
+        optional: true,
+    },
+    id_customer: {
+        type: String,
+        optional: true,
+    }
+};
+var DefaultSchema = new mongoose_1.Schema(schema, {
+    skipVersioning: true,
+    versionKey: false,
+    timestamps: true
+});
+DefaultSchema.plugin(passportLocalMongoose, {
+    usernameUnique: true,
+    limitAttempts: true,
+    maxAttempts: 5,
+    findByUsername: function (mongooseModel, queryParameters) {
+        // Add additional query parameter - AND condition - active: true
+        queryParameters.active = true;
+        return mongooseModel.findOne(queryParameters);
+    }
+});
+exports.Users = index_1.ResolveIOServer.getMainDB().model('users', DefaultSchema);
+exports.ClientUsers = null;
+if (index_1.ResolveIOServer.getSupportDB()) {
+    exports.ClientUsers = index_1.ResolveIOServer.getSupportDB().model('client-users', DefaultSchema);
+}
+exports.Users['simplschema'] = new simpl_schema_1.default(schema);
+schema._id = {
+    type: mongoose_1.Schema.Types.Mixed
+};
+var VersionSchema = new mongoose_1.Schema(schema, {
+    skipVersioning: true,
+    versionKey: false,
+    timestamps: true
+});
+exports.Users['versionCollection'] = 'users.versions';
+exports.UserVersions = index_1.ResolveIOServer.getMainDB().model(exports.Users['versionCollection'], VersionSchema);

package/cron/cron.d.ts

@@ -0,0 +1,5 @@
+declare let CronJob: any;
+declare function CrontabManager(key: any, tab: any, task: any, options: any): void;
+declare function combineOptions(tab: any, task: any, options: any): {};
+declare function updateTab(key: any, cronstring: any): void;
+declare function updateTask(key: any, task: any): void;

package/cron/cron.js

@@ -0,0 +1,160 @@
+var CronJob = require('cron').CronJob;
+function CrontabManager(key, tab, task, options) {
+    this.jobs = {};
+    if (key && tab && task) {
+        this.add(key, tab, task, options);
+    }
+}
+CrontabManager.prototype.getJob = function (key) {
+    return this.jobs[key];
+};
+CrontabManager.prototype.getJobs = function () {
+    return Object.keys(this.jobs);
+};
+CrontabManager.prototype.add = function (key, tab, task, options) {
+    if ((typeof tab === 'string' || tab instanceof Date) && typeof key === 'string' && task instanceof Function) {
+        options = combineOptions(tab, task, options);
+        try {
+            if (this.jobs[key]) {
+                this.deleteJob(key);
+                console.warn(key + " already existed and was deleted from the manager...");
+            }
+            this.jobs[key] = new CronJob(options);
+        }
+        catch (fooBaredByUser) {
+            console.error("crontab: " + tab + " possibly not valid, job " + key + " not started..." + fooBaredByUser.message);
+        }
+    }
+    else {
+        console.warn("couldn't add: " + key + " improper arguments");
+    }
+};
+CrontabManager.prototype.update = function () {
+    if (arguments.length === 2) {
+        if (typeof arguments[1] === 'string' || arguments[1] instanceof Date) {
+            updateTab.call(this, arguments[0], arguments[1]);
+        }
+        else if (arguments[1] instanceof Function) {
+            updateTask.call(this, arguments[0], arguments[1]);
+        }
+    }
+    else if (arguments.length === 3) {
+        updateTab.call(this, arguments[0], arguments[1]);
+        updateTask.call(this, arguments[0], arguments[2]);
+    }
+    else {
+        console.error("incorrect number of arguents passed to update.. won't update.. " + arguments[0]);
+    }
+};
+CrontabManager.prototype.deleteJob = function (key) {
+    try {
+        this.jobs[key].stop();
+        delete this.jobs[key];
+    }
+    catch (err) {
+        console.error("error in trying to stop job: " + key + ": " + err);
+    }
+};
+CrontabManager.prototype.start = function (key) {
+    try {
+        if (this.jobs[key].running) {
+            console.warn(key + " job already running");
+        }
+        else {
+            this.jobs[key].start();
+        }
+    }
+    catch (err) {
+        console.error("couldn't start job: " + key + ": " + err);
+    }
+};
+CrontabManager.prototype.stop = function (key) {
+    try {
+        if (!this.jobs[key].running) {
+            console.warn(key + " job already stopped");
+        }
+        else {
+            this.jobs[key].stop();
+        }
+    }
+    catch (err) {
+        console.error("couldn't stop job: " + key + ": " + err);
+    }
+};
+CrontabManager.prototype.stopAll = function () {
+    // tslint:disable-next-line:forin
+    for (var jobKey in this.jobs) {
+        try {
+            this.jobs[jobKey].stop();
+        }
+        catch (err) {
+        }
+    }
+};
+CrontabManager.prototype.toString = function () {
+    var manString = '{\n';
+    // tslint:disable-next-line:forin
+    for (var jobKey in this.jobs) {
+        manString += "'" + jobKey + "': " + this.jobs[jobKey].cronTime.source + ": " + this.jobs[jobKey]._callbacks[0] + ": " + (this.jobs[jobKey].running ? 'Running' : 'Stopped');
+    }
+    manString += '\n}';
+    return manString;
+};
+CrontabManager.prototype.listCrons = function () {
+    var manString = '{\n';
+    // tslint:disable-next-line:forin
+    for (var jobKey in this.jobs) {
+        manString += "'" + jobKey + "': " + this.jobs[jobKey].cronTime.source + " status: " + (this.jobs[jobKey].running ? 'Running' : 'Stopped') + " \n";
+    }
+    manString += '\n}';
+    return manString;
+};
+CrontabManager.prototype.exists = function (tabKey) {
+    if (this.jobs[tabKey]) {
+        return true;
+    }
+    return false;
+};
+function combineOptions(tab, task, options) {
+    var newOpts = {};
+    newOpts['cronTime'] = tab;
+    newOpts['onTick'] = task;
+    if (options instanceof Object) {
+        // might overwrite... please be careful.
+        // tslint:disable-next-line:forin
+        for (var optionKey in options) {
+            newOpts[optionKey] = options[optionKey];
+        }
+    }
+    return newOpts;
+}
+function updateTab(key, cronstring) {
+    try {
+        var running = this.jobs[key].running;
+        this.jobs[key].stop();
+        if (typeof cronstring === 'string' || cronstring instanceof Date) {
+            this.jobs[key] = new CronJob(cronstring, this.jobs[key]._callbacks[0], this.jobs[key].onComplete, running, this.jobs[key].zone);
+        }
+        else {
+            throw new Error("The cron definition passed was not a string or a Date object! " + key + " was stopped and not updated");
+        }
+    }
+    catch (tabErr) {
+        console.error("error updating tab: " + key + " - " + tabErr.message);
+    }
+}
+function updateTask(key, task) {
+    try {
+        var running = this.jobs[key].running;
+        this.jobs[key].stop();
+        if (!(task instanceof Function)) {
+            console.error("can't update with something that is not a function: " + typeof (task));
+            return;
+        }
+        this.jobs[key] = new CronJob(this.jobs[key].cronTime.source, task, this.jobs[key].onComplete, running, this.jobs[key].zone);
+    }
+    catch (tabErr) {
+        console.error("error updating task: " + key + "  - " + tabErr.message);
+    }
+}
+module.exports = CrontabManager;

package/fixtures/cron-jobs.d.ts

@@ -0,0 +1 @@
+export declare function loadServerCronJobs(): Promise<void>;

package/fixtures/cron-jobs.js

@@ -0,0 +1,90 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var cron_job_collection_1 = require("../collections/cron-job.collection");
+var mongoose_1 = require("mongoose");
+function loadServerCronJobs() {
+    return __awaiter(this, void 0, void 0, function () {
+        var cronJobs;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, cron_job_collection_1.CronJobs.find({}).exec()];
+                case 1:
+                    cronJobs = _a.sent();
+                    if (!!cronJobs.filter(function (a) { return a.name === 'Method Queue'; }).length) return [3 /*break*/, 3];
+                    return [4 /*yield*/, cron_job_collection_1.CronJobs.create({
+                            _id: mongoose_1.Types.ObjectId().toHexString(),
+                            __v: 0,
+                            name: 'Method Queue',
+                            "repeat": true,
+                            reoccuring: true,
+                            "time_to_run": "*/5 * * * * *",
+                            "method_run": "methodQueue",
+                            "method_run_data": null,
+                            "next_run": new Date(),
+                            "running": false
+                        })];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3:
+                    if (!!cronJobs.filter(function (a) { return a.name === 'Update Client Users'; }).length) return [3 /*break*/, 5];
+                    return [4 /*yield*/, cron_job_collection_1.CronJobs.create({
+                            _id: mongoose_1.Types.ObjectId().toHexString(),
+                            __v: 0,
+                            name: 'Update Client Users',
+                            "repeat": true,
+                            reoccuring: true,
+                            "time_to_run": "0 */1 * * *",
+                            "method_run": "updateClientUsers",
+                            "method_run_data": null,
+                            "next_run": new Date(),
+                            "running": false
+                        })];
+                case 4:
+                    _a.sent();
+                    _a.label = 5;
+                case 5:
+                    cronJobs.filter(function (a) { return a.running && a.next_run && a.next_run.getTime() < (new Date()).getTime(); }).forEach(function (cronJob) {
+                        cron_job_collection_1.CronJobs.updateOne({ _id: cronJob._id }, { $set: { running: false } }).exec();
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.loadServerCronJobs = loadServerCronJobs;

package/fixtures/init.d.ts

@@ -0,0 +1 @@
+export declare function loadServerInit(): Promise<void>;

package/fixtures/init.js

@@ -0,0 +1,67 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var app_version_collection_1 = require("../collections/app-version.collection");
+var logged_in_users_collection_1 = require("../collections/logged-in-users.collection");
+var active_subscription_collection_1 = require("../collections/active-subscription.collection");
+var mongoose_1 = require("mongoose");
+function loadServerInit() {
+    return __awaiter(this, void 0, void 0, function () {
+        var appVersion;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, app_version_collection_1.AppVersions.findOne()];
+                case 1:
+                    appVersion = _a.sent();
+                    if (!appVersion) {
+                        app_version_collection_1.AppVersions.create({
+                            _id: mongoose_1.Types.ObjectId().toHexString(),
+                            version: 1
+                        });
+                    }
+                    return [4 /*yield*/, logged_in_users_collection_1.LoggedInUsers.deleteMany({}).exec()];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, active_subscription_collection_1.ActiveSubscriptions.deleteMany({}).exec()];
+                case 3:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.loadServerInit = loadServerInit;

package/http/auth.d.ts

@@ -0,0 +1,2 @@
+import ResolveIOMainServer from '../server-app';
+export declare function setupAuthRoutes(mainServer: ResolveIOMainServer, app: any, serverConfig: any): void;