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

package/src/legacy/models/botIterable.js

@@ -0,0 +1,137 @@
+exports.model = (sequelize, DataType) => {
+  const BotIterables = sequelize.define('BotIterables', {
+    context: {
+      type: DataType.JSON,
+      defaultValue: [],
+    },
+    type: {
+      type: DataType.STRING(100),
+      allowNull: true,
+    },
+    action:{
+      type: DataType.ENUM({
+        values: ['bot', 'client', 'callback'],
+      }),
+      allowNull: false,
+    },
+    message: {
+      type: DataType.TEXT,
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+    SessionId: {
+      type: DataType.UUID,
+      references: {
+        model: 'Sessions',
+        key: 'id',
+      },
+      allowNull: true,
+      onDelete: 'SET NULL',
+    },
+    ResponseId: {
+      type: DataType.UUID,
+      references: {
+        model: 'Responses',
+        key: 'id',
+      },
+      allowNull: true,
+      onDelete: 'SET NULL',
+    },
+    OpenFAQId: {
+      type: DataType.UUID,
+      references: {
+        model: 'OpenFAQs',
+        key: 'id',
+      },
+      allowNull: true,
+      onDelete: 'SET NULL',
+    },
+    DialogNodeId: {
+      type: DataType.UUID,
+      references: {
+        model: 'DialogNodes',
+        key: 'id',
+      },
+      allowNull: true,
+      onDelete: 'SET NULL',
+    },
+    EntityId: {
+      type: DataType.UUID,
+      references: {
+        model: 'Entities',
+        key: 'id',
+      },
+      allowNull: true,
+      onDelete: 'SET NULL',
+    },
+    IntentionId: {
+      type: DataType.UUID,
+      references: {
+        model: 'Intentions',
+        key: 'id',
+      },
+      allowNull: true,
+      onDelete: 'SET NULL',
+    },
+    BotIterableId: {
+      type: DataType.UUID,
+      allowNull: true,
+      references: {
+        model: 'BotIterables',
+        key: 'id',
+      },
+      onDelete: 'SET NULL',
+    },
+    payload: {
+      type: DataType.JSON,
+      allowNull: true
+    },
+    processedAt: {
+      allowNull: true,
+      type: DataType.DATE
+    },
+    enqueuedAt: {
+      allowNull: true,
+      type: DataType.DATE
+    },
+    failedAt: {
+      allowNull: true,
+      type: DataType.DATE
+    },
+    readAt: {
+      allowNull: true,
+      type: DataType.DATE
+    },
+    sentAt: {
+      allowNull: true,
+      type: DataType.DATE
+    },
+    deliveredAt: {
+      allowNull: true,
+      type: DataType.DATE
+    },
+    brokerMessageStatus: {
+      type: DataType.STRING(100),
+      allowNull: true,
+    },
+    brokerMessageId: {
+      type: DataType.UUID,
+      allowNull: true
+    },
+  })
+
+  BotIterables.associate = (models) => {
+    BotIterables.belongsTo(models.Sessions, { onDelete: 'SET NULL' })
+    BotIterables.belongsTo(models.Entity, { onDelete: 'SET NULL' })
+    BotIterables.belongsTo(models.Intention, { onDelete: 'SET NULL' })
+    BotIterables.belongsTo(models.OpenFAQs, { onDelete: 'SET NULL' })
+    BotIterables.belongsTo(models.DialogNodes, { onDelete: 'SET NULL' })
+    BotIterables.belongsTo(models.Responses, { onDelete: 'SET NULL' })
+    BotIterables.hasMany(models.BotIterables, { as: 'BotIterablesResponses', foreignKey: 'BotIterableId' })
+    BotIterables.belongsTo(models.BotIterables, { as: 'BotIterablesUserMessage', foreignKey: 'BotIterableId' })
+  }
+
+  return BotIterables
+}

package/src/legacy/models/branches.js

@@ -0,0 +1,35 @@
+exports.model = (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,
+      },
+    }
+  })
+
+  Branches.associate = models => {
+    Branches.belongsTo(models.Enterprises)
+    Branches.hasMany(models.Lines)
+  }
+
+  return Branches
+}

package/src/legacy/models/channelConfigurations.js

@@ -0,0 +1,41 @@
+exports.model = (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/legacy/models/channelTypes.js

@@ -0,0 +1,68 @@
+const CHANNEL_TYPES = {
+  WEB_CHAT: 'webchat',
+  WHATS_APP: 'whatsapp',
+  DEFAULT: 'default',
+  FACEBOOK: 'facebook',
+  WHATSAPP_INTERAXA: 'whatsapp_interaxa',
+  WHATSAPP_GUPSHUP: 'whatsapp_gupshup',
+  MICROSOFT_TEAMS: 'microsoft_teams',
+  FACEBOOK_MESSENGER: 'facebook_messenger',
+}
+
+const 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,
+      },
+    },
+    direct_contact_name: {
+      allowNull: false,
+      type: DataTypes.STRING,
+      validate: {
+        notEmpty: true,
+      },
+    },
+    direct_contact_code: {
+      allowNull: false,
+      type: DataTypes.STRING,
+      validate: {
+        notEmpty: true,
+      },
+    },
+    direct_contact_type: {
+      allowNull: false,
+      type: DataTypes.STRING,
+      validate: {
+        notEmpty: true,
+      },
+    },
+    responsesTypes: {
+      allowNull: true,
+      type: DataTypes.ARRAY(DataTypes.STRING),
+    },
+  })
+
+  ChannelTypes.associate = models => {
+    ChannelTypes.hasMany(models.ChannelConfigurations)
+    ChannelTypes.hasMany(models.Channels)
+    ChannelTypes.hasMany(models.ResponsesBoxes)
+  }
+
+  return ChannelTypes
+}
+
+module.exports = {
+  model: ChannelTypesModel,
+  CHANNEL_TYPES,
+}

package/src/legacy/models/channels.js

@@ -0,0 +1,77 @@
+exports.model = (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',
+    },
+    TitleIconFileId: {
+      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,
+    },
+    brokerChannelId: {
+      type: DataTypes.UUID,
+      allowNull: true
+    },
+    deletedAt: {
+      allowNull: true,
+      type: DataTypes.DATE,
+      defaultValue: null
+    }
+  })
+
+  Channels.associate = models => {
+    Channels.belongsTo(models.ChannelTypes)
+    Channels.belongsTo(models.Skill)
+    Channels.belongsTo(models.Files)
+    Channels.belongsTo(models.Files, {
+      as: 'TitleIconFile',
+      foreignKey: 'TitleIconFileId',
+    })
+    Channels.hasMany(models.Sessions)
+  }
+
+  return Channels
+}

package/src/legacy/models/client.js

@@ -0,0 +1,25 @@
+exports.model = (sequelize, DataType) => {
+    const Client = sequelize.define('Client', {
+      clientId: {
+        type: DataType.STRING,
+        allowNull: true,
+        validate: {
+          notEmpty: false,
+        },
+      },
+      serverId: {
+        type: DataType.STRING,
+        allowNull: false,
+        validate: {
+          notEmpty: true,
+        },
+      }
+    })
+    
+    Client.associate = (models) => {
+      Client.hasMany(models.Sessions)
+      Client.hasMany(models.ConversationSessions)
+    }
+  
+    return Client
+}

package/src/legacy/models/comments.js

@@ -0,0 +1,27 @@
+exports.model = (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/legacy/models/contacts.js

@@ -0,0 +1,41 @@
+exports.model = (sequelize, DataTypes) => {
+    const Contacts = sequelize.define('Contacts', {
+      EnterpriseId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        references: {
+          model: 'Enterprises',
+          key: 'id',
+        },
+        onDelete: 'RESTRICT',
+        onUpdate: 'CASCADE',
+      },
+      content: {
+        allowNull: false,
+        type: DataTypes.JSONB,
+        validate: {
+          notEmpty: true,
+        },
+      },
+      allSelected: {
+        type: DataTypes.BOOLEAN,
+        allowNull: true,
+        defaultValue: false,
+      },
+      headers: {
+        allowNull: true,
+        type: DataTypes.JSONB,
+      },
+    })
+  
+    Contacts.associate = (models) => {
+      Contacts.belongsTo(models.Enterprises)
+      Contacts.belongsToMany(models.Groups, {
+        through: 'GroupsContacts',
+        as: 'Groups',
+      })
+    }
+  
+    return Contacts
+  }
+  

package/src/legacy/models/conversationSessions.js

@@ -0,0 +1,56 @@
+exports.model = (sequelize, DataType) => {
+  const ConversationSessions = sequelize.define('ConversationSessions', {
+    ClientId: {
+      type: DataType.UUID,
+      references: {
+        model: 'Clients',
+        key: 'id',
+      },
+      allowNull: false,
+      onDelete: 'SET NULL',
+      onUpdate: 'CASCADE',
+    },
+    SessionId: {
+      type: DataType.UUID,
+      references: {
+        model: 'Sessions',
+        key: 'id',
+      },
+      allowNull: true,
+      onDelete: 'SET NULL',
+    },
+    ChannelTypeId: {
+      type: DataType.UUID,
+      allowNull: false,
+      references: {
+        model: 'ChannelTypes',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    SkillId: {
+      type: DataType.UUID,
+      references: {
+        model: 'Skill',
+        key: 'id',
+      },
+      allowNull: true,
+      onDelete: 'SET NULL',
+    },
+    isHsm: {
+      allowNull: false,
+      defaultValue: false,
+      type: DataType.BOOLEAN,
+    }
+  })
+
+  ConversationSessions.associate = (models) => {
+    ConversationSessions.belongsTo(models.Sessions, { onDelete: 'SET NULL' })
+    ConversationSessions.belongsTo(models.Client, { onDelete: 'SET NULL' })
+    ConversationSessions.belongsTo(models.Skill, { onDelete: 'SET NULL' })
+    ConversationSessions.belongsTo(models.ChannelTypes)
+  }
+
+  return ConversationSessions
+}

package/src/legacy/models/customPostbacks.js

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

package/src/legacy/models/departments.js

@@ -0,0 +1,35 @@
+exports.model = (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
+}