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

package/src/scripts/unification.js

@@ -561,114 +561,114 @@ async function unificate() {
         
             /////////// INTENTIONS /////////////
     
-            console.log('INTENTIONS')
+            // console.log('INTENTIONS')
     
-            const oldIntentionsModel = require('../legacy/models/intention').model(oldDatabase, Sequelize.DataTypes)
-            const oldIntentions = await oldIntentionsModel.findAll()
+            // const oldIntentionsModel = require('../legacy/models/intention').model(oldDatabase, Sequelize.DataTypes)
+            // const oldIntentions = await oldIntentionsModel.findAll()
     
-            const newIntentions = oldIntentions.map(({ dataValues }) => ({
-                ...dataValues,
-                EnterpriseId: oldEnterprise.id
-            }))
+            // const newIntentions = oldIntentions.map(({ dataValues }) => ({
+            //     ...dataValues,
+            //     EnterpriseId: oldEnterprise.id
+            // }))
     
-            const newIntentionsModel = require('../models/intention').model(newDatabase, Sequelize.DataTypes)
-            for (const intention of newIntentions) await newIntentionsModel.create(intention, { transaction })
+            // const newIntentionsModel = require('../models/intention').model(newDatabase, Sequelize.DataTypes)
+            // for (const intention of newIntentions) await newIntentionsModel.create(intention, { transaction })
     
             /////////// INTENTIONVALUES /////////////
     
-            console.log('INTENTIONVALUES')
+            // console.log('INTENTIONVALUES')
     
-            const oldIntentionValuesModel = require('../legacy/models/intentionValue').model(oldDatabase, Sequelize.DataTypes)
-            const oldIntentionValues = await oldIntentionValuesModel.findAll()
+            // const oldIntentionValuesModel = require('../legacy/models/intentionValue').model(oldDatabase, Sequelize.DataTypes)
+            // const oldIntentionValues = await oldIntentionValuesModel.findAll()
     
-            const newIntentionValues = oldIntentionValues.map(({ dataValues }) => ({
-                ...dataValues,
-                EnterpriseId: oldEnterprise.id
-            }))
+            // const newIntentionValues = oldIntentionValues.map(({ dataValues }) => ({
+            //     ...dataValues,
+            //     EnterpriseId: oldEnterprise.id
+            // }))
     
-            const newIntentionValuesModel = require('../models/intentionValue').model(newDatabase, Sequelize.DataTypes)
-            for (const intentionValue of newIntentionValues) await newIntentionValuesModel.create(intentionValue, { transaction })
+            // const newIntentionValuesModel = require('../models/intentionValue').model(newDatabase, Sequelize.DataTypes)
+            // for (const intentionValue of newIntentionValues) await newIntentionValuesModel.create(intentionValue, { transaction })
         
             /////////// ENTITIES /////////////
     
-            console.log('ENTITIES')
+            // console.log('ENTITIES')
     
-            const oldEntitiesModel = require('../legacy/models/entity').model(oldDatabase, Sequelize.DataTypes)
-            const oldEntities = await oldEntitiesModel.findAll()
+            // const oldEntitiesModel = require('../legacy/models/entity').model(oldDatabase, Sequelize.DataTypes)
+            // const oldEntities = await oldEntitiesModel.findAll()
     
-            const newEntities = oldEntities.map(({ dataValues }) => ({
-                ...dataValues,
-                EnterpriseId: oldEnterprise.id
-            }))
+            // const newEntities = oldEntities.map(({ dataValues }) => ({
+            //     ...dataValues,
+            //     EnterpriseId: oldEnterprise.id
+            // }))
     
-            const newEntitiesModel = require('../models/entity').model(newDatabase, Sequelize.DataTypes)
-            for (const entity of newEntities) await newEntitiesModel.create(entity, { transaction })
+            // const newEntitiesModel = require('../models/entity').model(newDatabase, Sequelize.DataTypes)
+            // for (const entity of newEntities) await newEntitiesModel.create(entity, { transaction })
     
             /////////// ENTITYVALUES /////////////
     
-            console.log('ENTITYVALUES')
+            // console.log('ENTITYVALUES')
     
-            const oldEntityValuesModel = require('../legacy/models/entityValues').model(oldDatabase, Sequelize.DataTypes)
-            const oldEntityValues = await oldEntityValuesModel.findAll()
+            // const oldEntityValuesModel = require('../legacy/models/entityValues').model(oldDatabase, Sequelize.DataTypes)
+            // const oldEntityValues = await oldEntityValuesModel.findAll()
     
-            const newEntityValues = oldEntityValues.map(({ dataValues }) => ({
-                ...dataValues,
-                EnterpriseId: oldEnterprise.id
-            }))
+            // const newEntityValues = oldEntityValues.map(({ dataValues }) => ({
+            //     ...dataValues,
+            //     EnterpriseId: oldEnterprise.id
+            // }))
     
-            const newEntityValuesModel = require('../models/entityValues').model(newDatabase, Sequelize.DataTypes)
-            for (const entityValue of newEntityValues) await newEntityValuesModel.create(entityValue, { transaction })
+            // const newEntityValuesModel = require('../models/entityValues').model(newDatabase, Sequelize.DataTypes)
+            // for (const entityValue of newEntityValues) await newEntityValuesModel.create(entityValue, { transaction })
         
             /////////// SYNONYMS /////////////
     
-            console.log('SYNONYMS')
+            // console.log('SYNONYMS')
     
-            const oldSynonymsModel = require('../legacy/models/synonyms').model(oldDatabase, Sequelize.DataTypes)
-            const oldSynonyms = await oldSynonymsModel.findAll()
+            // const oldSynonymsModel = require('../legacy/models/synonyms').model(oldDatabase, Sequelize.DataTypes)
+            // const oldSynonyms = await oldSynonymsModel.findAll()
     
-            const newSynonyms = oldSynonyms.map(({ dataValues }) => ({
-                ...dataValues,
-                EnterpriseId: oldEnterprise.id
-            }))
+            // const newSynonyms = oldSynonyms.map(({ dataValues }) => ({
+            //     ...dataValues,
+            //     EnterpriseId: oldEnterprise.id
+            // }))
     
-            const newSynonymsModel = require('../models/synonyms').model(newDatabase, Sequelize.DataTypes)
-            for (const synonym of newSynonyms) await newSynonymsModel.create(synonym, { transaction })
+            // const newSynonymsModel = require('../models/synonyms').model(newDatabase, Sequelize.DataTypes)
+            // for (const synonym of newSynonyms) await newSynonymsModel.create(synonym, { transaction })
     
             /////////// RESPONSES /////////////
     
-            console.log('RESPONSES')
+            // console.log('RESPONSES')
     
-            const oldResponsesModel = require('../legacy/models/responses').model(oldDatabase, Sequelize.DataTypes)
-            const oldResponses = await oldResponsesModel.findAll()
+            // const oldResponsesModel = require('../legacy/models/responses').model(oldDatabase, Sequelize.DataTypes)
+            // const oldResponses = await oldResponsesModel.findAll()
     
-            const newResponses = oldResponses.map(({ dataValues }) => ({
-                ...dataValues,
-                EnterpriseId: oldEnterprise.id
-            }))
+            // const newResponses = oldResponses.map(({ dataValues }) => ({
+            //     ...dataValues,
+            //     EnterpriseId: oldEnterprise.id
+            // }))
     
-            const newResponsesModel = require('../models/responses').model(newDatabase, Sequelize.DataTypes)
-            for (const response of newResponses) await newResponsesModel.create(response, { transaction })
+            // const newResponsesModel = require('../models/responses').model(newDatabase, Sequelize.DataTypes)
+            // for (const response of newResponses) await newResponsesModel.create(response, { transaction })
     
             /////////// RESPONSESBOXES /////////////
     
-            console.log('RESPONSESBOXES')
+            // console.log('RESPONSESBOXES')
     
-            const oldResponsesBoxesModel = require('../legacy/models/responsesBoxes').model(oldDatabase, Sequelize.DataTypes)
-            const oldResponsesBoxes = await oldResponsesBoxesModel.findAll()
+            // const oldResponsesBoxesModel = require('../legacy/models/responsesBoxes').model(oldDatabase, Sequelize.DataTypes)
+            // const oldResponsesBoxes = await oldResponsesBoxesModel.findAll()
     
-            const newResponsesBoxes = oldResponsesBoxes.map(({ dataValues }) => {
-                const oldChannelType = oldChannelTypes.find(oct => oct.id == dataValues.ChannelTypeId)
-                const newChannelType = newChannelTypes.find(nct => nct.channelName == oldChannelType.channelName)
-                return {
-                    ...dataValues,
-                    ChannelTypeId: newChannelType.id,
-                    EnterpriseId: oldEnterprise.id,
-                    payload: JSON.parse(dataValues.payload)
-                }
-            })
+            // const newResponsesBoxes = oldResponsesBoxes.map(({ dataValues }) => {
+            //     const oldChannelType = oldChannelTypes.find(oct => oct.id == dataValues.ChannelTypeId)
+            //     const newChannelType = newChannelTypes.find(nct => nct.channelName == oldChannelType.channelName)
+            //     return {
+            //         ...dataValues,
+            //         ChannelTypeId: newChannelType.id,
+            //         EnterpriseId: oldEnterprise.id,
+            //         payload: JSON.parse(dataValues.payload)
+            //     }
+            // })
     
-            const newResponsesBoxesModel = require('../models/responsesBoxes').model(newDatabase, Sequelize.DataTypes)
-            for (const responseBox of newResponsesBoxes) await newResponsesBoxesModel.create(responseBox, { transaction })
+            // const newResponsesBoxesModel = require('../models/responsesBoxes').model(newDatabase, Sequelize.DataTypes)
+            // for (const responseBox of newResponsesBoxes) await newResponsesBoxesModel.create(responseBox, { transaction })
     
             /////////// OPENFAQS /////////////
     
@@ -802,41 +802,41 @@ async function unificate() {
         
             /////////// CLIENTS /////////////
     
-            console.log('CLIENTS')
+            // console.log('CLIENTS')
     
-            console.log('Migrando Clientes')
+            // console.log('Migrando Clientes')
     
-            const oldClientsModel = require('../legacy/models/client').model(oldDatabase, Sequelize.DataTypes)
-            const oldClientsCount = await oldClientsModel.count({
-                order: [['createdAt', 'ASC']]
-            })
+            // const oldClientsModel = require('../legacy/models/client').model(oldDatabase, Sequelize.DataTypes)
+            // const oldClientsCount = await oldClientsModel.count({
+            //     order: [['createdAt', 'ASC']]
+            // })
     
-            const newClientsModel = require('../models/client').model(newDatabase, Sequelize.DataTypes)
+            // const newClientsModel = require('../models/client').model(newDatabase, Sequelize.DataTypes)
     
-            console.log('total de clientes:', oldClientsCount)
+            // console.log('total de clientes:', oldClientsCount)
     
-            const pages = Math.ceil(oldClientsCount / 5000)
+            // const pages = Math.ceil(oldClientsCount / 5000)
     
-            console.log('total de páginas:', pages)
+            // console.log('total de páginas:', pages)
     
-            for (let i = 0; i < pages; i++) {
+            // for (let i = 0; i < pages; i++) {
     
-                console.log(`processando: página ${i + 1} de ${pages}`)
+            //     console.log(`processando: página ${i + 1} de ${pages}`)
     
-                const offset = i * 5000
+            //     const offset = i * 5000
     
-                const oldClients = await oldClientsModel.findAll({
-                    order: [['createdAt', 'ASC']],
-                    offset, limit: 5000
-                })
+            //     const oldClients = await oldClientsModel.findAll({
+            //         order: [['createdAt', 'ASC']],
+            //         offset, limit: 5000
+            //     })
     
-                const newClients = oldClients.map(({ dataValues }) => ({
-                    ...dataValues,
-                    EnterpriseId: oldEnterprise.id
-                }))
+            //     const newClients = oldClients.map(({ dataValues }) => ({
+            //         ...dataValues,
+            //         EnterpriseId: oldEnterprise.id
+            //     }))
     
-                for (const client of newClients) await newClientsModel.create(client, { transaction })
-            }
+            //     for (const client of newClients) await newClientsModel.create(client, { transaction })
+            // }
 
             /////////// PUBLICATIONS /////////////
 
@@ -891,41 +891,41 @@ async function unificate() {
 
             /////////// SESSIONS /////////////
     
-            console.log('SESSIONS')
+            // console.log('SESSIONS')
     
-            console.log('Migrando Sessões')
+            // console.log('Migrando Sessões')
     
-            const oldSessionsModel = require('../legacy/models/sessions').model(oldDatabase, Sequelize.DataTypes)
-            const oldSessionsCount = await oldSessionsModel.count({
-                order: [['createdAt', 'ASC']]
-            })
+            // const oldSessionsModel = require('../legacy/models/sessions').model(oldDatabase, Sequelize.DataTypes)
+            // const oldSessionsCount = await oldSessionsModel.count({
+            //     order: [['createdAt', 'ASC']]
+            // })
     
-            const newSessionsModel = require('../models/sessions').model(newDatabase, Sequelize.DataTypes)
+            // const newSessionsModel = require('../models/sessions').model(newDatabase, Sequelize.DataTypes)
     
-            console.log('total de sessões:', oldSessionsCount)
+            // console.log('total de sessões:', oldSessionsCount)
     
-            const pagesSessions = Math.ceil(oldSessionsCount / 5000)
+            // const pagesSessions = Math.ceil(oldSessionsCount / 5000)
     
-            console.log('total de páginas:', pagesSessions)
+            // console.log('total de páginas:', pagesSessions)
     
-            for (let i = 0; i < pagesSessions; i++) {
+            // for (let i = 0; i < pagesSessions; i++) {
     
-                console.log(`processando: página ${i + 1} de ${pagesSessions}`)
+            //     console.log(`processando: página ${i + 1} de ${pagesSessions}`)
     
-                const offset = i * 5000
+            //     const offset = i * 5000
     
-                const oldSessions = await oldSessionsModel.findAll({
-                    order: [['createdAt', 'ASC']],
-                    offset, limit: 5000
-                })
+            //     const oldSessions = await oldSessionsModel.findAll({
+            //         order: [['createdAt', 'ASC']],
+            //         offset, limit: 5000
+            //     })
     
-                const newSessions = oldSessions.map(({ dataValues }) => ({
-                    ...dataValues,
-                    EnterpriseId: oldEnterprise.id
-                }))
+            //     const newSessions = oldSessions.map(({ dataValues }) => ({
+            //         ...dataValues,
+            //         EnterpriseId: oldEnterprise.id
+            //     }))
     
-                for (const session of newSessions) await newSessionsModel.create(session, { transaction })
-            }
+            //     for (const session of newSessions) await newSessionsModel.create(session, { transaction })
+            // }
             
             /////////// SESSIONSPREREPORTS /////////////
 
@@ -954,120 +954,120 @@ async function unificate() {
 
             /////////// CONVERSATIONSESSIONS /////////////
 
-            console.log('CONVERSATIONSESSIONS')
+            // console.log('CONVERSATIONSESSIONS')
 
-            const oldConversationSessionsModel = require('../legacy/models/conversationSessions').model(oldDatabase, Sequelize.DataTypes)
-            const oldConversationSessionsCount = await oldConversationSessionsModel.count({
-                order: [['createdAt', 'ASC']]
-            })
+            // const oldConversationSessionsModel = require('../legacy/models/conversationSessions').model(oldDatabase, Sequelize.DataTypes)
+            // const oldConversationSessionsCount = await oldConversationSessionsModel.count({
+            //     order: [['createdAt', 'ASC']]
+            // })
 
-            const newConversationSessionsModel = require('../models/conversationSessions').model(newDatabase, Sequelize.DataTypes)
+            // const newConversationSessionsModel = require('../models/conversationSessions').model(newDatabase, Sequelize.DataTypes)
             
-            console.log('total de CONVERSATIONSESSIONS:', oldConversationSessionsCount)
+            // console.log('total de CONVERSATIONSESSIONS:', oldConversationSessionsCount)
 
-            const pagesConversationSessions = Math.ceil(oldConversationSessionsCount / 1000)
+            // const pagesConversationSessions = Math.ceil(oldConversationSessionsCount / 1000)
             
-            console.log('total de páginas:', pagesConversationSessions)
+            // console.log('total de páginas:', pagesConversationSessions)
 
-            for (let i = 0; i < pagesConversationSessions; i++) {
+            // for (let i = 0; i < pagesConversationSessions; i++) {
 
-                console.log(`processando: página ${i + 1} de ${pagesConversationSessions}`)
+            //     console.log(`processando: página ${i + 1} de ${pagesConversationSessions}`)
             
-                const offset = i * 1000
-
-                const oldConversationSessions = await oldConversationSessionsModel.findAll({
-                    attributes: { exclude: ['id'] },
-                    order: [['createdAt', 'ASC']],
-                    offset, limit: 1000
-                })
-
-                const newConversationSessions = oldConversationSessions.map(({ dataValues }) => {
-                    const { channelName } = oldChannelTypes.find(oct => oct.id == dataValues.ChannelTypeId)
-                    const { id } = newChannelTypes.find(nct => nct.channelName == channelName)
-                    return {
-                        ...dataValues,
-                        ChannelTypeId: id,
-                        EnterpriseId: oldEnterprise.id,
-                    }
-                })
-
-                console.log('inserindo registros...')
-                await newConversationSessionsModel.bulkCreate(newConversationSessions, { transaction })
-            }
+            //     const offset = i * 1000
+
+            //     const oldConversationSessions = await oldConversationSessionsModel.findAll({
+            //         attributes: { exclude: ['id'] },
+            //         order: [['createdAt', 'ASC']],
+            //         offset, limit: 1000
+            //     })
+
+            //     const newConversationSessions = oldConversationSessions.map(({ dataValues }) => {
+            //         const { channelName } = oldChannelTypes.find(oct => oct.id == dataValues.ChannelTypeId)
+            //         const { id } = newChannelTypes.find(nct => nct.channelName == channelName)
+            //         return {
+            //             ...dataValues,
+            //             ChannelTypeId: id,
+            //             EnterpriseId: oldEnterprise.id,
+            //         }
+            //     })
+
+            //     console.log('inserindo registros...')
+            //     await newConversationSessionsModel.bulkCreate(newConversationSessions, { transaction })
+            // }
 
             /////////// DIALOGNODES /////////////
     
-            console.log('DIALOGNODES')
+            // console.log('DIALOGNODES')
     
-            const oldDialogNodesModel = require('../legacy/models/dialogNodes').model(oldDatabase, Sequelize.DataTypes)
-            const oldDialogNodesCount = await oldDialogNodesModel.count({
-                order: [['isMultipleResponse'], ['SkillId'], ['DialogNodeFolderId'], ['step']]
-            })
+            // const oldDialogNodesModel = require('../legacy/models/dialogNodes').model(oldDatabase, Sequelize.DataTypes)
+            // const oldDialogNodesCount = await oldDialogNodesModel.count({
+            //     order: [['isMultipleResponse'], ['SkillId'], ['DialogNodeFolderId'], ['step']]
+            // })
     
-            const newDialogNodesModel = require('../models/dialogNodes').model(newDatabase, Sequelize.DataTypes)
+            // const newDialogNodesModel = require('../models/dialogNodes').model(newDatabase, Sequelize.DataTypes)
     
-            console.log('total de nós:', oldDialogNodesCount)
+            // console.log('total de nós:', oldDialogNodesCount)
     
-            const pagesDialogNodes = Math.ceil(oldDialogNodesCount / 5000)
+            // const pagesDialogNodes = Math.ceil(oldDialogNodesCount / 5000)
     
-            console.log('total de páginas:', pagesDialogNodes)
+            // console.log('total de páginas:', pagesDialogNodes)
     
-            for (let i = 0; i < pagesDialogNodes; i++) {
+            // for (let i = 0; i < pagesDialogNodes; i++) {
     
-                console.log(`processando: página ${i + 1} de ${pagesDialogNodes}`)
+            //     console.log(`processando: página ${i + 1} de ${pagesDialogNodes}`)
     
-                const offset = i * 5000
+            //     const offset = i * 5000
     
-                const oldDialogNodes = await oldDialogNodesModel.findAll({
-                    order: [['isMultipleResponse'], ['SkillId'], ['DialogNodeFolderId'], ['step']],
-                    offset, limit: 5000
-                })
+            //     const oldDialogNodes = await oldDialogNodesModel.findAll({
+            //         order: [['isMultipleResponse'], ['SkillId'], ['DialogNodeFolderId'], ['step']],
+            //         offset, limit: 5000
+            //     })
     
-                const newDialogNodes = oldDialogNodes.map(({ dataValues }) => ({
-                    ...dataValues,
-                    EnterpriseId: oldEnterprise.id
-                }))
+            //     const newDialogNodes = oldDialogNodes.map(({ dataValues }) => ({
+            //         ...dataValues,
+            //         EnterpriseId: oldEnterprise.id
+            //     }))
     
-                for (const dialogNode of newDialogNodes) await newDialogNodesModel.create(dialogNode, { transaction })
-            }
+            //     for (const dialogNode of newDialogNodes) await newDialogNodesModel.create(dialogNode, { transaction })
+            // }
 
             /////////// DIALOGNODESPREREPORTS /////////////
 
-            console.log('DIALOGNODESPREREPORTS')
+            // console.log('DIALOGNODESPREREPORTS')
 
-            const oldDialogNodesPreReportsModel = require('../legacy/models/dialogNodesPreReports').model(oldDatabase, Sequelize.DataTypes)
-            const oldDialogNodesPreReportsCount = await oldDialogNodesPreReportsModel.count({
-                order: [['createdAt', 'ASC']]
-            })
+            // const oldDialogNodesPreReportsModel = require('../legacy/models/dialogNodesPreReports').model(oldDatabase, Sequelize.DataTypes)
+            // const oldDialogNodesPreReportsCount = await oldDialogNodesPreReportsModel.count({
+            //     order: [['createdAt', 'ASC']]
+            // })
 
-            const newDialogNodesPreReportsModel = require('../models/dialogNodesPreReports').model(newDatabase, Sequelize.DataTypes)
+            // const newDialogNodesPreReportsModel = require('../models/dialogNodesPreReports').model(newDatabase, Sequelize.DataTypes)
             
-            console.log('total de DIALOGNODESPREREPORTS:', oldDialogNodesPreReportsCount)
+            // console.log('total de DIALOGNODESPREREPORTS:', oldDialogNodesPreReportsCount)
 
-            const pagesDialogNodesPreReports = Math.ceil(oldDialogNodesPreReportsCount / 1000)
+            // const pagesDialogNodesPreReports = Math.ceil(oldDialogNodesPreReportsCount / 1000)
             
-            console.log('total de páginas:', pagesDialogNodesPreReports)
+            // console.log('total de páginas:', pagesDialogNodesPreReports)
 
-            for (let i = 0; i < pagesDialogNodesPreReports; i++) {
+            // for (let i = 0; i < pagesDialogNodesPreReports; i++) {
 
-                console.log(`processando: página ${i + 1} de ${pagesDialogNodesPreReports}`)
+            //     console.log(`processando: página ${i + 1} de ${pagesDialogNodesPreReports}`)
             
-                const offset = i * 1000
+            //     const offset = i * 1000
 
-                const oldDialogNodesPreReports = await oldDialogNodesPreReportsModel.findAll({
-                    attributes: { exclude: ['id'] },
-                    order: [['createdAt', 'ASC']],
-                    offset, limit: 1000
-                })
+            //     const oldDialogNodesPreReports = await oldDialogNodesPreReportsModel.findAll({
+            //         attributes: { exclude: ['id'] },
+            //         order: [['createdAt', 'ASC']],
+            //         offset, limit: 1000
+            //     })
 
-                const newDialogNodesPreReports = oldDialogNodesPreReports.map(({ dataValues }) => ({
-                    ...dataValues,
-                    EnterpriseId: oldEnterprise.id,
-                }))
+            //     const newDialogNodesPreReports = oldDialogNodesPreReports.map(({ dataValues }) => ({
+            //         ...dataValues,
+            //         EnterpriseId: oldEnterprise.id,
+            //     }))
 
-                console.log('inserindo registros...')
-                await newDialogNodesPreReportsModel.bulkCreate(newDialogNodesPreReports, { transaction })
-            }
+            //     console.log('inserindo registros...')
+            //     await newDialogNodesPreReportsModel.bulkCreate(newDialogNodesPreReports, { transaction })
+            // }
 
             /////////// DIALOGNODES_APIRESOURCES /////////////
     
@@ -1105,71 +1105,71 @@ async function unificate() {
 
             /////////// DIALOGNODES_MULTIPLERESPONSES /////////////
     
-            console.log('DIALOGNODES_MULTIPLERESPONSES')
+            // console.log('DIALOGNODES_MULTIPLERESPONSES')
     
-            const oldDialogNodes_MultipleResponsesModel = require('../legacy/models/dialogNodes_MultipleResponses').model(oldDatabase, Sequelize.DataTypes)
-            const oldDialogNodes_MultipleResponsesCount = await oldDialogNodes_MultipleResponsesModel.count({
-                order: [['createdAt', 'ASC']]
-            })
+            // const oldDialogNodes_MultipleResponsesModel = require('../legacy/models/dialogNodes_MultipleResponses').model(oldDatabase, Sequelize.DataTypes)
+            // const oldDialogNodes_MultipleResponsesCount = await oldDialogNodes_MultipleResponsesModel.count({
+            //     order: [['createdAt', 'ASC']]
+            // })
     
-            const newDialogNodes_MultipleResponsesModel = require('../models/dialogNodes_MultipleResponses').model(newDatabase, Sequelize.DataTypes)
+            // const newDialogNodes_MultipleResponsesModel = require('../models/dialogNodes_MultipleResponses').model(newDatabase, Sequelize.DataTypes)
     
-            console.log('total de nós:', oldDialogNodes_MultipleResponsesCount)
+            // console.log('total de nós:', oldDialogNodes_MultipleResponsesCount)
     
-            const pagesDialogNodes_MultipleResponses = Math.ceil(oldDialogNodes_MultipleResponsesCount / 1000)
+            // const pagesDialogNodes_MultipleResponses = Math.ceil(oldDialogNodes_MultipleResponsesCount / 1000)
     
-            console.log('total de páginas:', pagesDialogNodes_MultipleResponses)
+            // console.log('total de páginas:', pagesDialogNodes_MultipleResponses)
     
-            for (let i = 0; i < pagesDialogNodes_MultipleResponses; i++) {
+            // for (let i = 0; i < pagesDialogNodes_MultipleResponses; i++) {
     
-                console.log(`processando: página ${i + 1} de ${pagesDialogNodes_MultipleResponses}`)
+            //     console.log(`processando: página ${i + 1} de ${pagesDialogNodes_MultipleResponses}`)
     
-                const offset = i * 1000
+            //     const offset = i * 1000
     
-                const oldDialogNodes_MultipleResponses = await oldDialogNodes_MultipleResponsesModel.findAll({
-                    attributes: { exclude: ['id'] },
-                    order: [['createdAt', 'ASC']],
-                    offset, limit: 1000
-                })
+            //     const oldDialogNodes_MultipleResponses = await oldDialogNodes_MultipleResponsesModel.findAll({
+            //         attributes: { exclude: ['id'] },
+            //         order: [['createdAt', 'ASC']],
+            //         offset, limit: 1000
+            //     })
 
-                const newDialogNodes_MultipleResponses = oldDialogNodes_MultipleResponses.map(({ dataValues }) => dataValues)
+            //     const newDialogNodes_MultipleResponses = oldDialogNodes_MultipleResponses.map(({ dataValues }) => dataValues)
     
-                await newDialogNodes_MultipleResponsesModel.bulkCreate(newDialogNodes_MultipleResponses, { transaction })
-            }
+            //     await newDialogNodes_MultipleResponsesModel.bulkCreate(newDialogNodes_MultipleResponses, { transaction })
+            // }
 
             /////////// DIALOGNODES_MULTIPLERESPONSES /////////////
     
-            console.log('RESPONSE_DIALOGNODES')
+            // console.log('RESPONSE_DIALOGNODES')
     
-            const oldResponse_DialogNodesModel = require('../legacy/models/response_DialogNodes').model(oldDatabase, Sequelize.DataTypes)
-            const oldResponse_DialogNodesCount = await oldResponse_DialogNodesModel.count({
-                order: [['DialogNodeId'], ['order'], ['createdAt']]
-            })
+            // const oldResponse_DialogNodesModel = require('../legacy/models/response_DialogNodes').model(oldDatabase, Sequelize.DataTypes)
+            // const oldResponse_DialogNodesCount = await oldResponse_DialogNodesModel.count({
+            //     order: [['DialogNodeId'], ['order'], ['createdAt']]
+            // })
     
-            const newResponse_DialogNodesModel = require('../models/response_DialogNodes').model(newDatabase, Sequelize.DataTypes)
+            // const newResponse_DialogNodesModel = require('../models/response_DialogNodes').model(newDatabase, Sequelize.DataTypes)
     
-            console.log('total de nós:', oldResponse_DialogNodesCount)
+            // console.log('total de nós:', oldResponse_DialogNodesCount)
     
-            const pagesResponse_DialogNodes = Math.ceil(oldResponse_DialogNodesCount / 1000)
+            // const pagesResponse_DialogNodes = Math.ceil(oldResponse_DialogNodesCount / 1000)
     
-            console.log('total de páginas:', pagesResponse_DialogNodes)
+            // console.log('total de páginas:', pagesResponse_DialogNodes)
     
-            for (let i = 0; i < pagesResponse_DialogNodes; i++) {
+            // for (let i = 0; i < pagesResponse_DialogNodes; i++) {
     
-                console.log(`processando: página ${i + 1} de ${pagesResponse_DialogNodes}`)
+            //     console.log(`processando: página ${i + 1} de ${pagesResponse_DialogNodes}`)
     
-                const offset = i * 1000
+            //     const offset = i * 1000
     
-                const oldResponse_DialogNodes = await oldResponse_DialogNodesModel.findAll({
-                    attributes: { exclude: ['id'] },
-                    order: [['DialogNodeId'], ['order'], ['createdAt']],
-                    offset, limit: 1000
-                })
+            //     const oldResponse_DialogNodes = await oldResponse_DialogNodesModel.findAll({
+            //         attributes: { exclude: ['id'] },
+            //         order: [['DialogNodeId'], ['order'], ['createdAt']],
+            //         offset, limit: 1000
+            //     })
 
-                const newResponse_DialogNodes = oldResponse_DialogNodes.map(({ dataValues }) => dataValues)
+            //     const newResponse_DialogNodes = oldResponse_DialogNodes.map(({ dataValues }) => dataValues)
     
-                await newResponse_DialogNodesModel.bulkCreate(newResponse_DialogNodes, { transaction })
-            }
+            //     await newResponse_DialogNodesModel.bulkCreate(newResponse_DialogNodes, { transaction })
+            // }
 
             /////////// TRANSHIPTRIGGERS /////////////
             
@@ -1330,40 +1330,40 @@ async function unificate() {
 
             /////////// TRANSHIPCONVERSATIONS /////////////
     
-            console.log('TRANSHIPCONVERSATIONS')
+            // console.log('TRANSHIPCONVERSATIONS')
     
-            const oldTranshipConversationsModel = require('../legacy/models/transhipConversations').model(oldDatabase, Sequelize.DataTypes)
-            const oldTranshipConversationsCount = await oldTranshipConversationsModel.count({
-                order: [['AttendanceId'], ['action'], ['createdAt']]
-            })
+            // const oldTranshipConversationsModel = require('../legacy/models/transhipConversations').model(oldDatabase, Sequelize.DataTypes)
+            // const oldTranshipConversationsCount = await oldTranshipConversationsModel.count({
+            //     order: [['AttendanceId'], ['action'], ['createdAt']]
+            // })
     
-            const newTranshipConversationsModel = require('../models/transhipConversations').model(newDatabase, Sequelize.DataTypes)
+            // const newTranshipConversationsModel = require('../models/transhipConversations').model(newDatabase, Sequelize.DataTypes)
     
-            console.log('total de mensagens:', oldTranshipConversationsCount)
+            // console.log('total de mensagens:', oldTranshipConversationsCount)
     
-            const pagesTranshipConversations = Math.ceil(oldTranshipConversationsCount / 1000)
+            // const pagesTranshipConversations = Math.ceil(oldTranshipConversationsCount / 1000)
     
-            console.log('total de páginas:', pagesTranshipConversations)
+            // console.log('total de páginas:', pagesTranshipConversations)
     
-            for (let i = 0; i < pagesTranshipConversations; i++) {
+            // for (let i = 0; i < pagesTranshipConversations; i++) {
     
-                console.log(`processando: página ${i + 1} de ${pagesTranshipConversations}`)
+            //     console.log(`processando: página ${i + 1} de ${pagesTranshipConversations}`)
     
-                const offset = i * 1000
+            //     const offset = i * 1000
     
-                const oldTranshipConversations = await oldTranshipConversationsModel.findAll({
-                    attributes: { exclude: ['id'] },
-                    order: [['AttendanceId'], ['action'], ['createdAt']],
-                    offset, limit: 1000
-                })
+            //     const oldTranshipConversations = await oldTranshipConversationsModel.findAll({
+            //         attributes: { exclude: ['id'] },
+            //         order: [['AttendanceId'], ['action'], ['createdAt']],
+            //         offset, limit: 1000
+            //     })
 
-                const newTranshipConversations = oldTranshipConversations.map(({ dataValues }) => ({
-                    ...dataValues,
-                    EnterpriseId: oldEnterprise.id
-                }))
+            //     const newTranshipConversations = oldTranshipConversations.map(({ dataValues }) => ({
+            //         ...dataValues,
+            //         EnterpriseId: oldEnterprise.id
+            //     }))
     
-                await newTranshipConversationsModel.bulkCreate(newTranshipConversations, { transaction })
-            }
+            //     await newTranshipConversationsModel.bulkCreate(newTranshipConversations, { transaction })
+            // }
 
             /////////// BLACKLISTCONTACTS /////////////