@itleanchatbot/shared-models-js-postgres 2.8.32 → 3.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itleanchatbot/shared-models-js-postgres",
-  "version": "2.8.32",
+  "version": "3.0.0",
   "description": "Shared Models JS Postgres",
   "main": "index.js",
   "license": "ISC",
@@ -8,7 +8,8 @@
   "scripts": {
     "lint": "npx eslint \"/**/*.js\" --fix",
     "format": "npm run format:src",
-    "format:src": "npx prettier --write \"src/**/*.js\""
+    "format:src": "npx prettier --write \"src/**/*.js\"",
+    "unificate": "node ./src/scripts/unification.js"
   },
   "husky": {
     "hooks": {
@@ -38,9 +39,12 @@
   },
   "dependencies": {
     "crypto-js": "^4.0.0",
+    "dotenv": "^16.0.0",
+    "moment": "^2.29.3",
     "pg": "^8.5.1",
     "pg-hstore": "^2.3.3",
     "sequelize": "^6.3.5",
+    "sequelize-cli": "^6.4.1",
     "uuid-apikey": "^1.5.3"
   }
 }

package/src/legacy/migrations/20220823112830-alter-skill.js

@@ -0,0 +1,25 @@
+'use strict';
+
+module.exports = {
+  async up (queryInterface, Sequelize) {
+    
+    await queryInterface.addColumn('Skills', 'status', {
+      defaultValue: 'ready',
+      allowNull: false,
+      type: Sequelize.STRING(10),
+      validate: {
+        notEmpty: true,
+      },
+    })
+
+    await queryInterface.addColumn('Skills', 'error', {
+        allowNull: true,
+        type: Sequelize.TEXT
+    })
+  },
+
+  async down (queryInterface) {
+    await queryInterface.removeColumn('Skills', 'error')
+    await queryInterface.removeColumn('Skills', 'status')
+  }
+};

package/src/legacy/models/apiKeys.js

@@ -0,0 +1,25 @@
+exports.model = (sequelize, DataTypes) => {
+    
+    const ApiKeys = sequelize.define('ApiKeys', {
+      EnterpriseId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        references: {
+          model: 'Enterprises',
+          key: 'id',
+        },
+        onDelete: 'RESTRICT',
+        onUpdate: 'CASCADE',
+      },
+      key: {
+          allowNull: false,
+          type: DataTypes.STRING(255)
+      }
+    })
+  
+    ApiKeys.associate = models => {
+        ApiKeys.belongsTo(models.Enterprises)
+    }
+  
+    return ApiKeys
+}

package/src/legacy/models/apiPreRequest.js

@@ -0,0 +1,56 @@
+
+exports.model = (sequelize, Sequelize) => {
+    const ApiPreRequests = sequelize.define('ApiPreRequests', {
+        ApiId: {
+            allowNull: true,
+            defaultValue: null,
+            type: Sequelize.UUID,
+            references: {
+                model: 'Apis',
+                key: 'id',
+            },
+            onDelete: 'SET NULL',
+            onUpdate: 'CASCADE',
+        },
+        PreApiResourceId: {
+            allowNull: false,
+            type: Sequelize.UUID,
+            references: {
+              model: 'ApiResources',
+              key: 'id',
+            },
+            onDelete: 'SET NULL',
+            onUpdate: 'CASCADE',
+        },
+        ApiResourceId: {
+            allowNull: true,
+            defaultValue: null,
+            type: Sequelize.UUID,
+            references: {
+              model: 'ApiResources',
+              key: 'id',
+            },
+            onDelete: 'SET NULL',
+            onUpdate: 'CASCADE',
+        },
+        result: {
+            allowNull: false,
+            type: Sequelize.STRING,
+        },
+        delayForNewRequest: {
+            allowNull: false,
+            type: Sequelize.STRING,
+        },
+    })
+  
+    ApiPreRequests.associate = (models) => {
+        ApiPreRequests.belongsTo(models.ApiResources)
+        ApiPreRequests.belongsTo(models.ApiResources, {
+            as: 'PreApiResource',
+            foreignKey: 'PreApiResourceId'
+          })
+        ApiPreRequests.belongsTo(models.Apis)
+    }
+  
+    return ApiPreRequests
+}

package/src/legacy/models/apiResourceBodies.js

@@ -0,0 +1,44 @@
+const APIS_RESOURCES_BODY_TYPES = {
+    JSON: 'json',
+    HTML: 'html',
+    TEXT: 'text',
+    XML: 'xml',
+    URL_ENCODE: 'url-encode'
+  }
+  
+  const APIS_RESOURCES_BODY_TYPE = [
+    APIS_RESOURCES_BODY_TYPES.JSON,
+    APIS_RESOURCES_BODY_TYPES.HTML,
+    APIS_RESOURCES_BODY_TYPES.TEXT,
+    APIS_RESOURCES_BODY_TYPES.XML,
+    APIS_RESOURCES_BODY_TYPES.URL_ENCODE
+  ]
+  
+  const ApiResourcesBodiesModel = (sequelize, Sequelize) => {
+    const ApiResourcesBodies = sequelize.define('ApiResourcesBodies', {
+      content: {
+        type: Sequelize.TEXT,
+        allowNull: false,
+      },
+      type: {
+        type: Sequelize.ENUM({
+          values: APIS_RESOURCES_BODY_TYPE,
+        }),
+        allowNull: false,
+        defaultValue: APIS_RESOURCES_BODY_TYPES.JSON,
+      },
+    })
+  
+    ApiResourcesBodies.associate = (models) => {
+      ApiResourcesBodies.hasOne(models.ApiResources)
+    }
+  
+    return ApiResourcesBodies
+  }
+
+module.exports = {
+    model: ApiResourcesBodiesModel,
+    APIS_RESOURCES_BODY_TYPE,
+    APIS_RESOURCES_BODY_TYPES
+}
+  

package/src/legacy/models/apiResourceHeaders.js

@@ -0,0 +1,30 @@
+exports.model = (sequelize, Sequelize) => {
+    const ApiResourcesHeaders = sequelize.define('ApiResourcesHeaders', {
+      ApiResourceId: {
+        type: Sequelize.UUID,
+        allowNull: false,
+        references: {
+          model: 'ApiResources',
+          key: 'id',
+        },
+        onDelete: 'RESTRICT',
+        onUpdate: 'CASCADE',
+      },
+      value: {
+        type: Sequelize.STRING,
+        allowNull: false,
+      },
+      type: {
+        type: Sequelize.STRING(40),
+        allowNull: false,
+        defaultValue: 'string',
+      },
+    })
+  
+    ApiResourcesHeaders.associate = (models) => {
+      ApiResourcesHeaders.belongsTo(models.ApiResources)
+    }
+  
+    return ApiResourcesHeaders
+  }
+  

package/src/legacy/models/apiResourcePathParams.js

@@ -0,0 +1,29 @@
+exports.model = (sequelize, Sequelize) => {
+    const ApiResourcesPathParams = sequelize.define('ApiResourcesPathParams', {
+      ApiResourceId: {
+        type: Sequelize.UUID,
+        allowNull: false,
+        references: {
+          model: 'ApiResources',
+          key: 'id',
+        },
+        onDelete: 'RESTRICT',
+        onUpdate: 'CASCADE',
+      },
+      key: {
+        type: Sequelize.STRING,
+        allowNull: false,
+      },
+      value: {
+        type: Sequelize.STRING,
+        allowNull: false,
+      },
+    })
+  
+    ApiResourcesPathParams.associate = (models) => {
+      ApiResourcesPathParams.belongsTo(models.ApiResources)
+    }
+  
+    return ApiResourcesPathParams
+  }
+  

package/src/legacy/models/apiResourceQueryStringParams.js

@@ -0,0 +1,37 @@
+exports.model = (sequelize, Sequelize) => {
+    const ApiResourcesQueryStringParams = sequelize.define(
+      'ApiResourcesQueryStringParams',
+      {
+        ApiResourceId: {
+          type: Sequelize.UUID,
+          allowNull: false,
+          references: {
+            model: 'ApiResources',
+            key: 'id',
+          },
+          onDelete: 'RESTRICT',
+          onUpdate: 'CASCADE',
+        },
+        key: {
+          type: Sequelize.STRING,
+          allowNull: false,
+        },
+        value: {
+          type: Sequelize.STRING,
+          allowNull: false,
+        },
+        type: {
+          type: Sequelize.STRING(40),
+          allowNull: false,
+          defaultValue: 'string',
+        },
+      }
+    )
+  
+    ApiResourcesQueryStringParams.associate = (models) => {
+      ApiResourcesQueryStringParams.belongsTo(models.ApiResources)
+    }
+  
+    return ApiResourcesQueryStringParams
+  }
+  

package/src/legacy/models/apiResources.js

@@ -0,0 +1,78 @@
+const HTTP_METHODS = [
+    'PUT',
+    'GET',
+    'DELETE',
+    'POST',
+    'COPY',
+    'OPTIONS',
+    'PATCH',
+    'PURGE',
+    'LINK',
+    'UNLINK',
+    'LOCK',
+    'UNLOCK',
+]
+
+const ApiResourcesModel = (sequelize, Sequelize) => {
+  const ApiResources = sequelize.define('ApiResources', {
+    ApiId: {
+      type: Sequelize.UUID,
+      allowNull: false,
+      references: {
+        model: 'Apis',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    ApiResourcesBodyId: {
+      type: Sequelize.UUID,
+      allowNull: true,
+      references: {
+        model: 'ApiResourcesBodies',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    uri: {
+      type: Sequelize.STRING,
+      allowNull: false,
+    },
+    method: {
+      type: Sequelize.ENUM({
+        values: HTTP_METHODS,
+      }),
+      allowNull: true,
+    },
+    name: {
+      type: Sequelize.STRING,
+      allowNull: true,
+    },
+    description: {
+      type: Sequelize.STRING,
+      allowNull: true,
+    },
+  })
+
+  ApiResources.associate = (models) => {
+    ApiResources.belongsTo(models.Apis)
+    ApiResources.belongsTo(models.ApiResourcesBodies)
+    ApiResources.hasMany(models.ApiPreRequests, {
+      as: 'PreApiResource',
+      foreignKey: 'PreApiResourceId'
+    })
+    ApiResources.hasMany(models.ApiPreRequests)
+    ApiResources.hasMany(models.ApiResourcesHeaders)
+    ApiResources.hasMany(models.ApiResourcesQueryStringParams)
+    ApiResources.hasMany(models.ApiResourcesPathParams)
+  }
+
+  return ApiResources
+}
+
+
+module.exports = {
+    model: ApiResourcesModel,
+    HTTP_METHODS
+}

package/src/legacy/models/apis.js

@@ -0,0 +1,67 @@
+const API_INTEGRATION_TYPES = {
+    JSON: 'json',
+    XML: 'xml',
+  }
+  
+const API_INTEGRATION_TYPE = [
+  API_INTEGRATION_TYPES.JSON,
+  API_INTEGRATION_TYPES.XML,
+]
+ 
+
+const API_AUTHENTICATIONS_TYPES = {
+  BASIC_AUTH: 'basicAuth',
+  BEARER_TOKEN: 'bearerToken',
+  API_KEY: 'apiKey',
+  NO_AUTH: 'noAuth'
+}
+
+
+  const ApisModel = (sequelize, Sequelize) => {
+    const Api = sequelize.define('Apis', {
+      baseUrl: {
+        type: Sequelize.JSON,
+        allowNull: false,
+      },
+      type: {
+        type: Sequelize.ENUM({
+          values: API_INTEGRATION_TYPE,
+        }),
+        defaultValue: API_INTEGRATION_TYPES.JSON,
+        allowNull: false,
+      },
+      name: {
+        type: Sequelize.STRING,
+        allowNull: true,
+      },
+      description: {
+        type: Sequelize.STRING,
+        allowNull: true,
+      },
+      EnterpriseId: {
+        type: Sequelize.UUID,
+        allowNull: true,
+        references: {
+          model: 'Enterprises',
+          key: 'id',
+        },
+        onDelete: 'RESTRICT',
+        onUpdate: 'CASCADE',
+      },
+    })
+  
+    Api.associate = (models) => {
+      Api.hasMany(models.ApiResources)
+      Api.hasMany(models.ApiPreRequests)
+    }
+  
+    return Api
+  }
+  
+
+  module.exports = {
+      model: ApisModel,
+      API_INTEGRATION_TYPE,
+      API_INTEGRATION_TYPES,
+      API_AUTHENTICATIONS_TYPES
+  }

package/src/legacy/models/attendanceScale.js

@@ -0,0 +1,40 @@
+exports.model = (sequelize, DataTypes) => {
+  const AttendanceScale = sequelize.define('AttendanceScales', {
+    LineConfigurationId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'LineConfigurations',
+        key: 'id',
+      },
+      onDelete: 'CASCADE',
+      onUpdate: 'CASCADE',
+    },
+    day: {
+      allowNull: false,
+      type: DataTypes.ENUM([0, 1, 2, 3, 4, 5, 6]),
+    },
+    hourInit: {
+      allowNull: false,
+      type: DataTypes.TIME,
+      get(field) {
+        const hourInit = this.getDataValue(field)
+        return hourInit.substring(0, 5)
+      },
+    },
+    hourFinish: {
+      allowNull: false,
+      type: DataTypes.TIME,
+      get(field) {
+        const hourInit = this.getDataValue(field)
+        return hourInit.substring(0, 5)
+      },
+    },
+  })
+
+  AttendanceScale.associate = (models) => {
+    AttendanceScale.belongsTo(models.LineConfigurations)
+  }
+
+  return AttendanceScale
+}

package/src/legacy/models/attendanceScaleOff.js

@@ -0,0 +1,56 @@
+exports.model = (sequelize, DataTypes) => {
+  const AttendanceScale = sequelize.define('AttendanceScaleOffs', {
+    LineConfigurationId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'LineConfigurations',
+        key: 'id',
+      },
+      onDelete: 'CASCADE',
+      onUpdate: 'CASCADE',
+    },
+    date: {
+      allowNull: false,
+      type: DataTypes.DATEONLY,
+      get(field) {
+        const isRecorrent = this.getDataValue('isRecorrent')
+        const date = this.getDataValue(field)
+        if(!isRecorrent) return new Date(date).toISOString().substring(0, 10)
+        return new Date().getUTCFullYear() + new Date(date).toISOString().substring(4, 10)
+      },
+    },
+    hourInit: {
+      allowNull: true,
+      type: DataTypes.TIME,
+      get(field) {
+        const hourInit = this.getDataValue(field)
+        if(!hourInit) return hourInit
+        return hourInit.substring(0, 5)
+      },
+    },
+    hourFinish: {
+      allowNull: true,
+      type: DataTypes.TIME,
+      get(field) {
+        const hourFinish = this.getDataValue(field)
+        if(!hourFinish) return hourFinish
+        return hourFinish.substring(0, 5)
+      },
+    },
+    isRecorrent: {
+      allowNull: true,
+      type: DataTypes.BOOLEAN
+    },
+    allExpedientOff: {
+      allowNull: true,
+      type: DataTypes.BOOLEAN
+    },
+  })
+
+  AttendanceScale.associate = (models) => {
+    AttendanceScale.belongsTo(models.LineConfigurations)
+  }
+
+  return AttendanceScale
+}

package/src/legacy/models/attendances.js

@@ -0,0 +1,93 @@
+exports.model = (sequelize, DataTypes) => {
+  const Attendances = sequelize.define('Attendances', {
+    SessionId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'Sessions',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    LineId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'Lines',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    SystemUserId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'SystemUsers',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    status: {
+      type: DataTypes.ENUM(['waiting', 'started', 'closed', 'transfered']),
+      allowNull: false,
+      validate: {
+        notEmpty: false,
+      },
+    },
+    startedAt: {
+      allowNull: true,
+      type: DataTypes.DATE,
+    },
+    closedAt: {
+      allowNull: true,
+      type: DataTypes.DATE,
+    },
+    PreviousAttendanceId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'Attendances',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    clientData: {
+      allowNull: true,
+      type: DataTypes.JSON,
+    },
+    TranshipTriggerId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'TranshipTriggers',
+        key: 'id',
+      },
+      onDelete: 'SET NULL',
+      onUpdate: 'CASCADE',
+    },
+    protocol: {
+      allowNull: true,
+      type: DataTypes.STRING(255),
+    },
+    inactivityCounter: {
+      type: DataTypes.INTEGER,
+      allowNull: true,
+    }
+  })
+
+  Attendances.associate = models => {
+    Attendances.belongsTo(models.Sessions)
+    Attendances.belongsTo(models.SystemUsers)
+    Attendances.belongsTo(models.Lines)
+    Attendances.hasMany(models.TranshipConversations)
+    Attendances.hasOne(models.Attendances, { as: 'PreviousAttendance' })
+    Attendances.hasMany(models.Comments)
+    Attendances.belongsTo(models.TranshipTriggers)
+  }
+
+  return Attendances
+}

package/src/legacy/models/blacklistContacts.js

@@ -0,0 +1,24 @@
+exports.model = (sequelize, Sequelize) => {
+    const BlacklistContacts = sequelize.define('BlacklistContacts', {
+        ChannelId: {
+            type: Sequelize.UUID,
+            allowNull: true,
+            references: {
+                model: 'Channels',
+                key: 'id',
+            },
+            onDelete: 'RESTRICT',
+            onUpdate: 'CASCADE',
+        },
+            contact: {
+            allowNull: false,
+            type: Sequelize.STRING(255)
+        },
+    })
+  
+    BlacklistContacts.associate = models => {
+        BlacklistContacts.belongsTo(models.Channels)
+    }
+  
+    return BlacklistContacts
+}