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

package/_leanbot_enterprises_map.json

@@ -1,7 +1,7 @@
 [
     {
-        "alias": "leanbot-1",
-        "name": "IT Lean Tech LTDA",
-        "cnpj": "12.082.645/0001-08"
+        "alias": "leanbot-volks",
+        "name": "Volkswagen Brasil",
+        "cnpj": "59.104.422/0001-50"
     }
 ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itleanchatbot/shared-models-js-postgres",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "description": "Shared Models JS Postgres",
   "main": "index.js",
   "license": "ISC",

package/src/migrations/20221004113728-add-indexes.js

@@ -0,0 +1,14 @@
+'use strict'
+
+module.exports = {
+  up: async (queryInterface, _) => {
+    await queryInterface.addIndex('Attendances', {
+      name: 'leanbot_attendances_07',
+      fields: ['EnterpriseId', 'LineId', 'status', 'createdAt']
+    })
+  },
+
+  down: async (queryInterface, _) => {
+    await queryInterface.removeIndex('Attendances', 'leanbot_attendances_07')
+  },
+}

package/src/migrations/20221205131730-add-indexes.js

@@ -0,0 +1,40 @@
+/**
+ * Índices adicionados para fins de performance do processo de inatividade
+ */
+
+'use strict'
+
+module.exports = {
+  up: async (queryInterface, _) => {
+    await queryInterface.addIndex('ConversationSessions', {
+        name: 'leanbot_conversationSessions_04',
+        fields: ['ClientId', 'createdAt']
+    })
+
+    await queryInterface.addIndex('InactivityTriggers', {
+        name: 'leanbot_inactivityTriggers_03',
+        fields: ['SkillId', 'order']
+    })
+
+    await queryInterface.addIndex('Sessions', {
+        name: 'leanbot_sessions_03',
+        fields: ['status', 'tranship', 'createdAt']
+    })
+
+    await queryInterface.addIndex('Channels', {
+        name: 'leanbot_channels_05',
+        fields: ['deletedAt', 'id']
+    })
+  },
+
+  down: async (queryInterface, _) => {
+
+    await queryInterface.removeIndex('Channels', 'leanbot_channels_05')
+
+    await queryInterface.removeIndex('Sessions', 'leanbot_sessions_03')
+
+    await queryInterface.removeIndex('InactivityTriggers', 'leanbot_inactivityTriggers_03')
+
+    await queryInterface.removeIndex('ConversationSessions', 'leanbot_conversationSessions_04')
+  },
+}

package/src/migrations/20221205131730-alter-function.js

@@ -0,0 +1,175 @@
+/**
+ * Função modificada para fins de performance
+ */
+
+'use strict'
+
+module.exports = {
+  up: async (queryInterface, _) => {
+
+    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 distinct 
+                        "Sessions"."id",
+                        "Sessions"."EnterpriseId",
+                        "InactivityTriggers"."min",
+                        "Sessions"."createdAt"
+                    from "Sessions"   
+                        inner join "Clients"
+                        on "Clients"."id" = "Sessions"."ClientId"
+                        inner join "ConversationSessions"
+                        on "ConversationSessions"."ClientId" = "Clients"."id"
+                            and age(current_timestamp, "ConversationSessions"."createdAt") < interval '24 hours'
+                        inner join "Channels"
+                        on "Channels"."id" = "Sessions"."ChannelId"
+                            and "Channels"."deletedAt" is null
+                        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"."EnterpriseId" = r."EnterpriseId"
+                        and "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, _) => {
+    
+    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 distinct 
+                        "Sessions"."id",
+                        "InactivityTriggers"."min",
+                        "Sessions"."createdAt"
+                    from "Sessions"   
+                        inner join "Clients"
+                        on "Clients"."id" = "Sessions"."ClientId"
+                        inner join "ConversationSessions"
+                        on "ConversationSessions"."ClientId" = "Clients"."id"
+                            and age(current_timestamp, "ConversationSessions"."createdAt") < interval '24 hours'
+                        inner join "Channels"
+                        on "Channels"."id" = "Sessions"."ChannelId"
+                        inner join "InactivityTriggers"
+                        on "InactivityTriggers"."SkillId" = "Channels"."SkillId"
+                            and "InactivityTriggers"."order" = "Sessions"."inactivityCounter"
+                    where "Sessions"."status" = 'open'
+                        and "Sessions"."tranship" = false
+                        and "Channels"."deletedAt" is null
+                    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;
+        `
+    )
+  },
+}

package/src/migrations/20221205131731-alter-function.js

@@ -0,0 +1,176 @@
+'use strict'
+
+module.exports = {
+  up: async (queryInterface, _) => {
+
+    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 distinct 
+                        "Sessions"."id",
+                        "Sessions"."EnterpriseId",
+                        "Attendances"."id" as "AttendanceId",
+                        "TranshipInactivityTriggers"."min",
+                        "Sessions"."createdAt"
+                    from "Sessions"
+                        inner join "Clients"
+                        on "Clients"."id" = "Sessions"."ClientId"
+                        inner join "ConversationSessions"
+                        on "ConversationSessions"."ClientId" = "Clients"."id"
+                            and age(current_timestamp, "ConversationSessions"."createdAt") < interval '24 hours'
+                        inner join "Channels"
+                        on "Channels"."id" = "Sessions"."ChannelId"
+                            and "Channels"."deletedAt" is null
+                        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"."EnterpriseId" = r."EnterpriseId"
+                        and "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, _) => {
+    
+    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 distinct 
+                        "Sessions"."id",
+                        "Attendances"."id" as "AttendanceId",
+                        "TranshipInactivityTriggers"."min",
+                        "Sessions"."createdAt"
+                    from "Sessions"
+                        inner join "Clients"
+                        on "Clients"."id" = "Sessions"."ClientId"
+                        inner join "ConversationSessions"
+                        on "ConversationSessions"."ClientId" = "Clients"."id"
+                            and age(current_timestamp, "ConversationSessions"."createdAt") < interval '24 hours'
+                        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;
+        `
+    )
+  },
+}

package/src/migrations/20221205131732-add-indexes.js

@@ -0,0 +1,27 @@
+/**
+ * Índices adicionados para fins de performance do processo de inatividade
+ */
+
+ 'use strict'
+
+module.exports = {
+  up: async (queryInterface, _) => {
+    await queryInterface.addIndex('Attendances', {
+        name: 'leanbot_attendances_08',
+        fields: ['SessionId', 'status']
+    })
+ 
+    await queryInterface.addIndex('TranshipInactivityTriggers', {
+        name: 'leanbot_transhipInactivityTriggers_02',
+        fields: ['LineId', 'order']
+    })
+  },
+ 
+   down: async (queryInterface, _) => {
+ 
+    await queryInterface.removeIndex('TranshipInactivityTriggers', 'leanbot_transhipInactivityTriggers_02')
+ 
+    await queryInterface.removeIndex('Attendances', 'leanbot_attendances_08')
+   },
+}
+ 

package/src/scripts/migrateBotIterables.js

@@ -6,7 +6,11 @@ const { argv } = require('process')
 
 const minDateArg = argv[2]
 const maxDateArg = argv[3]
-const oldDatabaseNameArg = argv[4] 
+const oldDatabaseNameArg = argv[4]
+
+const hostaddr = process.env.DATABASE_HOST
+const user = process.env.DB_USERNAME
+const password = process.env.DB_PASSWORD
 
 function getDatabaseConfig(databaseName) {
     return {
@@ -57,7 +61,7 @@ function runQuery(sequelize, date, EnterpriseId) {
         )
         select *
         from dblink(
-            'dbname=${oldDatabaseNameArg}',
+            'user=${user} password=${password} dbname=${oldDatabaseNameArg}',
             'select ''${EnterpriseId}'',
                 "id",
                 "SessionId",

package/src/scripts/migrateClients.js

@@ -0,0 +1,151 @@
+require('dotenv/config')
+const moment = require('moment')
+const Sequelize = require('sequelize')
+
+const { argv } = require('process')
+
+const minDateArg = argv[2]
+const maxDateArg = argv[3]
+const oldDatabaseNameArg = argv[4] 
+
+const hostaddr = process.env.DATABASE_HOST
+const user = process.env.DB_USERNAME
+const password = process.env.DB_PASSWORD
+
+function getDatabaseConfig(databaseName) {
+    return {
+        username: process.env.DB_USERNAME,
+        password: process.env.DB_PASSWORD,
+        database: databaseName,
+        host: process.env.DATABASE_HOST,
+        dialect: process.env.DATABASE_TYPE,
+        logging: false,
+        omitNull: true,
+        minifyAliases: true,
+        timezone: process.env.DATABASE_TIMEZONE || 'Etc/UTC',
+        pool: {
+            max: 100,
+            min: 0,
+            idle: 10000,
+        },
+    }
+}
+
+function runQuery(sequelize, date, EnterpriseId) {
+    return sequelize.query(
+        `insert into "Clients" (
+            "EnterpriseId",
+            "id",
+            "clientId",
+            "serverId",
+            "createdAt",
+            "updatedAt"
+        )
+        select *
+        from dblink(
+            'user=${user} password=${password} dbname=${oldDatabaseNameArg}',
+            'select ''${EnterpriseId}'',
+                "id",
+                "clientId",
+                "serverId",
+                "createdAt",
+                "updatedAt"
+            from "Clients"
+            where cast("createdAt" as date) = ''${date.format('YYYY-MM-DD')}'''
+        ) as linktable
+            (
+                "EnterpriseId" uuid,
+                "id" uuid,
+                "clientId" varchar(255),
+                "serverId" varchar(255),
+                "createdAt" timestamp with time zone,
+                "updatedAt" timestamp with time zone
+            )`
+    )
+}
+
+async function migrateBotIterables() {
+
+    const oldConfig = getDatabaseConfig(oldDatabaseNameArg)
+    const oldDatabase = new Sequelize(
+        oldConfig.database,
+        oldConfig.username,
+        oldConfig.password,
+        oldConfig
+    )
+
+    const oldEnterpriseModel = require('../legacy/models/enterprises').model(oldDatabase, Sequelize.DataTypes)
+    const { id: EnterpriseId } = await oldEnterpriseModel.findOne()
+
+    const dataInicial = moment(minDateArg, 'YYYY-MM-DD')
+    const dataFinalStr = moment(maxDateArg, 'YYYY-MM-DD').format('YYYY-MM-DD')
+
+    const config = getDatabaseConfig(process.env.DATABASE_NAME)
+
+    const newDatabase = new Sequelize(
+        config.database,
+        config.username,
+        config.password,
+        config
+    )
+
+    while (dataInicial.format('YYYY-MM-DD') <= dataFinalStr) {
+
+        console.log(`MIGRANDO DATA: ${dataInicial.format('YYYY-MM-DD')}`)
+
+        await runQuery(newDatabase, dataInicial, EnterpriseId)
+
+        dataInicial.add(1, 'days')
+    }
+
+    console.log('finalizado')
+}
+
+function executeValidationSequence(readline, sequence, callback, index = 0) {
+    readline.question(`${sequence[index]} (y/n): `, resp => {
+        
+        if (resp.toLowerCase() == 'y') {
+            
+            if (index == sequence.length - 1) { 
+                readline.close()
+                callback()
+            }
+            else executeValidationSequence(readline, sequence, callback, ++index)
+        
+        } else if (resp.toLowerCase() == 'n') {
+            
+            console.log('\nEste processo será encerrado. Reinicie-o após a regularização das configurações\n')
+            readline.close()
+            process.exit()
+        
+        } else {
+            
+            console.log('\nResponsta inválida!')
+            executeValidationSequence(readline, sequence, callback, index)
+        }
+    })
+}
+
+const validationSequence = [
+    `\nEste processo foi iniciado à partir do diretório: ${process.cwd()}\nEstá correto?`,
+    '\nO arquivo .env foi criado e está correto?',
+    `\nA origem desta migração será executada no host ${process.env.DATABASE_HOST}, database ${oldDatabaseNameArg}. Está correto?`,
+    `\nO destino desta migração será executada no host ${process.env.DATABASE_HOST}, database ${process.env.DATABASE_NAME}. Está correto?`,
+    `\nSerão migrados somente os dados da tabela "Clients" de ${minDateArg} à ${maxDateArg}. Está correto?`
+]
+
+async function main() {
+
+    if (minDateArg > maxDateArg) return console.log('Data inicial deve ser inferior ou igual à Data final.')
+    
+    const readline = require('readline').createInterface({
+        input: process.stdin,
+        output: process.stdout
+    })
+
+    console.log('\n*** Antes de iniciar o processo de migração, confirme os dados solicitados abaixo. ***\n')
+
+    executeValidationSequence(readline, validationSequence, migrateBotIterables)
+}
+
+main()