@resolveio/server-lib 3.2.10-newrole → 3.2.11-newrole

package/collections/queue-response.collection.js

@@ -1,74 +0,0 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-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
-    },
-    method: {
-        type: String
-    },
-    id_ws: {
-        type: String
-    },
-    messageId: {
-        type: Number
-    },
-    id_user: {
-        type: String
-    },
-    user: {
-        type: String
-    },
-    response: {
-        type: Object,
-        blackbox: true
-    },
-    date: {
-        type: Date
-    }
-};
-var DefaultSchema = new mongoose_1.Schema(schema, {
-    skipVersioning: true,
-    versionKey: false,
-    timestamps: true
-});
-exports.QueueResponses = index_1.ResolveIOServer.getMainDB().model('queue-responses', DefaultSchema);
-var vSchema = __assign({}, schema);
-vSchema._id = {
-    type: mongoose_1.Schema.Types.Mixed
-};
-var VersionSchema = new mongoose_1.Schema(vSchema, {
-    skipVersioning: true,
-    versionKey: false,
-    timestamps: true
-});
-exports.QueueResponses['versionCollection'] = 'queue-responses.versions';
-exports.QueueResponseVersions = index_1.ResolveIOServer.getMainDB().model(exports.QueueResponses['versionCollection'], VersionSchema);
-exports.QueueResponses['simplschema'] = new simpl_schema_1.default(schema);

package/collections/support-ticket.collection.d.ts

@@ -1,7 +0,0 @@
-import { Model, Document } from 'mongoose';
-import { SupportTicketModel } from '../models/support-ticket.model';
-interface ResolveIOModel extends SupportTicketModel, Document {
-}
-export declare let SupportTickets: Model<ResolveIOModel>;
-export declare let SupportTicketVersions: Model<ResolveIOModel>;
-export {};

package/collections/support-ticket.collection.js

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

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

@@ -1,164 +0,0 @@
-"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
-    },
-    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: Object
-    },
-    'roles.super_admin': {
-        type: Boolean
-    },
-    'roles.approvals': {
-        type: Array
-    },
-    'roles.approvals.$': {
-        type: Object
-    },
-    'roles.approvals.$.name': {
-        type: String
-    },
-    'roles.approvals.$.type': {
-        type: String
-    },
-    'roles.approvals.$.accounting_code': {
-        type: String
-    },
-    'roles.groups': {
-        type: Array
-    },
-    'roles.groups.$': {
-        type: Object
-    },
-    'roles.groups.$.name': {
-        type: String
-    },
-    'roles.groups.$.views': {
-        type: Array
-    },
-    'roles.groups.$.views.$': {
-        type: String
-    },
-    'roles.groups.$.yard': {
-        type: String,
-        optional: true
-    },
-    'roles.notifications': {
-        type: Array
-    },
-    'roles.notifications.$': {
-        type: String
-    },
-    'roles.miscs': {
-        type: Array
-    },
-    'roles.miscs.$': {
-        type: String
-    },
-    active: Boolean,
-    id_customer: {
-        type: String,
-        optional: true
-    },
-    customer: {
-        type: String,
-        optional: true
-    },
-    customer_type: {
-        type: String,
-        optional: true
-    },
-    phonenumber: {
-        type: String,
-        optional: true
-    },
-    other: {
-        type: Object,
-        optional: true,
-        blackbox: 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

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

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

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