@itleanchatbot/shared-models-js-postgres 1.4.91 → 2.0.0

package/src/migrations/20210819155330-create-function.js

@@ -0,0 +1,123 @@
+'use strict'
+
+module.exports = {
+  up: async (queryInterface, Sequelize) => {
+    await queryInterface.addIndex('BotIterables', {
+      fields: [
+        {
+          attribute: 'SessionId',
+        },
+        {
+          attribute: 'createdAt',
+          order: 'DESC',
+        },
+      ],
+    })
+
+    await queryInterface.addIndex('InactivityTriggers', ['SkillId', 'order'])
+
+    await queryInterface.addIndex('Sessions', ['ChannelId'])
+
+    await queryInterface.addIndex('Sessions', ['ClientId'])
+
+    await queryInterface.sequelize.query(
+      `
+            CREATE OR REPLACE FUNCTION get_inactive_sessions(first_call boolean, records_per_page int, starter_page int, maximun int, current_page int DEFAULT 1)
+            RETURNS TABLE ("id" uuid) AS $$
+            declare r RECORD;
+            declare last_iterable "BotIterables"%ROWTYPE;
+            declare min_diff INT;
+            declare counter INT := 0;
+            BEGIN
+            
+                IF ((records_per_page * current_page) > maximun) THEN
+                    RETURN;
+                END IF;
+            
+                IF (first_call) THEN
+                    DROP TABLE IF EXISTS _tmp_get_inactive_sessions;
+                    CREATE TEMPORARY TABLE _tmp_get_inactive_sessions (
+                        "id" uuid
+                    );
+                END IF;
+            
+                FOR r IN (
+                    select "Sessions"."id",
+                        "InactivityTriggers"."min"
+                    from "Sessions"
+                        inner join "Clients"
+                        on "Clients"."id" = "Sessions"."ClientId"
+                        inner join "Channels"
+                        on "Channels"."id" = "Sessions"."ChannelId"
+                        inner join "ChannelTypes"
+                        on "ChannelTypes"."id" = "Channels"."ChannelTypeId"
+                        inner join "InactivityTriggers"
+                        on "InactivityTriggers"."SkillId" = "Channels"."SkillId"
+                            and "InactivityTriggers"."order" = "Sessions"."inactivityCounter"
+                    where "Sessions"."status" = 'open'
+                        and "Sessions"."tranship" = false
+                    order by "Sessions"."createdAt"
+                    limit records_per_page
+                    offset ((starter_page - 1)*records_per_page)
+                ) LOOP
+                
+                    select * into last_iterable
+                    from "BotIterables"
+                    where "BotIterables"."SessionId" = r."id"
+                    order by "BotIterables"."createdAt" DESC
+                    limit 1;
+                    
+                    min_diff := (
+                        (SELECT DATE_PART('day', current_timestamp - last_iterable."createdAt") * 24 * 60) +
+                        (SELECT DATE_PART('hour', current_timestamp - last_iterable."createdAt") * 60) +
+                        (SELECT DATE_PART('minute', current_timestamp - last_iterable."createdAt"))
+                    );
+                    
+                    IF (last_iterable."action" = 'bot' and min_diff >= r."min") THEN
+            
+                        INSERT INTO _tmp_get_inactive_sessions ("id") 
+                        VALUES (r."id");
+                        
+                    END IF;
+                    
+                    counter := counter + 1;
+                
+                END LOOP;
+                
+                IF (counter = records_per_page) THEN
+                    PERFORM get_inactive_sessions(false, records_per_page, starter_page + 1, maximun, current_page + 1);
+                END IF;
+                
+                RETURN QUERY
+                SELECT * FROM _tmp_get_inactive_sessions;
+            
+            END;
+            $$ LANGUAGE plpgsql;
+        `
+    )
+  },
+
+  down: async (queryInterface, Sequelize) => {
+    await queryInterface.sequelize.query(
+      `DROP FUNCTION get_inactive_sessions(first_call boolean, records_per_page int, starter_page int, maximun int, current_page int)`
+    )
+
+    await queryInterface.removeIndex('BotIterables', {
+      fields: [
+        {
+          attribute: 'SessionId',
+        },
+        {
+          attribute: 'createdAt',
+          order: 'DESC',
+        },
+      ],
+    })
+
+    await queryInterface.removeIndex('InactivityTriggers', ['SkillId', 'order'])
+
+    await queryInterface.removeIndex('Sessions', ['ChannelId'])
+
+    await queryInterface.removeIndex('Sessions', ['ClientId'])
+  },
+}

package/src/migrations/20210823145424-remove-names-botiterables.js

@@ -0,0 +1,74 @@
+'use strict'
+
+module.exports = {
+  up: async (queryInterface, Sequelize) => {
+    await queryInterface.removeColumn('BotIterables', 'responseName')
+    await queryInterface.removeColumn('BotIterables', 'openFaqName')
+    await queryInterface.removeColumn('BotIterables', 'dialogNodeName')
+
+    await queryInterface.changeColumn('BotIterables', 'ResponseId', {
+      type: Sequelize.UUID,
+      references: {
+        model: 'Responses',
+        key: 'id',
+      },
+      allowNull: true,
+      onDelete: 'SET NULL',
+    })
+
+    await queryInterface.changeColumn('BotIterables', 'OpenFAQId', {
+      type: Sequelize.UUID,
+      references: {
+        model: 'OpenFAQs',
+        key: 'id',
+      },
+      allowNull: true,
+      onDelete: 'SET NULL',
+    })
+
+    await queryInterface.changeColumn('BotIterables', 'DialogNodeId', {
+      type: Sequelize.UUID,
+      references: {
+        model: 'DialogNodes',
+        key: 'id',
+      },
+      allowNull: true,
+      onDelete: 'SET NULL',
+    })
+
+    await queryInterface.changeColumn('BotIterables', 'EntityId', {
+      type: Sequelize.UUID,
+      references: {
+        model: 'Entities',
+        key: 'id',
+      },
+      allowNull: true,
+      onDelete: 'SET NULL',
+    })
+
+    await queryInterface.changeColumn('BotIterables', 'IntentionId', {
+      type: Sequelize.UUID,
+      references: {
+        model: 'Intentions',
+        key: 'id',
+      },
+      allowNull: true,
+      onDelete: 'SET NULL',
+    })
+  },
+
+  down: async (queryInterface, Sequelize) => {
+    await queryInterface.addColumn('BotIterables', 'responseName', {
+      type: Sequelize.STRING(255),
+      allowNull: true,
+    })
+    await queryInterface.addColumn('BotIterables', 'openFaqName', {
+      type: Sequelize.STRING(255),
+      allowNull: true,
+    })
+    await queryInterface.addColumn('BotIterables', 'dialogNodeName', {
+      type: Sequelize.STRING(255),
+      allowNull: true,
+    })
+  },
+}

package/src/migrations/20210902145430-create-apiKeys.js

@@ -0,0 +1,40 @@
+'use strict'
+
+module.exports = {
+  up: async (queryInterface, Sequelize) => {
+    await queryInterface.createTable('ApiKeys', {
+      id: {
+        allowNull: false,
+        defaultValue: Sequelize.literal('uuid_generate_v4()'),
+        primaryKey: true,
+        type: Sequelize.UUID,
+      },
+      EnterpriseId: {
+        allowNull: false,
+        type: Sequelize.UUID,
+        references: {
+          model: 'Enterprises',
+          key: 'id',
+        },
+        onDelete: 'RESTRICT',
+        onUpdate: 'CASCADE',
+      },
+      key: {
+        allowNull: false,
+        type: Sequelize.STRING(255),
+      },
+      createdAt: {
+        allowNull: false,
+        type: Sequelize.DATE,
+      },
+      updatedAt: {
+        allowNull: false,
+        type: Sequelize.DATE,
+      },
+    })
+  },
+
+  down: async (queryInterface, Sequelize) => {
+    await queryInterface.dropTable('ApiKeys')
+  },
+}

package/src/migrations/20210906092430-create-customPostback.js

@@ -0,0 +1,44 @@
+'use strict'
+
+module.exports = {
+  up: async (queryInterface, Sequelize) => {
+    await queryInterface.createTable('CustomPostbacks', {
+      id: {
+        allowNull: false,
+        defaultValue: Sequelize.literal('uuid_generate_v4()'),
+        primaryKey: true,
+        type: Sequelize.UUID,
+      },
+      EnterpriseId: {
+        allowNull: false,
+        type: Sequelize.UUID,
+        references: {
+          model: 'Enterprises',
+          key: 'id',
+        },
+        onDelete: 'RESTRICT',
+        onUpdate: 'CASCADE',
+      },
+      url: {
+        allowNull: false,
+        type: Sequelize.STRING(255),
+      },
+      headers: {
+        allowNull: true,
+        type: Sequelize.JSON,
+      },
+      createdAt: {
+        allowNull: false,
+        type: Sequelize.DATE,
+      },
+      updatedAt: {
+        allowNull: false,
+        type: Sequelize.DATE,
+      },
+    })
+  },
+
+  down: async (queryInterface, Sequelize) => {
+    await queryInterface.dropTable('CustomPostbacks')
+  },
+}

package/src/migrations/20210906144034-alter-api-body-migration.js

@@ -0,0 +1,74 @@
+'use strict'
+
+const {
+  apiResourceBodies: { APIS_RESOURCES_BODY_TYPES },
+} = require('@itleanchatbot/shared-models-js-postgres')
+
+const oldEnumString = `'${APIS_RESOURCES_BODY_TYPES.JSON}', '${APIS_RESOURCES_BODY_TYPES.TEXT}', '${APIS_RESOURCES_BODY_TYPES.XML}', '${APIS_RESOURCES_BODY_TYPES.HTML}'`
+const newEnumString = `'${APIS_RESOURCES_BODY_TYPES.JSON}', '${APIS_RESOURCES_BODY_TYPES.TEXT}', '${APIS_RESOURCES_BODY_TYPES.XML}', '${APIS_RESOURCES_BODY_TYPES.HTML}', '${APIS_RESOURCES_BODY_TYPES.URL_ENCODE}'`
+
+const replaceEnum = async (replaceTo, queryInterface) => {
+  const transaction = await queryInterface.sequelize.transaction()
+  try {
+    await queryInterface.sequelize.query(
+      `
+                CREATE TYPE "enum_ApiResourcesBodies_type_new"
+                AS ENUM (${replaceTo})
+            `,
+      { transaction }
+    )
+    await queryInterface.sequelize.query(
+      `
+                ALTER TABLE "ApiResourcesBodies"
+                ALTER COLUMN "type"
+                DROP DEFAULT
+            `,
+      { transaction }
+    )
+    await queryInterface.sequelize.query(
+      `
+                ALTER TABLE "ApiResourcesBodies"
+                ALTER COLUMN "type"
+                TYPE "enum_ApiResourcesBodies_type_new"
+                USING ("type"::text::"enum_ApiResourcesBodies_type_new")
+            `,
+      { transaction }
+    )
+    await queryInterface.sequelize.query(
+      `
+                DROP TYPE "enum_ApiResourcesBodies_type"
+            `,
+      { transaction }
+    )
+    await queryInterface.sequelize.query(
+      `
+                ALTER TYPE "enum_ApiResourcesBodies_type_new"
+                RENAME TO "enum_ApiResourcesBodies_type"
+            `,
+      { transaction }
+    )
+    await queryInterface.sequelize.query(
+      `
+                ALTER TABLE "ApiResourcesBodies"
+                ALTER COLUMN "type"
+                SET DEFAULT 'json'::"enum_ApiResourcesBodies_type"
+            `,
+      { transaction }
+    )
+    await transaction.commit()
+  } catch (error) {
+    console.error(error)
+    transaction.rollback()
+    throw error
+  }
+}
+
+module.exports = {
+  up: async (queryInterface) => {
+    await replaceEnum(newEnumString, queryInterface)
+  },
+
+  down: async (queryInterface) => {
+    await replaceEnum(oldEnumString, queryInterface)
+  },
+}

package/src/migrations/20210910081430-create-transhipInactivityTriggers.js

@@ -0,0 +1,48 @@
+'use strict'
+
+module.exports = {
+  up: async (queryInterface, Sequelize) => {
+    await queryInterface.createTable('TranshipInactivityTriggers', {
+      id: {
+        allowNull: false,
+        defaultValue: Sequelize.literal('uuid_generate_v4()'),
+        primaryKey: true,
+        type: Sequelize.UUID,
+      },
+      LineId: {
+        allowNull: false,
+        type: Sequelize.UUID,
+        references: {
+          model: 'Lines',
+          key: 'id',
+        },
+        onDelete: 'SET NULL',
+        onUpdate: 'CASCADE',
+      },
+      min: {
+        allowNull: false,
+        type: Sequelize.INTEGER,
+      },
+      response: {
+        allowNull: false,
+        type: Sequelize.TEXT,
+      },
+      order: {
+        allowNull: false,
+        type: Sequelize.INTEGER,
+      },
+      createdAt: {
+        allowNull: false,
+        type: Sequelize.DATE,
+      },
+      updatedAt: {
+        allowNull: false,
+        type: Sequelize.DATE,
+      },
+    })
+  },
+
+  down: async (queryInterface, Sequelize) => {
+    await queryInterface.dropTable('TranshipInactivityTriggers')
+  },
+}

package/src/migrations/20210923131530-alter-attendances.js

@@ -0,0 +1,14 @@
+'use strict'
+
+module.exports = {
+  up: async (queryInterface, Sequelize) => {
+    await queryInterface.addColumn('Attendances', 'inactivityCounter', {
+      type: Sequelize.INTEGER,
+      allowNull: true,
+    })
+  },
+
+  down: async (queryInterface, Sequelize) => {
+    await queryInterface.removeColumn('Attendances', 'inactivityCounter')
+  },
+}

package/src/migrations/20210923140130-create-function.js

@@ -0,0 +1,85 @@
+'use strict'
+
+module.exports = {
+  up: async (queryInterface, Sequelize) => {
+    await queryInterface.sequelize.query(
+      `
+        CREATE OR REPLACE FUNCTION get_inactive_attendances(first_call boolean, records_per_page int, starter_page int, maximun int, current_page int DEFAULT 1)
+        RETURNS TABLE ("id" uuid) AS $$
+        declare r RECORD;
+        declare last_iterable "TranshipConversations"%ROWTYPE;
+        declare min_diff INT;
+        declare counter INT := 0;
+        BEGIN
+        
+            IF ((records_per_page * current_page) > maximun) THEN
+                RETURN;
+            END IF;
+        
+            IF (first_call) THEN
+                DROP TABLE IF EXISTS _tmp_get_inactive_attendances;
+                CREATE TEMPORARY TABLE _tmp_get_inactive_attendances (
+                    "id" uuid
+                );
+            END IF;
+        
+            FOR r IN (
+                select "Sessions"."id",
+                    "Attendances"."id" as "AttendanceId",
+                    "TranshipInactivityTriggers"."min"
+                from "Sessions"
+                    inner join "Attendances"
+                    on "Attendances"."SessionId" = "Sessions"."id"
+                        and "Attendances"."status" = 'started'
+                    inner join "TranshipInactivityTriggers"
+                    on "Attendances"."LineId" = "TranshipInactivityTriggers"."LineId"
+                        and "TranshipInactivityTriggers"."order" = "Attendances"."inactivityCounter"
+                where "Sessions"."tranship" = true
+                    and "Sessions"."status" = 'open'
+                order by "Sessions"."createdAt"
+                limit records_per_page
+                offset ((starter_page - 1)*records_per_page)
+            ) LOOP
+            
+                select * into last_iterable
+                from "TranshipConversations"
+                where "TranshipConversations"."AttendanceId" = r."AttendanceId"
+                order by "TranshipConversations"."createdAt" DESC
+                limit 1;
+                
+                min_diff := (
+                    (SELECT DATE_PART('day', current_timestamp - last_iterable."createdAt") * 24 * 60) +
+                    (SELECT DATE_PART('hour', current_timestamp - last_iterable."createdAt") * 60) +
+                    (SELECT DATE_PART('minute', current_timestamp - last_iterable."createdAt"))
+                );
+                
+                IF (last_iterable."action" = 'tranship' and min_diff >= r."min") THEN
+        
+                    INSERT INTO _tmp_get_inactive_attendances ("id") 
+                    VALUES (r."id");
+                    
+                END IF;
+                
+                counter := counter + 1;
+            
+            END LOOP;
+            
+            IF (counter = records_per_page) THEN
+                PERFORM get_inactive_attendances(false, records_per_page, starter_page + 1, maximun, current_page + 1);
+            END IF;
+            
+            RETURN QUERY
+            SELECT * FROM _tmp_get_inactive_attendances;
+        
+        END;
+        $$ LANGUAGE plpgsql;
+        `
+    )
+  },
+
+  down: async (queryInterface, Sequelize) => {
+    await queryInterface.sequelize.query(
+      `DROP FUNCTION get_inactive_attendances(first_call boolean, records_per_page int, starter_page int, maximun int, current_page int)`
+    )
+  },
+}

package/src/migrations/20210927141630-alter-attendances.js

@@ -0,0 +1,32 @@
+'use strict'
+
+const { replaceEnum } = require('../../presenters/database/migrationHelpers')
+
+module.exports = {
+  up: async (queryInterface, Sequelize) => {
+    await replaceEnum(
+      queryInterface,
+      'Attendances',
+      'status',
+      'waiting',
+      'started',
+      'closed',
+      'transfered',
+      'abandoned',
+      'inactive'
+    )
+  },
+
+  down: async (queryInterface, Sequelize) => {
+    await replaceEnum(
+      queryInterface,
+      'Attendances',
+      'status',
+      'waiting',
+      'started',
+      'closed',
+      'transfered',
+      'abandoned'
+    )
+  },
+}

package/src/migrations/20211020130541-alter-table-session-hasTranship.js

@@ -0,0 +1,14 @@
+'use strict'
+
+module.exports = {
+  up: async (queryInterface, Sequelize) => {
+    await queryInterface.addColumn('Sessions', 'hasTranshipment', {
+      type: Sequelize.BOOLEAN,
+      defaultValue: false,
+      allowNull: false,
+    })
+  },
+  down: async (queryInterface) => {
+    await queryInterface.removeColumn('Sessions', 'hasTranshipment')
+  },
+}

package/src/migrations/20211025155825-create-stopwords.js

@@ -0,0 +1,52 @@
+'use strict'
+
+const models = require('./../models')
+
+module.exports = {
+  up: async (queryInterface, Sequelize) => {
+    await queryInterface.createTable('Stopwords', {
+      id: {
+        allowNull: false,
+        defaultValue: Sequelize.literal('uuid_generate_v4()'),
+        primaryKey: true,
+        type: Sequelize.UUID,
+      },
+      SkillId: {
+        allowNull: true,
+        type: Sequelize.UUID,
+        references: {
+          model: 'Skills',
+          key: 'id',
+        },
+        onDelete: 'SET NULL',
+        onUpdate: 'CASCADE',
+      },
+      EnterpriseId: {
+        allowNull: true,
+        type: Sequelize.UUID,
+        references: {
+          model: 'Enterprises',
+          key: 'id',
+        },
+        onDelete: 'SET NULL',
+        onUpdate: 'CASCADE',
+      },
+      words: {
+        allowNull: false,
+        type: Sequelize.ARRAY(Sequelize.STRING),
+      },
+      createdAt: {
+        allowNull: false,
+        type: Sequelize.DATE,
+      },
+      updatedAt: {
+        allowNull: false,
+        type: Sequelize.DATE,
+      },
+    })
+  },
+
+  down: async (queryInterface) => {
+    await queryInterface.dropTable('Stopwords')
+  },
+}

package/src/models/index.js

@@ -0,0 +1,45 @@
+const fs = require('fs')
+const path = require('path')
+const Sequelize = require('sequelize')
+const basename = path.basename(__filename)
+
+module.exports = (config) => {
+  const db = {}
+  let sequelize
+
+  if (config.use_env_variable) {
+    sequelize = new Sequelize(process.env[config.use_env_variable], config)
+  } else {
+    sequelize = new Sequelize(
+      config.database,
+      config.username,
+      config.password,
+      config
+    )
+  }
+
+  fs.readdirSync(__dirname)
+    .filter((file) => {
+      return (
+        file.indexOf('.') !== 0 && file !== basename && file.slice(-3) === '.js'
+      )
+    })
+    .forEach((file) => {
+      const model = require(path.join(__dirname, file))(
+        sequelize,
+        Sequelize.DataTypes
+      )
+      db[model.name] = model
+    })
+
+  Object.keys(db).forEach((modelName) => {
+    if (db[modelName].associate) {
+      db[modelName].associate(db)
+    }
+  })
+
+  db.sequelize = sequelize
+  db.Sequelize = Sequelize
+
+  return db
+}

package/src/{stopwords.js → models/stopwords.js}

@@ -1,12 +1,6 @@
 
   const StopwordsModel = (sequelize, types) => {
     const Stopwords = sequelize.define('Stopwords', {
-        id: {
-            allowNull: false,
-            defaultValue: types.UUID,
-            primaryKey: true,
-            type: types.UUID,
-          },
           SkillId: {
             allowNull: true,
             type: types.UUID,