@itleanchatbot/shared-models-js-postgres 1.0.7 → 1.0.9

package/index.js

@@ -0,0 +1,59 @@
+const attendances = require('/src/attendances')
+const branches = require('/src/branches')
+const channelConfigurations = require('/src/channelConfigurations')
+const channels = require('/src/channels')
+const channelTypes = require('/src/channelTypes')
+const comments = require('/src/comments')
+const departments = require('/src/departments')
+const enterprises = require('/src/enterprises')
+const entity = require('/src/entity')
+const entityValues = require('/src/entityValues')
+const files = require('/src/files')
+const ibmProvider = require('/src/ibmProvider')
+const intelligence = require('/src/intelligence')
+const intention = require('/src/intention')
+const intentionValue = require('/src/intentionValue')
+const lines = require('/src/lines')
+const profile = require('/src/profile')
+const profiles_permission = require('/src/profiles_permission')
+const sessions = require('/src/sessions')
+const skill_apiResources = require('/src/skill_apiResources')
+const skill = require('/src/skill')
+const socketClients = require('/src/socketClients')
+const subDepartments = require('/src/subDepartments')
+const synonyms = require('/src/synonyms')
+const systemUsers_Lines = require('/src/systemUsers_Lines')
+const systemUsers_profiles = require('/src/systemUsers_profiles')
+const systemUsers = require('/src/systemUsers')
+const transhipConversations = require('/src/transhipConversations')
+
+module.exports = {
+    attendances,
+    branches,
+    channelConfigurations,
+    channels,
+    channelTypes,
+    comments,
+    departments,
+    enterprises,
+    entity,
+    entityValues,
+    files,
+    ibmProvider,
+    intelligence,
+    intention,
+    intentionValue,
+    lines,
+    profile,
+    profiles_permission,
+    sessions,
+    skill_apiResources,
+    skill,
+    socketClients,
+    subDepartments,
+    synonyms,
+    systemUsers_Lines,
+    systemUsers_profiles,
+    systemUsers,
+    transhipConversations
+}

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@itleanchatbot/shared-models-js-postgres",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Shared Models JS Postgres",
-  "main": "./src/index.js",
+  "main": "index.js",
   "license": "ISC",
   "author": "Wilber da Silva <wilber.costa@itlean.com>",
   "scripts": {
-    "lint": "npx eslint \"{src,apps,libs,test}/**/*.js\" --fix",
+    "lint": "npx eslint \"/**/*.js\" --fix",
     "format": "npm run format:src",
     "format:src": "npx prettier --write \"src/**/*.js\""
   },

package/src/attendances.js

@@ -0,0 +1,70 @@
+exports.AttendancesModel = (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',
+    },
+  })
+
+  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)
+  }
+
+  return Attendances
+}

package/src/branches.js

@@ -0,0 +1,47 @@
+exports.BranchesModel = (sequelize, DataTypes) => {
+  const Branches = sequelize.define('Branches', {
+    EnterpriseId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'Enterprises',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    internalId: {
+      allowNull: false,
+      type: DataTypes.STRING(50),
+      validate: {
+        notEmpty: true,
+      },
+    },
+    name: {
+      allowNull: false,
+      type: DataTypes.STRING(50),
+      validate: {
+        notEmpty: true,
+      },
+    },
+    phone: {
+      allowNull: true,
+      type: DataTypes.STRING(50),
+    },
+    website: {
+      allowNull: true,
+      type: DataTypes.STRING(255),
+    },
+    urlApi: {
+      allowNull: true,
+      type: DataTypes.STRING(255),
+    },
+  })
+
+  Branches.associate = models => {
+    Branches.belongsTo(models.Enterprises)
+    Branches.hasMany(models.Lines)
+  }
+
+  return Branches
+}

package/src/channelConfigurations.js

@@ -0,0 +1,41 @@
+exports.ChannelConfigurationsModel = (sequelize, DataTypes) => {
+  const ChannelConfigurations = sequelize.define('ChannelConfigurations', {
+    ChannelTypeId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'ChannelTypes',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    fieldName: {
+      type: DataTypes.STRING(50),
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+    fieldType: {
+      type: DataTypes.STRING(50),
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+    fieldLabel: {
+      type: DataTypes.STRING(50),
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+  })
+
+  ChannelConfigurations.associate = models => {
+    ChannelConfigurations.belongsTo(models.ChannelTypes)
+  }
+
+  return ChannelConfigurations
+}

package/src/channelTypes.js

@@ -0,0 +1,26 @@
+exports.ChannelTypesModel = (sequelize, DataTypes) => {
+  const ChannelTypes = sequelize.define('ChannelTypes', {
+    channelName: {
+      allowNull: false,
+      type: DataTypes.STRING(50),
+      unique: true,
+      validate: {
+        notEmpty: true,
+      },
+    },
+    channelLabel: {
+      allowNull: false,
+      type: DataTypes.STRING(50),
+      validate: {
+        notEmpty: true,
+      },
+    },
+  })
+
+  ChannelTypes.associate = models => {
+    ChannelTypes.hasMany(models.ChannelConfigurations)
+    ChannelTypes.hasMany(models.Channels)
+  }
+
+  return ChannelTypes
+}

package/src/channels.js

@@ -0,0 +1,54 @@
+exports.ChannelsModel = (sequelize, DataTypes) => {
+  const Channels = sequelize.define('Channels', {
+    SkillId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'Skill',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    ChannelTypeId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'ChannelTypes',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    FileId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'Files',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    name: {
+      type: DataTypes.STRING(50),
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+    configurations: {
+      type: DataTypes.JSON,
+      allowNull: false,
+    },
+  })
+
+  Channels.associate = models => {
+    Channels.belongsTo(models.ChannelTypes)
+    Channels.belongsTo(models.Skill)
+    Channels.belongsTo(models.Files)
+    Channels.hasMany(models.Sessions)
+  }
+
+  return Channels
+}

package/src/comments.js

@@ -0,0 +1,27 @@
+exports.CommentsModel = (sequelize, DataTypes) => {
+  const Comments = sequelize.define('Comments', {
+    AttendanceId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'Attendances',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    content: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+  })
+
+  Comments.associate = models => {
+    Comments.belongsTo(models.Attendances)
+  }
+
+  return Comments
+}

package/src/departments.js

@@ -0,0 +1,35 @@
+exports.DepartmentsModel = (sequelize, DataTypes) => {
+  const Departments = sequelize.define('Departments', {
+    EnterpriseId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'Enterprises',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    internalId: {
+      allowNull: false,
+      type: DataTypes.STRING(50),
+      validate: {
+        notEmpty: true,
+      },
+    },
+    name: {
+      allowNull: false,
+      type: DataTypes.STRING(50),
+      validate: {
+        notEmpty: true,
+      },
+    },
+  })
+
+  Departments.associate = models => {
+    Departments.belongsTo(models.Enterprises)
+    Departments.hasMany(models.Lines)
+  }
+
+  return Departments
+}

package/src/enterprises.js

@@ -0,0 +1,29 @@
+exports.EnterprisesModel = (sequelize, DataTypes) => {
+  const Enterprises = sequelize.define('Enterprises', {
+    cnpj: {
+      type: DataTypes.STRING(18),
+      allowNull: false,
+      unique: true,
+      validate: {
+        notEmpty: true,
+      },
+    },
+    name: {
+      allowNull: false,
+      type: DataTypes.STRING(50),
+      validate: {
+        notEmpty: true,
+      },
+    },
+  })
+
+  Enterprises.associate = models => {
+    Enterprises.hasMany(models.Departments)
+    Enterprises.hasMany(models.SubDepartments)
+    Enterprises.hasMany(models.Branches)
+    Enterprises.hasMany(models.SystemUsers)
+    Enterprises.hasMany(models.Files)
+  }
+
+  return Enterprises
+}

package/src/entity.js

@@ -0,0 +1,34 @@
+exports.EntityModel = (sequelize, types) => {
+  const Entity = sequelize.define('Entity', {
+    SkillId: {
+      type: types.UUID,
+      references: {
+        model: 'Skill',
+        key: 'id',
+      },
+      referencesKey: 'id',
+      foreignKeyConstraint: true,
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+    name: {
+      type: types.STRING,
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+    values: {
+      type: types.STRING,
+    },
+  })
+  Entity.associate = models => {
+    Entity.belongsTo(models.Skill)
+    Entity.hasMany(models.Synonyms)
+    Entity.hasMany(models.EntityValues)
+  }
+
+  return Entity
+}

package/src/entityValues.js

@@ -0,0 +1,63 @@
+const ENTITY_VALUES_TYPES = {
+  SYNONYM: 'synonyms',
+  PATTERN: 'pattern',
+}
+
+const ENTITY_VALUES_TYPE = [
+  ENTITY_VALUES_TYPES.SYNONYM,
+  ENTITY_VALUES_TYPES.PATTERN,
+]
+
+const EntityValuesModel = (sequelize, types) => {
+  const EntityValues = sequelize.define('EntityValues', {
+    EntityId: {
+      type: types.UUID,
+      references: {
+        model: 'Entity',
+        key: 'id',
+      },
+      referencesKey: 'id',
+      foreignKeyConstraint: true,
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+
+    name: {
+      type: types.STRING,
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+
+    synonyms: {
+      type: types.STRING,
+      allowNull: false,
+    },
+
+    type: {
+      type: types.ENUM({
+        values: ENTITY_VALUES_TYPE,
+      }),
+      allowNull: false,
+      defaultValue: ENTITY_VALUES_TYPES.SYNONYM,
+    },
+  })
+
+  EntityValues.associate = models => {
+    EntityValues.belongsTo(models.Entity)
+    EntityValues.hasMany(models.Synonyms)
+  }
+
+  return EntityValues
+}
+
+module.exports = {
+  EntityValuesModel,
+  ENTITY_VALUES_TYPE,
+  ENTITY_VALUES_TYPES,
+}

package/src/files.js

@@ -0,0 +1,35 @@
+exports.FilesModel = (sequelize, DataTypes) => {
+  const Files = sequelize.define('Files', {
+    EnterpriseId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'Enterprises',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    base64: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+    type: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+  })
+
+  Files.associate = models => {
+    Files.belongsTo(models.Enterprises)
+    Files.hasOne(models.Channels)
+  }
+
+  return Files
+}

package/src/ibmProvider.js

@@ -0,0 +1,43 @@
+exports.IbmProviderModel = (sequelize, types) => {
+  const IbmProvider = sequelize.define('IbmProvider', {
+    url: {
+      type: types.STRING,
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+
+    token: {
+      type: types.STRING,
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+
+    active: {
+      type: types.BOOLEAN,
+      defaultValue: true,
+    },
+
+    IntelligenceId: {
+      type: types.UUID,
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+
+    UserId: {
+      type: types.UUID,
+    },
+  })
+
+  IbmProvider.associate = models => {
+    IbmProvider.belongsTo(models.Intelligence)
+    IbmProvider.hasMany(models.Skill)
+  }
+
+  return IbmProvider
+}

package/src/intelligence.js

@@ -0,0 +1,45 @@
+const PROVIDER_TYPES = {
+  AWS: 'aws',
+  IBM: 'ibm',
+  ITLEAN: 'itlean',
+}
+
+const PROVIDER_TYPE = [
+  PROVIDER_TYPES.AWS,
+  PROVIDER_TYPES.IBM,
+  PROVIDER_TYPES.ITLEAN,
+]
+
+const IntelligenceModel = (sequelize, types) => {
+  const Intelligence = sequelize.define('Intelligence', {
+    name: {
+      type: types.STRING,
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+    providerType: {
+      type: types.ENUM({
+        values: PROVIDER_TYPE,
+      }),
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+  })
+
+  Intelligence.associate = models => {
+    Intelligence.hasMany(models.Skill)
+    Intelligence.hasMany(models.IbmProvider)
+  }
+
+  return Intelligence
+}
+
+module.exports = {
+  IntelligenceModel,
+  PROVIDER_TYPE,
+  PROVIDER_TYPES,
+}

package/src/intention.js

@@ -0,0 +1,36 @@
+exports.IntentionModel = (sequelize, types) => {
+  const Intention = sequelize.define('Intention', {
+    SkillId: {
+      type: types.UUID,
+      references: {
+        model: 'Skill',
+        key: 'id',
+      },
+      referencesKey: 'id',
+      foreignKeyConstraint: true,
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+
+    name: {
+      type: types.STRING,
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+
+    description: {
+      type: types.STRING,
+    },
+  })
+
+  Intention.associate = models => {
+    Intention.belongsTo(models.Skill)
+    Intention.hasMany(models.IntentionValue)
+  }
+
+  return Intention
+}

package/src/intentionValue.js

@@ -0,0 +1,31 @@
+exports.IntentionValueModel = (sequelize, types) => {
+  const IntentionValue = sequelize.define('IntentionValue', {
+    IntentionId: {
+      type: types.UUID,
+      references: {
+        model: 'Intention',
+        key: 'id',
+      },
+      referencesKey: 'id',
+      foreignKeyConstraint: true,
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+
+    name: {
+      type: types.STRING,
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+  })
+
+  IntentionValue.associate = models => {
+    IntentionValue.belongsTo(models.Intention)
+  }
+
+  return IntentionValue
+}

package/src/lines.js

@@ -0,0 +1,48 @@
+exports.LinesModel = (sequelize, DataTypes) => {
+  const Lines = sequelize.define('Lines', {
+    BranchId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'Branches',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    DepartmentId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'Departments',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    SubDepartmentId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'SubDepartments',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+  })
+
+  Lines.associate = models => {
+    Lines.belongsTo(models.Branches)
+    Lines.belongsTo(models.Departments)
+    Lines.belongsTo(models.SubDepartments)
+    Lines.belongsToMany(models.SystemUsers, {
+      through: models.SystemUsers_Lines,
+    })
+    Lines.hasOne(models.LineConfigurations)
+    Lines.hasMany(models.Attendances)
+    Lines.hasMany(models.QuickMessages)
+  }
+
+  return Lines
+}

package/src/profile.js

@@ -0,0 +1,23 @@
+exports.ProfilesModel = (sequelize, DataTypes) => {
+  const Profiles = sequelize.define('Profiles', {
+    name: {
+      allowNull: false,
+      unique: true,
+      type: DataTypes.STRING(50),
+      validate: {
+        notEmpty: true,
+      },
+    },
+  })
+
+  Profiles.associate = models => {
+    Profiles.belongsToMany(models.Permissions, {
+      through: models.Profiles_Permissions,
+    })
+    Profiles.belongsToMany(models.SystemUsers, {
+      through: models.SystemUsers_Profiles,
+    })
+  }
+
+  return Profiles
+}

package/src/profiles_permission.js

@@ -0,0 +1,25 @@
+exports.Profiles_PermissionsModel = (sequelize, DataTypes) => {
+  const Profiles_Permissions = sequelize.define('Profiles_Permissions', {
+    ProfileId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'Profiles',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    PermissionId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'Permissions',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+  })
+  return Profiles_Permissions
+}

package/src/sessions.js

@@ -0,0 +1,44 @@
+exports.SessionsModel = (sequelize, DataTypes) => {
+  const Sessions = sequelize.define('Sessions', {
+    ChannelId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'Channels',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    context: {
+      type: DataTypes.JSON,
+      allowNull: true,
+      validate: {
+        notEmpty: false,
+      },
+    },
+    tranship: {
+      type: DataTypes.BOOLEAN,
+      defaultValue: false,
+    },
+    status: {
+      type: DataTypes.ENUM(['open', 'closed', 'expired']),
+      allowNull: false,
+      validate: {
+        notEmpty: false,
+      },
+    },
+    endOfSession: {
+      type: DataTypes.DATE,
+      allowNull: true,
+    },
+  })
+
+  Sessions.associate = models => {
+    Sessions.belongsTo(models.Channels)
+    Sessions.hasOne(models.Attendances)
+    Sessions.hasOne(models.SocketClients)
+  }
+
+  return Sessions
+}

package/src/skill.js

@@ -0,0 +1,104 @@
+const SKILL_LANG = ['pt-br']
+
+const STATUS_TYPES = {
+  NOT_ACTION: 'without_action',
+  WAIT: 'waiting',
+  SUCCESS: 'success',
+  FAIL: 'failed',
+  CANCEL: 'cancel',
+}
+
+const STATUS = [
+  STATUS_TYPES.NOT_ACTION,
+  STATUS_TYPES.WAIT,
+  STATUS_TYPES.SUCCESS,
+  STATUS_TYPES.FAIL,
+  STATUS_TYPES.CANCEL,
+]
+
+const SkillModel = (sequelize, types) => {
+  const Skill = sequelize.define('Skill', {
+    IntelligenceId: {
+      type: types.UUID,
+      allowNull: false,
+      references: {
+        model: 'Intelligence',
+        key: 'id',
+      },
+    },
+
+    AwsProviderId: {
+      type: types.UUID,
+    },
+    IbmProviderId: {
+      type: types.UUID,
+      allowNull: true,
+      references: {
+        model: 'IbmProvider',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    ItleanProviderId: {
+      type: types.UUID,
+      allowNull: true,
+      references: {
+        model: 'ItleanProvider',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    name: {
+      type: types.STRING,
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+    description: {
+      type: types.STRING,
+      defaultValue: '',
+    },
+    lang: {
+      type: types.ENUM({
+        values: SKILL_LANG,
+      }),
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+    publishProcessStatus: {
+      type: types.ENUM({
+        values: STATUS,
+      }),
+      defaultValue: STATUS_TYPES.NOT_ACTION,
+    },
+    externalIbmId: {
+      type: types.STRING,
+    },
+    publishedOnProvider: {
+      type: types.BOOLEAN,
+      defaultValue: false,
+    },
+  })
+
+  Skill.associate = models => {
+    Skill.belongsTo(models.Intelligence)
+    Skill.hasMany(models.Intention)
+    Skill.hasMany(models.Entity)
+    Skill.hasMany(models.Channels)
+    Skill.hasMany(models.Skill_ApiResources)
+  }
+
+  return Skill
+}
+
+module.exports = {
+  SkillModel,
+  SKILL_LANG,
+  STATUS,
+  STATUS_TYPES,
+}

package/src/skill_apiResources.js

@@ -0,0 +1,31 @@
+exports.Skill_ApiResourcesModel = (sequelize, Sequelize) => {
+  const Skill_ApiResources = sequelize.define('Skill_ApiResources', {
+    SkillId: {
+      type: Sequelize.UUID,
+      allowNull: false,
+      references: {
+        model: 'Skills',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    ApiResourceId: {
+      type: Sequelize.UUID,
+      allowNull: false,
+      references: {
+        model: 'ApiResources',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+  })
+
+  Skill_ApiResources.associate = models => {
+    Skill_ApiResources.belongsTo(models.Skill)
+    // Skill_ApiResources.belongsTo(models.ApiResources)
+  }
+
+  return Skill_ApiResources
+}

package/src/socketClients.js

@@ -0,0 +1,45 @@
+exports.SocketClientsModel = (sequelize, DataTypes) => {
+  const SocketClients = sequelize.define('SocketClients', {
+    SessionId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'Sessions',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    SystemUserId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'SystemUsers',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    socketId: {
+      type: DataTypes.STRING,
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+    protocol: {
+      type: DataTypes.STRING,
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+  })
+
+  SocketClients.associate = models => {
+    SocketClients.belongsTo(models.Sessions)
+    SocketClients.belongsTo(models.SystemUsers)
+  }
+
+  return SocketClients
+}

package/src/subDepartments.js

@@ -0,0 +1,35 @@
+exports.SubDepartmentsModel = (sequelize, DataTypes) => {
+  const SubDepartments = sequelize.define('SubDepartments', {
+    EnterpriseId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'Enterprises',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    internalId: {
+      allowNull: false,
+      type: DataTypes.STRING(50),
+      validate: {
+        notEmpty: true,
+      },
+    },
+    name: {
+      allowNull: false,
+      type: DataTypes.STRING(50),
+      validate: {
+        notEmpty: true,
+      },
+    },
+  })
+
+  SubDepartments.associate = models => {
+    SubDepartments.belongsTo(models.Enterprises)
+    SubDepartments.hasMany(models.Lines)
+  }
+
+  return SubDepartments
+}

package/src/synonyms.js

@@ -0,0 +1,66 @@
+const SYNONYMS_TYPES = {
+  SYNONYM: 'synonyms',
+  PATTERN: 'pattern',
+}
+
+const SYNONYMS_TYPE = [SYNONYMS_TYPES.SYNONYM, SYNONYMS_TYPES.PATTERN]
+
+const SynonymsModel = (sequelize, types) => {
+  const Synonyms = sequelize.define('Synonyms', {
+    EntityValueId: {
+      type: types.UUID,
+      references: {
+        model: 'EntityValues',
+        key: 'id',
+      },
+      referencesKey: 'id',
+      foreignKeyConstraint: true,
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+
+    EntityId: {
+      type: types.UUID,
+      references: {
+        model: 'Entities',
+        key: 'id',
+      },
+      referencesKey: 'id',
+      foreignKeyConstraint: true,
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+
+    name: {
+      type: types.STRING,
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+
+    type: {
+      type: types.ENUM({
+        values: SYNONYMS_TYPE,
+      }),
+      allowNull: false,
+      defaultValue: SYNONYMS_TYPES.SYNONYM,
+    },
+  })
+
+  Synonyms.associate = models => {
+    Synonyms.belongsTo(models.EntityValues)
+  }
+
+  return Synonyms
+}
+
+module.exports = {
+  SynonymsModel,
+  SYNONYMS_TYPE,
+  SYNONYMS_TYPES,
+}

package/src/systemUsers.js

@@ -0,0 +1,50 @@
+exports.SystemUsersModel = (sequelize, DataTypes) => {
+  const SystemUsers = sequelize.define('SystemUsers', {
+    name: {
+      allowNull: false,
+      type: DataTypes.STRING(50),
+      validate: {
+        notEmpty: true,
+      },
+    },
+    email: {
+      allowNull: false,
+      type: DataTypes.TEXT,
+      unique: true,
+      validate: {
+        notEmpty: true,
+      },
+    },
+    password: {
+      type: DataTypes.TEXT,
+    },
+    EnterpriseId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'Enterprises',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    maxSimultaneousAttendances: {
+      type: DataTypes.INTEGER,
+      allowNull: true,
+    },
+  })
+
+  SystemUsers.associate = models => {
+    SystemUsers.belongsToMany(models.Profiles, {
+      through: models.SystemUsers_Profiles,
+    })
+    SystemUsers.belongsTo(models.Enterprises)
+    SystemUsers.belongsToMany(models.Lines, {
+      through: models.SystemUsers_Lines,
+    })
+    SystemUsers.hasMany(models.Attendances)
+    SystemUsers.hasMany(models.SocketClients)
+  }
+
+  return SystemUsers
+}

package/src/systemUsers_Lines.js

@@ -0,0 +1,25 @@
+exports.SystemUsers_LinesModel = (sequelize, DataTypes) => {
+  const SystemUsers_Lines = sequelize.define('SystemUsers_Lines', {
+    SystemUserId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'SystemUsers',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    LineId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'Lines',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+  })
+  return SystemUsers_Lines
+}

package/src/systemUsers_profiles.js

@@ -0,0 +1,25 @@
+exports.SystemUsers_ProfilesModel = (sequelize, DataTypes) => {
+  const SystemUsers_Profiles = sequelize.define('SystemUsers_Profiles', {
+    SystemUserId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'SystemUsers',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    ProfileId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'Profiles',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+  })
+  return SystemUsers_Profiles
+}

package/src/transhipConversations.js

@@ -0,0 +1,34 @@
+exports.TranshipConversationsModel = (sequelize, DataTypes) => {
+  const TranshipConversations = sequelize.define('TranshipConversations', {
+    AttendanceId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'Attendances',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    action: {
+      type: DataTypes.ENUM(['tranship', 'client']),
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+    message: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+  })
+
+  TranshipConversations.associate = models => {
+    TranshipConversations.belongsTo(models.Attendances)
+  }
+
+  return TranshipConversations
+}