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

package/src/legacy/models/ibmProvider.js

@@ -0,0 +1,57 @@
+exports.model = (sequelize, types) => {
+  const IbmProvider = sequelize.define('IbmProvider', {
+    url: {
+      type: types.STRING,
+      allowNull: true,
+    },
+
+    token: {
+      type: types.STRING,
+      allowNull: true,
+    },
+
+    active: {
+      type: types.BOOLEAN,
+      defaultValue: true,
+    },
+
+    IntelligenceId: {
+      type: types.UUID,
+      allowNull: false,
+      validate: {
+        notEmpty: true,
+      },
+    },
+
+    EnterpriseId: {
+      type: types.UUID,
+      allowNull: true,
+      references: {
+        model: 'Enterprises',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+
+    version: {
+      type: types.STRING(15),
+      allowNull: false,
+      defaultValue: '2018-09-20',
+    },
+
+    apiVersion: {
+      type: types.STRING(5),
+      allowNull: false,
+      defaultValue: 'v1',
+    },
+  })
+
+  IbmProvider.associate = (models) => {
+    IbmProvider.belongsTo(models.Intelligence)
+    IbmProvider.hasMany(models.Skill)
+    IbmProvider.belongsTo(models.Enterprises)
+  }
+
+  return IbmProvider
+}

package/src/legacy/models/inactivityTriggers.js

@@ -0,0 +1,37 @@
+exports.model = (sequelize, DataTypes) => {
+    const InactivityTriggers = sequelize.define('InactivityTriggers', {
+        SkillId: {
+            allowNull: false,
+            type: DataTypes.UUID,
+            references: {
+                model: 'Skills',
+                key: 'id',
+            },
+            onDelete: 'RESTRICT',
+            onUpdate: 'CASCADE',
+        },
+        DialogNodeId: {
+            allowNull: true,
+            type: DataTypes.UUID,
+            references: {
+                model: 'DialogNodes',
+                key: 'id',
+            },
+            onDelete: 'SET NULL',
+            onUpdate: 'CASCADE',
+        },
+        min: {
+            allowNull: false,
+            type: DataTypes.INTEGER
+        },
+        order: {
+            allowNull: false,
+            type: DataTypes.INTEGER
+        }
+    })
+    InactivityTriggers.associate = (models) => {
+        InactivityTriggers.belongsTo(models.Skill)
+        InactivityTriggers.belongsTo(models.DialogNodes)
+    }
+    return InactivityTriggers
+}

package/src/legacy/models/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 = {
+  model: IntelligenceModel,
+  PROVIDER_TYPE,
+  PROVIDER_TYPES,
+}

package/src/legacy/models/intention.js

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

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

@@ -0,0 +1,35 @@
+exports.model = (sequelize, types) => {
+    const ItleanProvider = sequelize.define('ItleanProvider', {
+      active: {
+        type: types.BOOLEAN,
+        defaultValue: true,
+      },
+      IntelligenceId: {
+        type: types.UUID,
+        allowNull: false,
+        validate: {
+          notEmpty: true,
+        },
+      },
+  
+      EnterpriseId: {
+        type: types.UUID,
+        allowNull: true,
+        references: {
+          model: 'Enterprises',
+          key: 'id',
+        },
+        onDelete: 'RESTRICT',
+        onUpdate: 'CASCADE',
+      },
+    })
+  
+    ItleanProvider.associate = (models) => {
+      ItleanProvider.belongsTo(models.Intelligence)
+      ItleanProvider.hasMany(models.Skill)
+      ItleanProvider.belongsTo(models.Enterprises)
+    }
+  
+    return ItleanProvider
+  }
+  

package/src/legacy/models/lineConfigurations.js

@@ -0,0 +1,63 @@
+exports.model = (sequelize, DataTypes) => {
+    const LineConfigurations = sequelize.define('LineConfigurations', {
+      LineId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        references: {
+          model: 'Lines',
+          key: 'id',
+        },
+        onDelete: 'RESTRICT',
+        onUpdate: 'CASCADE',
+      },
+      transfer: {
+        type: DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: true,
+      },
+      autoDistribution: {
+        type: DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: false,
+      },
+      sendEmoji: {
+        type: DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: false,
+      },
+      sendAttachment: {
+        type: DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: false,
+      },
+      activateSystemUserMaxResponseTime: {
+        type: DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: false,
+      },
+      systemUserMaxResponseTimeInMinutes: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+      },
+      activateUserMaxResponseTime: {
+        type: DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: false,
+      },
+      userMaxResponseTimeInMinutes: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+      },
+    })
+  
+    LineConfigurations.associate = (models) => {
+      LineConfigurations.belongsTo(models.Lines, { foreignKey: 'LineId' })
+      LineConfigurations.hasMany(models.AttendanceScales)
+      LineConfigurations.hasMany(models.AttendanceScaleOffs)
+    }
+  
+    return LineConfigurations
+  }
+  

package/src/legacy/models/lines.js

@@ -0,0 +1,49 @@
+exports.model = (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)
+    Lines.hasMany(models.TranshipInactivityTriggers)
+  }
+
+  return Lines
+}

package/src/legacy/models/messagesHsm.js

@@ -0,0 +1,75 @@
+const STATUS_MESSAGES = {
+   1: 'Pendente',
+   2: 'Enviado para aprovação',
+   3: 'Aprovado',
+   4: 'Recusado',
+ }
+
+ const MessagesHsms = (sequelize, DataTypes) => {
+   const MessagesHsms = sequelize.define('MessagesHsms', {
+     EnterpriseId: {
+       type: DataTypes.UUID,
+       allowNull: false,
+       references: {
+         model: 'Enterprises',
+         key: 'id',
+       },
+       onDelete: 'RESTRICT',
+       onUpdate: 'CASCADE',
+     },
+     TemplateId: {
+       type: DataTypes.UUID,
+       allowNull: false,
+       references: {
+         model: 'Templates',
+         key: 'id',
+       },
+       onDelete: 'RESTRICT',
+       onUpdate: 'CASCADE',
+     },
+     namespace: {
+       allowNull: true,
+       type: DataTypes.STRING,
+     },
+     elementName: {
+       allowNull: true,
+       type: DataTypes.STRING,
+     },
+     templateId: {
+       allowNull: true,
+       type: DataTypes.STRING,
+     },
+     title: {
+       allowNull: false,
+       type: DataTypes.STRING,
+     },
+     status: {
+       type: DataTypes.STRING,
+       defaultValue: STATUS_MESSAGES[1],
+     },
+     message: {
+       allowNull: true,
+       type: DataTypes.JSONB,
+     },
+     params: {
+       allowNull: true,
+       type: DataTypes.JSONB,
+     },
+   })
+ 
+   MessagesHsms.associate = (models) => {
+     MessagesHsms.belongsTo(models.Enterprises)
+     MessagesHsms.belongsTo(models.Templates)
+     MessagesHsms.belongsToMany(models.Channels, {
+       through: 'MessagesHsmChannels',
+       as: 'Channels',
+     })
+   }
+ 
+   return MessagesHsms
+ }
+ 
+ module.exports = {
+   model: MessagesHsms,
+   STATUS_MESSAGES
+ }

package/src/legacy/models/onlineEditions.js

@@ -0,0 +1,27 @@
+exports.model = (sequelize, DataTypes) => {
+    const OnlineEditions = sequelize.define('OnlineEditions', {
+        SystemUserId: {
+            type: DataTypes.UUID,
+            allowNull: false,
+        },
+        socketId: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        },
+        payload: {
+        type: DataTypes.JSON,
+        allowNull: false,
+        },
+        moduleName: {
+        type: DataTypes.STRING(50),
+        allowNull: false,
+        },
+    })
+  
+    OnlineEditions.associate = (models) => {
+        OnlineEditions.belongsTo(models.SystemUsers)
+    }
+  
+    return OnlineEditions
+  }
+  

package/src/legacy/models/openFaqs.js

@@ -0,0 +1,33 @@
+exports.model = (sequelize, Sequelize) => {
+  const OpenFAQs = sequelize.define('OpenFAQs', {
+    name: {
+      allowNull: false,
+      type: Sequelize.TEXT,
+      unique: false,
+    },
+    SkillId: {
+      allowNull: false,
+      type: Sequelize.UUID,
+      references: {
+        model: 'Skill',
+        key: 'id',
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE',
+    },
+    answers: {
+      allowNull: false,
+      type: Sequelize.JSON,
+      validate: {
+        notEmpty: true,
+      },
+    },
+  })
+
+  OpenFAQs.associate = (models) => {
+    OpenFAQs.belongsTo(models.Skill)
+    OpenFAQs.hasMany(models.FaqQuestions)
+  }
+
+  return OpenFAQs
+}

package/src/legacy/models/permissions.js

@@ -0,0 +1,28 @@
+exports.model = (sequelize, DataTypes) => {
+    const Permissions = sequelize.define('Permissions', {
+      permissionCode: {
+        type: DataTypes.STRING(50),
+        allowNull: false,
+        unique: true,
+        validate: {
+          notEmpty: true,
+        },
+      },
+      description: {
+        allowNull: false,
+        type: DataTypes.STRING(255),
+        validate: {
+          notEmpty: true,
+        },
+      },
+    })
+  
+    Permissions.associate = (models) => {
+      Permissions.belongsToMany(models.Profiles, {
+        through: models.Profiles_Permissions,
+      })
+    }
+  
+    return Permissions
+  }
+  

package/src/legacy/models/postbackGupshup.js

@@ -0,0 +1,27 @@
+exports.model = (sequelize, DataTypes) => {
+   const PostbackGupshupModel = sequelize.define('PostbackGupshups', {
+      app: {
+         allowNull: true,
+         type: DataTypes.STRING,
+      },
+      timestamp: {
+         allowNull: true,
+         type: DataTypes.STRING,
+      },
+      version: {
+         allowNull: true,
+         type: DataTypes.STRING,
+      },
+      type: {
+         allowNull: true,
+         type: DataTypes.STRING,
+      },
+      payload: {
+        allowNull: true,
+        type: DataTypes.JSONB,
+      },
+   })
+ 
+   return PostbackGupshupModel
+ }
+ 

package/src/legacy/models/profile.js

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

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

@@ -0,0 +1,30 @@
+exports.model = (sequelize, DataTypes) => {
+    const Publications = sequelize.define('Publications', {
+        SkillId: {
+            allowNull: false,
+            type: DataTypes.UUID,
+        },
+        status: {
+            type: DataTypes.ENUM(['publishing', 'completed', 'failed']),
+            allowNull: false,
+            validate: {
+              notEmpty: false,
+            },
+        },
+        error: {
+            type: DataTypes.TEXT,
+            allowNull: true
+        },
+        description: {
+            type: DataTypes.STRING(255),
+            allowNull: true
+        }
+    })
+  
+    Publications.associate = models => {
+        Publications.belongsTo(models.Skill)
+    }
+  
+    return Publications
+}
+  

package/src/legacy/models/quickMessages.js

@@ -0,0 +1,35 @@
+exports.model = (sequelize, DataTypes) => {
+    const QuickMessages = sequelize.define('QuickMessages', {
+      LineId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        references: {
+          model: 'Lines',
+          key: 'id',
+        },
+        onDelete: 'RESTRICT',
+        onUpdate: 'CASCADE',
+      },
+      shortcut: {
+        type: DataTypes.STRING(50),
+        allowNull: false,
+        validate: {
+          notEmpty: true,
+        },
+      },
+      content: {
+        type: DataTypes.TEXT,
+        allowNull: false,
+        validate: {
+          notEmpty: true,
+        },
+      },
+    })
+  
+    QuickMessages.associate = (models) => {
+      QuickMessages.belongsTo(models.Lines)
+    }
+  
+    return QuickMessages
+  }
+