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

package/src/scripts/unification.js

@@ -0,0 +1,1434 @@
+require('dotenv/config')
+const Sequelize = require('sequelize')
+
+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 loadEnterprisesMap() {
+    
+    const cwd = process.cwd()
+    
+    try {
+        
+        const map = require(`${cwd}/_leanbot_enterprises_map.json`)
+        
+        return map
+    
+    } catch(error) {
+
+        console.log(`\n* Não foi possível carregar arquivo de mapeamento de Empresas!`)
+        console.log(`* Diretório pesquisado: ${cwd}`)
+        console.log(`* Arquivo esperado: _leanbot_enterprises_map.json\n`)
+
+        console.error(error)
+
+        return null
+    }
+}
+
+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)
+        }
+    })
+}
+
+async function unificate() {
+
+    const map = loadEnterprisesMap()
+    
+    if (!map) return
+
+    const newConfig = getDatabaseConfig(process.env.DATABASE_NAME)
+
+    const newDatabase = new Sequelize(
+        newConfig.database,
+        newConfig.username,
+        newConfig.password,
+        newConfig
+    )
+    
+    for (const enterprise of map) {
+
+        const transaction = await newDatabase.transaction()
+
+        try {
+
+            console.log(`\n\n*** MIGRANDO: ${enterprise.alias} ***\n\n`)
+
+            const oldConfig = getDatabaseConfig(enterprise.alias)
+
+            const oldDatabase = new Sequelize(
+                oldConfig.database,
+                oldConfig.username,
+                oldConfig.password,
+                oldConfig
+            )
+
+            /////// ENTERPRISES //////////
+    
+            console.log('ENTERPRISES')
+    
+            const oldEnterpriseModel = require('../legacy/models/enterprises').model(oldDatabase, Sequelize.DataTypes)
+            const oldEnterprise = await oldEnterpriseModel.findOne()
+    
+            const NewEnterpriseModel = require('../models/enterprises').model(newDatabase, Sequelize.DataTypes)
+    
+            await NewEnterpriseModel.create({
+                id: oldEnterprise.id,
+                alias: enterprise.alias,
+                name: enterprise.name,
+                cnpj: enterprise.cnpj,
+                createdAt: oldEnterprise.createdAt,
+                updatedAt: oldEnterprise.updatedAt
+            }, { transaction })
+    
+            /////////// SYSTEMUSERS | PROFILES /////////////
+    
+            console.log('SYSTEMUSERS | PROFILES')
+    
+            const oldSystemUsersModel = require('../legacy/models/systemUsers').model(oldDatabase, Sequelize.DataTypes)
+            const oldProfilesModel = require('../legacy/models/profile').model(oldDatabase, Sequelize.DataTypes)
+            const oldSystemUsers_ProfilesModel = require('../legacy/models/systemUsers_profiles').model(oldDatabase, Sequelize.DataTypes)
+            
+            oldSystemUsersModel.belongsToMany(oldProfilesModel, {
+                through: oldSystemUsers_ProfilesModel,
+            })
+    
+            const systemUsers = await oldSystemUsersModel.findAll({
+                include: [
+                    {
+                        model: oldProfilesModel,
+                        required: true
+                    }
+                ]
+            })
+            
+            const newSystemUsersModel = require('../models/systemUsers').model(newDatabase, Sequelize.DataTypes)
+            const newProfilesModel = require('../models/profile').model(newDatabase, Sequelize.DataTypes)
+            const newSystemUsers_ProfilesModel = require('../models/systemUsers_profiles').model(newDatabase, Sequelize.DataTypes)
+            for (const systemUser of systemUsers) { 
+                await newSystemUsersModel.create(systemUser.dataValues, { transaction })
+                for (const profile of systemUser.Profiles) {
+                    const newProfile = await newProfilesModel.findOne({ where: { name: profile.name } })
+                    if (!newProfile) console.warn(`CLIENTE: ${enterprise.alias} | USUÁRIO: ${systemUser.id} | PERFIL: ${profile.name} | SEM CORRESPONDÊNCIA NO NOVO BANCO DE DADOS!`)
+                    else await newSystemUsers_ProfilesModel.create({
+                        SystemUserId: systemUser.id,
+                        ProfileId: newProfile.id
+                    }, { transaction })
+                }
+            }
+    
+            /////////// BRANCHES /////////////
+    
+            console.log('BRANCHES')
+    
+            const oldBranchesModel = require('../legacy/models/branches').model(oldDatabase, Sequelize.DataTypes)
+            const oldBranches = await oldBranchesModel.findAll()
+    
+            const newBranchesModel = require('../models/branches').model(newDatabase, Sequelize.DataTypes)
+            for (const branch of oldBranches) await newBranchesModel.create(branch.dataValues, { transaction })
+    
+            /////////// DEPARTMENTS /////////////
+    
+            console.log('DEPARTMENTS')
+    
+            const oldDepartmentsModel = require('../legacy/models/departments').model(oldDatabase, Sequelize.DataTypes)
+            const oldDepartments = await oldDepartmentsModel.findAll()
+    
+            const newDepartmentsModel = require('../models/departments').model(newDatabase, Sequelize.DataTypes)
+            for (const department of oldDepartments) await newDepartmentsModel.create(department.dataValues, { transaction })
+    
+            /////////// SUBDEPARTMENTS /////////////
+    
+            console.log('SUBDEPARTMENTS')
+    
+            const oldSubDepartmentsModel = require('../legacy/models/subDepartments').model(oldDatabase, Sequelize.DataTypes)
+            const oldSubDepartments = await oldSubDepartmentsModel.findAll()
+    
+            const newSubDepartmentsModel = require('../models/subDepartments').model(newDatabase, Sequelize.DataTypes)
+            for (const subDepartment of oldSubDepartments) await newSubDepartmentsModel.create(subDepartment.dataValues, { transaction })
+        
+            /////////// LINES /////////////
+    
+            console.log('LINES')
+    
+            const oldLinesModel = require('../legacy/models/lines').model(oldDatabase, Sequelize.DataTypes)
+            const oldLines = await oldLinesModel.findAll()
+    
+            const newLines = oldLines.map(({ dataValues }) => ({
+                EnterpriseId: oldEnterprise.id,
+                ...dataValues
+            }))
+    
+            const newLinesModel = require('../models/lines').model(newDatabase, Sequelize.DataTypes)
+            for (const line of newLines) await newLinesModel.create(line, { transaction })
+    
+            /////////// SYSTEMUSERS X LINES /////////////
+    
+            console.log('SYSTEMUSERS X LINES')
+    
+            const oldSystemUsers_LinesModel = require('../legacy/models/systemUsers_Lines').model(oldDatabase, Sequelize.DataTypes)
+            const oldSystemUsers_Lines = await oldSystemUsers_LinesModel.findAll()
+    
+            const newSystemUsers_LinesModel = require('../models/systemUsers_Lines').model(newDatabase, Sequelize.DataTypes)
+            for (const systemUser_Line of oldSystemUsers_Lines) await newSystemUsers_LinesModel.create(systemUser_Line.dataValues, { transaction })
+        
+            /////////// APIKEYS /////////////
+    
+            console.log('APIKEYS')
+    
+            const oldApiKeysModel = require('../legacy/models/apiKeys').model(oldDatabase, Sequelize.DataTypes)
+            const oldApiKey = await oldApiKeysModel.findOne({ where: { EnterpriseId: oldEnterprise.id } })
+    
+            if (!oldApiKey) console.warn(`CLIENTE: ${enterprise.alias} | APIKEY NÃO ENCONTRADA!`)
+            else {
+                const newApiKeysModel = require('../models/apiKeys').model(newDatabase, Sequelize.DataTypes)
+                await newApiKeysModel.create(oldApiKey.dataValues, { transaction })
+            }
+    
+            /////////// CUSTOMPOSTBACKS /////////////
+    
+            console.log('CUSTOMPOSTBACKS')
+    
+            const oldCustomPostbacksModel = require('../legacy/models/customPostbacks').model(oldDatabase, Sequelize.DataTypes)
+            const oldCustomPostback = await oldCustomPostbacksModel.findOne({ where: { EnterpriseId: oldEnterprise.id } })
+    
+            if (oldCustomPostback) {
+                
+                const newCustomPostbacksModel = require('../models/customPostbacks').model(newDatabase, Sequelize.DataTypes)
+                await newCustomPostbacksModel.create(oldCustomPostback.dataValues, { transaction })
+            }
+    
+            /////////// LINECONFIGURATIONS /////////////
+    
+            console.log('LINECONFIGURATIONS')
+    
+            const oldLineConfigurationsModel = require('../legacy/models/lineConfigurations').model(oldDatabase, Sequelize.DataTypes)
+            const oldLineConfigurations = await oldLineConfigurationsModel.findAll()
+            const newLineConfigurations = oldLineConfigurations.map(({ dataValues }) => ({
+                EnterpriseId: oldEnterprise.id,
+                ...dataValues
+            }))
+    
+            const newLineConfigurationsModel = require('../models/lineConfigurations').model(newDatabase, Sequelize.DataTypes)
+            for (const lineConfiguration of newLineConfigurations) await newLineConfigurationsModel.create(lineConfiguration, { transaction })
+        
+            /////////// ATTENDANCESCALES /////////////
+    
+            console.log('ATTENDANCESCALES')
+    
+            const oldAttendanceScalesModel = require('../legacy/models/attendanceScale').model(oldDatabase, Sequelize.DataTypes)
+            const oldAttendanceScales = await oldAttendanceScalesModel.findAll()
+    
+            const newAttendanceScalesModel = require('../models/attendanceScale').model(newDatabase, Sequelize.DataTypes)
+            for (const attendanceScale of oldAttendanceScales) await newAttendanceScalesModel.create(attendanceScale.dataValues, { transaction })
+    
+            /////////// ATTENDANCESCALEOFFS /////////////
+    
+            console.log('ATTENDANCESCALEOFFS')
+    
+            const oldAttendanceScaleOffsModel = require('../legacy/models/attendanceScaleOff').model(oldDatabase, Sequelize.DataTypes)
+            const oldAttendanceScaleOffs = await oldAttendanceScaleOffsModel.findAll()
+    
+            const newAttendanceScaleOffsModel = require('../models/attendanceScaleOff').model(newDatabase, Sequelize.DataTypes)
+            for (const attendanceScaleOff of oldAttendanceScaleOffs) await newAttendanceScaleOffsModel.create(attendanceScaleOff.dataValues, { transaction })
+        
+            /////////// QUICKMESSAGES /////////////
+    
+            console.log('QUICKMESSAGES')
+    
+            const oldQuickMessagesModel = require('../legacy/models/quickMessages').model(oldDatabase, Sequelize.DataTypes)
+            const oldQuickMessages = await oldQuickMessagesModel.findAll()
+            const quickMessages = oldQuickMessages.map(({ dataValues }) => ({
+                EnterpriseId: oldEnterprise.id,
+                ...dataValues
+            }))
+    
+            const newQuickMessagesModel = require('../models/quickMessages').model(newDatabase, Sequelize.DataTypes)
+            for (const quickMessage of quickMessages) await newQuickMessagesModel.create(quickMessage, { transaction })
+        
+            /////////// TRANSHIPINACTIVITYTRIGGERS /////////////
+    
+            console.log('TRANSHIPINACTIVITYTRIGGERS')
+    
+            const oldTranshipInactivityTriggersModel = require('../legacy/models/transhipInactivityTriggers').model(oldDatabase, Sequelize.DataTypes)
+            const oldTranshipInactivityTriggers = await oldTranshipInactivityTriggersModel.findAll()
+            const transhipInactivityTriggers = oldTranshipInactivityTriggers.map(({ dataValues }) => ({
+                EnterpriseId: oldEnterprise.id,
+                ...dataValues
+            }))
+    
+            const newTranshipInactivityTriggersModel = require('../models/transhipInactivityTriggers').model(newDatabase, Sequelize.DataTypes)
+            for (const transhipInactivityTrigger of transhipInactivityTriggers) await newTranshipInactivityTriggersModel.create(transhipInactivityTrigger, { transaction })
+        
+            /////////// CONTACTS /////////////
+    
+            console.log('CONTACTS')
+    
+            const oldContactsModel = require('../legacy/models/contacts').model(oldDatabase, Sequelize.DataTypes)
+            const oldContacts = await oldContactsModel.findAll()
+    
+            const newContactsModel = require('../models/contacts').model(newDatabase, Sequelize.DataTypes)
+            for (const contact of oldContacts) await newContactsModel.create(contact.dataValues, { transaction })
+    
+            /////////// GROUPS /////////////
+    
+            console.log('GROUPS')
+    
+            const oldGroupsModel = require('../legacy/models/groups').model(oldDatabase, Sequelize.DataTypes)
+            const oldGroups = await oldGroupsModel.findAll()
+    
+            const newGroupsModel = require('../models/groups').model(newDatabase, Sequelize.DataTypes)
+            for (const group of oldGroups) await newGroupsModel.create(group.dataValues, { transaction })
+    
+            /////////// GROUPSCONTACTS /////////////
+    
+            console.log('GROUPSCONTACTS')
+    
+            const oldGroupsContactsModel = require('../legacy/models/groupsContracts').model(oldDatabase, Sequelize.DataTypes)
+            const oldGroupsContacts = await oldGroupsContactsModel.findAll()
+    
+            const newGroupsContactsModel = require('../models/groupsContracts').model(newDatabase, Sequelize.DataTypes)
+            for (const groupContact of oldGroupsContacts) await newGroupsContactsModel.create(groupContact.dataValues, { transaction })
+    
+            /////////// FIELDS /////////////
+    
+            console.log('FIELDS')
+    
+            const oldFieldsModel = require('../legacy/models/fields').model(oldDatabase, Sequelize.DataTypes)
+            const oldFields = await oldFieldsModel.findAll()
+    
+            const newFieldsModel = require('../models/fields').model(newDatabase, Sequelize.DataTypes)
+            for (const field of oldFields) await newFieldsModel.create(field.dataValues, { transaction })
+    
+            /////////////////////////////////////////////////////////
+            /////////// ITLEANPROVIDERS N' IBMPROVIDERS /////////////
+            /////////////////////////////////////////////////////////        
+    
+            const newIntelligencesFile = require('../models/intelligence')
+            const newIntelligencesModel = newIntelligencesFile.model(newDatabase, Sequelize.DataTypes)
+    
+            /////////// ITLEANPROVIDERS /////////////
+    
+            console.log('ITLEANPROVIDERS')
+    
+            const oldITLeanProvidersModel = require('../legacy/models/itleanProvider').model(oldDatabase, Sequelize.DataTypes)
+            const oldITLeanProviders = await oldITLeanProvidersModel.findAll()
+            
+            const newItleanIntelligence = await newIntelligencesModel.findOne({
+                where: {
+                    name: 'LeanNLP',
+                    providerType: newIntelligencesFile.PROVIDER_TYPES.ITLEAN
+                }
+            })
+    
+            if (newItleanIntelligence) {
+                
+                const newITLeanProviders = oldITLeanProviders.map(({ dataValues }) => ({
+                    ...dataValues,
+                    IntelligenceId: newItleanIntelligence.id
+                }))
+    
+                const newITLeanProvidersModel = require('../models/itleanProvider').model(newDatabase, Sequelize.DataTypes)
+            
+                for (const itleanProvider of newITLeanProviders) await newITLeanProvidersModel.create(itleanProvider, { transaction })
+            
+            } else console.warn(`IA: LeanNLP | SEM CORRESPONDÊNCIA NO NOVO BANCO DE DADOS!`)
+    
+            /////////// IBMPROVIDERS /////////////
+    
+            console.log('IBMPROVIDERS')
+    
+            const oldIBMProvidersModel = require('../legacy/models/ibmProvider').model(oldDatabase, Sequelize.DataTypes)
+            const oldIBMProviders = await oldIBMProvidersModel.findAll()
+            
+            const newIbmIntelligence = await newIntelligencesModel.findOne({
+                where: {
+                    name: 'Watson Assistant',
+                    providerType: newIntelligencesFile.PROVIDER_TYPES.IBM
+                }
+            })
+    
+            if (newIbmIntelligence) {
+                
+                const newIBMProviders = oldIBMProviders.map(({ dataValues }) => ({
+                    ...dataValues,
+                    IntelligenceId: newIbmIntelligence.id
+                }))
+    
+                const newIBMProvidersModel = require('../models/ibmProvider').model(newDatabase, Sequelize.DataTypes)
+            
+                for (const ibmProvider of newIBMProviders) await newIBMProvidersModel.create(ibmProvider, { transaction })
+            
+            } else console.warn(`IA: Watson Assistant | SEM CORRESPONDÊNCIA NO NOVO BANCO DE DADOS!`)
+        
+            /////////// SKILLS /////////////
+    
+            console.log('SKILLS')
+    
+            const oldSkillsModel = require('../legacy/models/skill').model(oldDatabase, Sequelize.DataTypes)
+            const oldIntelligencesModel = require('../legacy/models/intelligence').model(oldDatabase, Sequelize.DataTypes)
+            
+            oldSkillsModel.belongsTo(oldIntelligencesModel)
+    
+            const oldSkills = await oldSkillsModel.findAll({
+                include: [
+                    {
+                        model: oldIntelligencesModel,
+                        required: true
+                    }
+                ]
+            })
+    
+            const newIntelligenceIds = {
+                [newIntelligencesFile.PROVIDER_TYPES.ITLEAN]: newItleanIntelligence.id,
+                [newIntelligencesFile.PROVIDER_TYPES.IBM]: newIbmIntelligence.id
+            }
+    
+            const newSkills = oldSkills.map(skill => {
+                return {
+                    ...skill.dataValues,
+                    EnterpriseId: oldEnterprise.id,
+                    IntelligenceId: newIntelligenceIds[skill.Intelligence.providerType]
+                }
+            })
+    
+            const newSkillsModel = require('../models/skill').model(newDatabase, Sequelize.DataTypes)
+            for (const skill of newSkills) await newSkillsModel.create(skill, { transaction })
+    
+            /////////// FILES /////////////
+    
+            console.log('FILES')
+    
+            const oldFilesModel = require('../legacy/models/files').model(oldDatabase, Sequelize.DataTypes)
+            const oldFiles = await oldFilesModel.findAll()
+    
+            const newFilesModel = require('../models/files').model(newDatabase, Sequelize.DataTypes)
+            for (const file of oldFiles) await newFilesModel.create(file.dataValues, { transaction })
+    
+            /////////// CHANNELS /////////////
+    
+            console.log('CHANNELS')
+    
+            const oldChannelsModel = require('../legacy/models/channels').model(oldDatabase, Sequelize.DataTypes)
+            const oldChannelTypesModel = require('../legacy/models/channelTypes').model(oldDatabase, Sequelize.DataTypes)
+            oldChannelsModel.belongsTo(oldChannelTypesModel)
+    
+            const oldChannels = await oldChannelsModel.findAll({
+                include: [
+                    {
+                        model: oldChannelTypesModel,
+                        required: true
+                    }
+                ]
+            })
+    
+            const newChannelTypesModel = require('../models/channelTypes').model(newDatabase, Sequelize.DataTypes)
+            const newChannelTypes = await newChannelTypesModel.findAll()
+    
+            const newChannels = oldChannels.map(oldChannel => ({
+                ...oldChannel.dataValues,
+                EnterpriseId: oldEnterprise.id,
+                ChannelTypeId: (newChannelTypes.find(nct => nct.channelName == oldChannel.ChannelType.channelName)).id
+            }))
+    
+            const newChannelsModel = require('../models/channels').model(newDatabase, Sequelize.DataTypes)
+    
+            for(const channel of newChannels) await newChannelsModel.create(channel, { transaction })
+    
+            /////////// MESSAGESHSMS /////////////
+    
+            console.log('MESSAGESHSMS')
+    
+            const oldMessagesHsmsModel = require('../legacy/models/messagesHsm').model(oldDatabase, Sequelize.DataTypes)
+            const oldTemplatesModel = require('../legacy/models/templates').model(oldDatabase, Sequelize.DataTypes)
+            
+            oldMessagesHsmsModel.belongsTo(oldTemplatesModel)
+            oldMessagesHsmsModel.belongsToMany(oldChannelsModel, {
+                through: 'MessagesHsmChannels',
+                as: 'Channels',
+            })
+    
+            const oldMessagesHsms = await oldMessagesHsmsModel.findAll({
+                include: [
+                    {
+                        model: oldTemplatesModel,
+                        required: true
+                    },
+                    {
+                        model: oldChannelsModel,
+                        required: true,
+                        as: 'Channels'
+                    }
+                ]
+            })
+    
+            const oldChannelTypes = await oldChannelTypesModel.findAll()
+    
+            const newTemplatesModel = require('../models/templates').model(newDatabase, Sequelize.DataTypes)
+            const newTemplates = await newTemplatesModel.findAll()
+    
+            const newMessagesHsms = oldMessagesHsms.map(oHsm => {
+                
+                const oldChannelTypeId = oHsm.Template.ChannelTypeId
+    
+                const oldChannelType = oldChannelTypes.find(oct => oct.id == oldChannelTypeId)
+                
+                const newChannelType = newChannelTypes.find(nct => nct.channelName == oldChannelType.channelName)
+    
+                const oldTemplate = oHsm.Template.title
+    
+                const newTemplate = newTemplates.find(nt => nt.title == oldTemplate && nt.ChannelTypeId == newChannelType.id)
+    
+                return {
+                    message: {
+                        ...oHsm.dataValues,
+                        TemplateId: newTemplate.id,
+                    },
+                    message_channel: {
+                        ChannelId: oHsm.Channels[0].id,
+                        MessagesHsmId: oHsm.id
+                    }
+                }
+            })
+    
+            const newMessagesHsmsModel = require('../models/messagesHsm').model(newDatabase, Sequelize.DataTypes)
+            const newMessagesHsms_ChannelsModel = require('../models/messagesHsms_Channels').model(newDatabase, Sequelize.DataTypes)
+            for (messageHsm of newMessagesHsms) { 
+                await newMessagesHsmsModel.create(messageHsm.message, { transaction })
+                await newMessagesHsms_ChannelsModel.create(messageHsm.message_channel, { transaction })
+            }
+    
+            /////////// SENDHSMS /////////////
+    
+            console.log('SENDHSMS')
+    
+            const oldSendHsmsModel = require('../legacy/models/sendHsm').model(oldDatabase, Sequelize.DataTypes)
+            const oldSendHsms = await oldSendHsmsModel.findAll()
+    
+            const newSendHsms = oldSendHsms.map(({ dataValues }) => ({
+                ...dataValues,
+                MessagesHsmId: dataValues.messageId
+            }))
+    
+            const newSendHsmsModel = require('../models/sendHsm').model(newDatabase, Sequelize.DataTypes)
+            for (const sendHsm of newSendHsms) await newSendHsmsModel.create(sendHsm, { transaction })
+    
+            /////////// GROUPSSENDHSMS /////////////
+    
+            console.log('GROUPSSENDHSMS')
+    
+            const oldGroupsSendHsmsModel = require('../legacy/models/groupsSendHsms').model(oldDatabase, Sequelize.DataTypes)
+            const oldGroupsSendHsms = await oldGroupsSendHsmsModel.findAll()
+    
+            const newdGroupsSendHsmsModel = require('../models/groupsSendHsms').model(newDatabase, Sequelize.DataTypes)
+            for (const groupSendHsm of oldGroupsSendHsms) await newdGroupsSendHsmsModel.create(groupSendHsm.dataValues, { transaction })
+        
+            /////////// INTENTIONS /////////////
+    
+            console.log('INTENTIONS')
+    
+            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 newIntentionsModel = require('../models/intention').model(newDatabase, Sequelize.DataTypes)
+            for (const intention of newIntentions) await newIntentionsModel.create(intention, { transaction })
+    
+            /////////// INTENTIONVALUES /////////////
+    
+            console.log('INTENTIONVALUES')
+    
+            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 newIntentionValuesModel = require('../models/intentionValue').model(newDatabase, Sequelize.DataTypes)
+            for (const intentionValue of newIntentionValues) await newIntentionValuesModel.create(intentionValue, { transaction })
+        
+            /////////// ENTITIES /////////////
+    
+            console.log('ENTITIES')
+    
+            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 newEntitiesModel = require('../models/entity').model(newDatabase, Sequelize.DataTypes)
+            for (const entity of newEntities) await newEntitiesModel.create(entity, { transaction })
+    
+            /////////// ENTITYVALUES /////////////
+    
+            console.log('ENTITYVALUES')
+    
+            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 newEntityValuesModel = require('../models/entityValues').model(newDatabase, Sequelize.DataTypes)
+            for (const entityValue of newEntityValues) await newEntityValuesModel.create(entityValue, { transaction })
+        
+            /////////// SYNONYMS /////////////
+    
+            console.log('SYNONYMS')
+    
+            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 newSynonymsModel = require('../models/synonyms').model(newDatabase, Sequelize.DataTypes)
+            for (const synonym of newSynonyms) await newSynonymsModel.create(synonym, { transaction })
+    
+            /////////// RESPONSES /////////////
+    
+            console.log('RESPONSES')
+    
+            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 newResponsesModel = require('../models/responses').model(newDatabase, Sequelize.DataTypes)
+            for (const response of newResponses) await newResponsesModel.create(response, { transaction })
+    
+            /////////// RESPONSESBOXES /////////////
+    
+            console.log('RESPONSESBOXES')
+    
+            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 newResponsesBoxesModel = require('../models/responsesBoxes').model(newDatabase, Sequelize.DataTypes)
+            for (const responseBox of newResponsesBoxes) await newResponsesBoxesModel.create(responseBox, { transaction })
+    
+            /////////// OPENFAQS /////////////
+    
+            console.log('OPENFAQS')
+    
+            const oldOpenFaqsModel = require('../legacy/models/openFaqs').model(oldDatabase, Sequelize.DataTypes)
+            const oldOpenFaqs = await oldOpenFaqsModel.findAll()
+    
+            const newdOpenFaqs = oldOpenFaqs.map(({ dataValues }) => ({
+                ...dataValues,
+                EnterpriseId: oldEnterprise.id
+            }))
+    
+            const newOpenFaqsModel = require('../models/openFaqs').model(newDatabase, Sequelize.DataTypes)
+            for (const openFaqs of newdOpenFaqs) await newOpenFaqsModel.create(openFaqs, { transaction })
+    
+            /////////// FAQQUESTIONS /////////////
+    
+            console.log('FAQQUESTIONS')
+    
+            const oldFaqQuestionsModel = require('../legacy/models/faqQuestions').model(oldDatabase, Sequelize.DataTypes)
+            const oldFaqQuestions = await oldFaqQuestionsModel.findAll()
+    
+            const newFaqQuestions = oldFaqQuestions.map(({ dataValues }) => ({
+                ...dataValues,
+                EnterpriseId: oldEnterprise.id
+            }))
+    
+            const newFaqQuestionsModel = require('../models/faqQuestions').model(newDatabase, Sequelize.DataTypes)
+            for (const faqQuestion of newFaqQuestions) await newFaqQuestionsModel.create(faqQuestion, { transaction })
+        
+            /////////// APIS /////////////
+    
+            console.log('APIS')
+    
+            const oldApisModel = require('../legacy/models/apis').model(oldDatabase, Sequelize.DataTypes)
+            const oldApis = await oldApisModel.findAll()
+    
+            const newApisModel = require('../models/apis').model(newDatabase, Sequelize.DataTypes)
+            for (const api of oldApis) await newApisModel.create(api.dataValues, { transaction })
+        
+            /////////// APIRESOURCESBODIES /////////////
+    
+            console.log('APIRESOURCESBODIES')
+    
+            const oldApiResourcesBodiesModel = require('../legacy/models/apiResourceBodies').model(oldDatabase, Sequelize.DataTypes)
+            const oldApiResourcesBodies = await oldApiResourcesBodiesModel.findAll()
+    
+            const newApiResourcesBodies = oldApiResourcesBodies.map(({ dataValues }) => ({
+                ...dataValues,
+                EnterpriseId: oldEnterprise.id
+            }))
+    
+            const newApiResourcesBodiesModel = require('../models/apiResourceBodies').model(newDatabase, Sequelize.DataTypes)
+            for (const resourceBody of newApiResourcesBodies) await newApiResourcesBodiesModel.create(resourceBody, { transaction })
+    
+            /////////// APIRESOURCES /////////////
+    
+            console.log('APIRESOURCES')
+    
+            const oldApiResourcesModel = require('../legacy/models/apiResources').model(oldDatabase, Sequelize.DataTypes)
+            const oldApiResources = await oldApiResourcesModel.findAll()
+    
+            const newApiResources = oldApiResources.map(({ dataValues }) => ({
+                ...dataValues,
+                EnterpriseId: oldEnterprise.id
+            }))
+    
+            const newApiResourcesModel = require('../models/apiResources').model(newDatabase, Sequelize.DataTypes)
+            for (const resource of newApiResources) await newApiResourcesModel.create(resource, { transaction })
+    
+            /////////// APIPREREQUESTS /////////////
+    
+            console.log('APIPREREQUESTS')
+    
+            const oldApiPreRequestsModel = require('../legacy/models/apiPreRequest').model(oldDatabase, Sequelize.DataTypes)
+            const oldApiPreRequests = await oldApiPreRequestsModel.findAll()
+    
+            const newApiPreRequests = oldApiPreRequests.map(({ dataValues }) => ({
+                ...dataValues,
+                EnterpriseId: oldEnterprise.id
+            }))
+    
+            const newApiPreRequestsModel = require('../models/apiPreRequest').model(newDatabase, Sequelize.DataTypes)
+            for (const preRequest of newApiPreRequests) await newApiPreRequestsModel.create(preRequest, { transaction })
+    
+            /////////// APIRESOURCESHEADERS /////////////
+    
+            console.log('APIRESOURCESHEADERS')
+    
+            const oldApiResourcesHeadersModel = require('../legacy/models/apiResourceHeaders').model(oldDatabase, Sequelize.DataTypes)
+            const oldApiResourcesHeaders = await oldApiResourcesHeadersModel.findAll()
+    
+            const newApiResourcesHeaders = oldApiResourcesHeaders.map(({ dataValues }) => ({
+                ...dataValues,
+                EnterpriseId: oldEnterprise.id
+            }))
+    
+            const newApiResourcesHeadersModel = require('../models/apiResourceHeaders').model(newDatabase, Sequelize.DataTypes)
+            for (const header of newApiResourcesHeaders) await newApiResourcesHeadersModel.create(header, { transaction })
+    
+            /////////// APIRESOURCESPATHPARAMS /////////////
+    
+            console.log('APIRESOURCESPATHPARAMS')
+    
+            const oldApiResourcesPathParamsModel = require('../legacy/models/apiResourcePathParams').model(oldDatabase, Sequelize.DataTypes)
+            const oldApiResourcesPathParams = await oldApiResourcesPathParamsModel.findAll()
+    
+            const newApiResourcesPathParams = oldApiResourcesPathParams.map(({ dataValues }) => ({
+                ...dataValues,
+                EnterpriseId: oldEnterprise.id
+            }))
+    
+            const newApiResourcesPathParamsModel = require('../models/apiResourcePathParams').model(newDatabase, Sequelize.DataTypes)
+            for (const pathParam of newApiResourcesPathParams) await newApiResourcesPathParamsModel.create(pathParam, { transaction })
+    
+            /////////// APIRESOURCESQUERYSTRINGPARAMS /////////////
+    
+            console.log('APIRESOURCESQUERYSTRINGPARAMS')
+    
+            const oldApiResourcesQueryStringParamsModel = require('../legacy/models/apiResourceQueryStringParams').model(oldDatabase, Sequelize.DataTypes)
+            const oldApiResourcesQueryStringParams = await oldApiResourcesQueryStringParamsModel.findAll()
+    
+            const newApiResourcesQueryStringParams = oldApiResourcesQueryStringParams.map(({ dataValues }) => ({
+                ...dataValues,
+                EnterpriseId: oldEnterprise.id
+            }))
+    
+            const newApiResourcesQueryStringParamsModel = require('../models/apiResourceQueryStringParams').model(newDatabase, Sequelize.DataTypes)
+            for (const queryString of newApiResourcesQueryStringParams) await newApiResourcesQueryStringParamsModel.create(queryString, { transaction })
+        
+            /////////// CLIENTS /////////////
+    
+            console.log('CLIENTS')
+    
+            console.log('Migrando Clientes')
+    
+            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)
+    
+            console.log('total de clientes:', oldClientsCount)
+    
+            const pages = Math.ceil(oldClientsCount / 5000)
+    
+            console.log('total de páginas:', pages)
+    
+            for (let i = 0; i < pages; i++) {
+    
+                console.log(`processando: página ${i + 1} de ${pages}`)
+    
+                const offset = i * 5000
+    
+                const oldClients = await oldClientsModel.findAll({
+                    order: [['createdAt', 'ASC']],
+                    offset, limit: 5000
+                })
+    
+                const newClients = oldClients.map(({ dataValues }) => ({
+                    ...dataValues,
+                    EnterpriseId: oldEnterprise.id
+                }))
+    
+                for (const client of newClients) await newClientsModel.create(client, { transaction })
+            }
+
+            /////////// PUBLICATIONS /////////////
+
+            console.log('PUBLICATIONS')
+
+            const oldPublicationsModel = require('../legacy/models/publications').model(oldDatabase, Sequelize.DataTypes)
+            const oldPublications = await oldPublicationsModel.findAll()
+    
+            const newPublications = oldPublications.map(({ dataValues }) => ({
+                ...dataValues,
+                EnterpriseId: oldEnterprise.id
+            }))
+    
+            const newPublicationsModel = require('../models/publications').model(newDatabase, Sequelize.DataTypes)
+            for (const publication of newPublications) await newPublicationsModel.create(publication, { transaction })
+
+            /////////// SENDHSMRETURNHSMS /////////////
+    
+            console.log('SENDHSMRETURNHSMS')
+    
+            console.log('Migrando SENDHSMRETURNHSMS')
+    
+            const oldSendHsmReturHsmsModel = require('../legacy/models/sendHsmReturnHsm').model(oldDatabase, Sequelize.DataTypes)
+            const oldSendHsmReturHsmsCount = await oldSendHsmReturHsmsModel.count({
+                order: [['createdAt', 'ASC']]
+            })
+    
+            const newSendHsmReturHsmsModel = require('../models/sendHsmReturnHsm').model(newDatabase, Sequelize.DataTypes)
+    
+            console.log('total de SENDHSMRETURNHSMS:', oldSendHsmReturHsmsCount)
+    
+            const pagesSendHsmReturHsms = Math.ceil(oldSendHsmReturHsmsCount / 1000)
+    
+            console.log('total de páginas:', pagesSendHsmReturHsms)
+    
+            for (let i = 0; i < pagesSendHsmReturHsms; i++) {
+    
+                console.log(`processando: página ${i + 1} de ${pagesSendHsmReturHsms}`)
+    
+                const offset = i * 1000
+    
+                const oldSendHsmReturHsms = await oldSendHsmReturHsmsModel.findAll({
+                    attributes: { exclude: ['id'] },
+                    order: [['createdAt', 'ASC']],
+                    offset, limit: 1000
+                })
+    
+                const newSendHsmReturHsms = oldSendHsmReturHsms.map(({ dataValues }) => dataValues)
+                console.log('inserindo registros...')
+                await newSendHsmReturHsmsModel.bulkCreate(newSendHsmReturHsms, { transaction })
+            }
+
+            /////////// SESSIONS /////////////
+    
+            console.log('SESSIONS')
+    
+            console.log('Migrando Sessões')
+    
+            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)
+    
+            console.log('total de sessões:', oldSessionsCount)
+    
+            const pagesSessions = Math.ceil(oldSessionsCount / 5000)
+    
+            console.log('total de páginas:', pagesSessions)
+    
+            for (let i = 0; i < pagesSessions; i++) {
+    
+                console.log(`processando: página ${i + 1} de ${pagesSessions}`)
+    
+                const offset = i * 5000
+    
+                const oldSessions = await oldSessionsModel.findAll({
+                    order: [['createdAt', 'ASC']],
+                    offset, limit: 5000
+                })
+    
+                const newSessions = oldSessions.map(({ dataValues }) => ({
+                    ...dataValues,
+                    EnterpriseId: oldEnterprise.id
+                }))
+    
+                for (const session of newSessions) await newSessionsModel.create(session, { transaction })
+            }
+            
+            /////////// SESSIONSPREREPORTS /////////////
+
+            console.log('SESSIONSPREREPORTS')
+
+            const oldSessionsPreReportsModel = require('../legacy/models/sessionsPreReports').model(oldDatabase, Sequelize.DataTypes)
+            const oldSessionsPreReports = await oldSessionsPreReportsModel.findAll()
+    
+            const newSessionsPreReports = oldSessionsPreReports.map(({ dataValues }) => ({
+                ...dataValues,
+                EnterpriseId: oldEnterprise.id
+            }))
+    
+            const newSessionsPreReportsModel = require('../models/sessionsPreReports').model(newDatabase, Sequelize.DataTypes)
+            for (const preReport of newSessionsPreReports) await newSessionsPreReportsModel.create(preReport, { transaction })
+
+            /////////// STOPWORDS /////////////
+
+            console.log('STOPWORDS')
+
+            const oldStopwordsModel = require('../legacy/models/stopwords').model(oldDatabase, Sequelize.DataTypes)
+            const oldStopwords = await oldStopwordsModel.findAll()
+    
+            const newStopwordsModel = require('../models/stopwords').model(newDatabase, Sequelize.DataTypes)
+            for (const stopword of oldStopwords) await newStopwordsModel.create(stopword.dataValues, { transaction })
+
+            /////////// CONVERSATIONSESSIONS /////////////
+
+            console.log('CONVERSATIONSESSIONS')
+
+            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)
+            
+            console.log('total de CONVERSATIONSESSIONS:', oldConversationSessionsCount)
+
+            const pagesConversationSessions = Math.ceil(oldConversationSessionsCount / 1000)
+            
+            console.log('total de páginas:', pagesConversationSessions)
+
+            for (let i = 0; i < pagesConversationSessions; i++) {
+
+                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 })
+            }
+
+            /////////// 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 newDialogNodesModel = require('../models/dialogNodes').model(newDatabase, Sequelize.DataTypes)
+    
+            console.log('total de nós:', oldDialogNodesCount)
+    
+            const pagesDialogNodes = Math.ceil(oldDialogNodesCount / 5000)
+    
+            console.log('total de páginas:', pagesDialogNodes)
+    
+            for (let i = 0; i < pagesDialogNodes; i++) {
+    
+                console.log(`processando: página ${i + 1} de ${pagesDialogNodes}`)
+    
+                const offset = i * 5000
+    
+                const oldDialogNodes = await oldDialogNodesModel.findAll({
+                    order: [['isMultipleResponse'], ['SkillId'], ['DialogNodeFolderId'], ['step']],
+                    offset, limit: 5000
+                })
+    
+                const newDialogNodes = oldDialogNodes.map(({ dataValues }) => ({
+                    ...dataValues,
+                    EnterpriseId: oldEnterprise.id
+                }))
+    
+                for (const dialogNode of newDialogNodes) await newDialogNodesModel.create(dialogNode, { transaction })
+            }
+
+            /////////// DIALOGNODESPREREPORTS /////////////
+
+            console.log('DIALOGNODESPREREPORTS')
+
+            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)
+            
+            console.log('total de DIALOGNODESPREREPORTS:', oldDialogNodesPreReportsCount)
+
+            const pagesDialogNodesPreReports = Math.ceil(oldDialogNodesPreReportsCount / 1000)
+            
+            console.log('total de páginas:', pagesDialogNodesPreReports)
+
+            for (let i = 0; i < pagesDialogNodesPreReports; i++) {
+
+                console.log(`processando: página ${i + 1} de ${pagesDialogNodesPreReports}`)
+            
+                const offset = i * 1000
+
+                const oldDialogNodesPreReports = await oldDialogNodesPreReportsModel.findAll({
+                    attributes: { exclude: ['id'] },
+                    order: [['createdAt', 'ASC']],
+                    offset, limit: 1000
+                })
+
+                const newDialogNodesPreReports = oldDialogNodesPreReports.map(({ dataValues }) => ({
+                    ...dataValues,
+                    EnterpriseId: oldEnterprise.id,
+                }))
+
+                console.log('inserindo registros...')
+                await newDialogNodesPreReportsModel.bulkCreate(newDialogNodesPreReports, { transaction })
+            }
+
+            /////////// DIALOGNODES_APIRESOURCES /////////////
+    
+            console.log('DIALOGNODES_APIRESOURCES')
+    
+            const oldDialogNodes_ApiResourcesModel = require('../legacy/models/dialogNodes_apiResources').model(oldDatabase, Sequelize.DataTypes)
+            const oldDialogNodes_ApiResourcesCount = await oldDialogNodes_ApiResourcesModel.count({
+                order: [['createdAt', 'ASC']]
+            })
+    
+            const newDialogNodes_ApiResourcesModel = require('../models/dialogNodes_apiResources').model(newDatabase, Sequelize.DataTypes)
+    
+            console.log('total de nós:', oldDialogNodes_ApiResourcesCount)
+    
+            const pagesDialogNodes_ApiResources = Math.ceil(oldDialogNodes_ApiResourcesCount / 1000)
+    
+            console.log('total de páginas:', pagesDialogNodes_ApiResources)
+    
+            for (let i = 0; i < pagesDialogNodes_ApiResources; i++) {
+    
+                console.log(`processando: página ${i + 1} de ${pagesDialogNodes_ApiResources}`)
+    
+                const offset = i * 1000
+    
+                const oldDialogNodes_ApiResources = await oldDialogNodes_ApiResourcesModel.findAll({
+                    attributes: { exclude: ['id'] },
+                    order: [['createdAt', 'ASC']],
+                    offset, limit: 1000
+                })
+
+                const newDialogNodes_ApiResources = oldDialogNodes_ApiResources.map(({ dataValues }) => dataValues)
+    
+                await newDialogNodes_ApiResourcesModel.bulkCreate(newDialogNodes_ApiResources, { transaction })
+            }
+
+            /////////// 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 newDialogNodes_MultipleResponsesModel = require('../models/dialogNodes_MultipleResponses').model(newDatabase, Sequelize.DataTypes)
+    
+            console.log('total de nós:', oldDialogNodes_MultipleResponsesCount)
+    
+            const pagesDialogNodes_MultipleResponses = Math.ceil(oldDialogNodes_MultipleResponsesCount / 1000)
+    
+            console.log('total de páginas:', pagesDialogNodes_MultipleResponses)
+    
+            for (let i = 0; i < pagesDialogNodes_MultipleResponses; i++) {
+    
+                console.log(`processando: página ${i + 1} de ${pagesDialogNodes_MultipleResponses}`)
+    
+                const offset = i * 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)
+    
+                await newDialogNodes_MultipleResponsesModel.bulkCreate(newDialogNodes_MultipleResponses, { transaction })
+            }
+
+            /////////// DIALOGNODES_MULTIPLERESPONSES /////////////
+    
+            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 newResponse_DialogNodesModel = require('../models/response_DialogNodes').model(newDatabase, Sequelize.DataTypes)
+    
+            console.log('total de nós:', oldResponse_DialogNodesCount)
+    
+            const pagesResponse_DialogNodes = Math.ceil(oldResponse_DialogNodesCount / 1000)
+    
+            console.log('total de páginas:', pagesResponse_DialogNodes)
+    
+            for (let i = 0; i < pagesResponse_DialogNodes; i++) {
+    
+                console.log(`processando: página ${i + 1} de ${pagesResponse_DialogNodes}`)
+    
+                const offset = i * 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)
+    
+                await newResponse_DialogNodesModel.bulkCreate(newResponse_DialogNodes, { transaction })
+            }
+
+            /////////// TRANSHIPTRIGGERS /////////////
+            
+            console.log('TRANSHIPTRIGGERS')
+
+            const oldTranshipTriggersModel = require('../legacy/models/transhipTriggers').model(oldDatabase, Sequelize.DataTypes)
+            const oldTranshipTriggers = await oldTranshipTriggersModel.findAll()
+    
+            const newTranshipTriggersModel = require('../models/transhipTriggers').model(newDatabase, Sequelize.DataTypes)
+            for (const TranshipTrigger of oldTranshipTriggers) await newTranshipTriggersModel.create(TranshipTrigger.dataValues, { transaction })
+
+            /////////// ATTENDANCES /////////////
+    
+            console.log('ATTENDANCES')
+    
+            console.log('Migrando ATTENDANCES')
+    
+            const oldAttendancesModel = require('../legacy/models/attendances').model(oldDatabase, Sequelize.DataTypes)
+            const oldAttendancesCount = await oldAttendancesModel.count({
+                order: [['LineId'], ['createdAt']]
+            })
+    
+            const newAttendancesModel = require('../models/attendances').model(newDatabase, Sequelize.DataTypes)
+    
+            console.log('total de atendimentos:', oldAttendancesCount)
+    
+            const pagesAttendances = Math.ceil(oldAttendancesCount / 5000)
+    
+            console.log('total de páginas:', pagesAttendances)
+    
+            for (let i = 0; i < pagesAttendances; i++) {
+    
+                console.log(`processando: página ${i + 1} de ${pagesAttendances}`)
+    
+                const offset = i * 5000
+    
+                const oldAttendances = await oldAttendancesModel.findAll({
+                    order: [['LineId'], ['createdAt']],
+                    offset, limit: 5000
+                })
+    
+                const newAttendances = oldAttendances.map(({ dataValues }) => ({
+                    ...dataValues,
+                    EnterpriseId: oldEnterprise.id
+                }))
+    
+                for (const attendance of newAttendances) await newAttendancesModel.create(attendance, { transaction })
+            }
+
+            /////////// COMMENTS /////////////
+    
+            console.log('COMMENTS')
+    
+            console.log('Migrando COMMENTS')
+    
+            const oldCommentsModel = require('../legacy/models/comments').model(oldDatabase, Sequelize.DataTypes)
+            const oldCommentsCount = await oldCommentsModel.count({
+                order: [['createdAt']]
+            })
+    
+            const newCommentsModel = require('../models/comments').model(newDatabase, Sequelize.DataTypes)
+    
+            console.log('total de comentários:', oldCommentsCount)
+    
+            const pagesComments = Math.ceil(oldCommentsCount / 5000)
+    
+            console.log('total de páginas:', pagesComments)
+    
+            for (let i = 0; i < pagesComments; i++) {
+    
+                console.log(`processando: página ${i + 1} de ${pagesComments}`)
+    
+                const offset = i * 5000
+    
+                const oldComments = await oldCommentsModel.findAll({
+                    order: [['createdAt']],
+                    offset, limit: 5000
+                })
+    
+                const newComments = oldComments.map(({ dataValues }) => ({
+                    ...dataValues,
+                    EnterpriseId: oldEnterprise.id
+                }))
+    
+                for (const comment of newComments) await newCommentsModel.create(comment, { transaction })
+            }
+
+            /////////// ENDSESSIONTRIGGERS /////////////
+            
+            console.log('ENDSESSIONTRIGGERS')
+
+            const oldEndSessionTriggersModel = require('../legacy/models/endSessionTriggers').model(oldDatabase, Sequelize.DataTypes)
+            const oldEndSessionTriggers = await oldEndSessionTriggersModel.findAll()
+    
+            const newEndSessionTriggersModel = require('../models/endSessionTriggers').model(newDatabase, Sequelize.DataTypes)
+            for (const endSessionTrigger of oldEndSessionTriggers) await newEndSessionTriggersModel.create(endSessionTrigger.dataValues, { transaction })
+            
+            /////////// FAQTRIGGERS /////////////
+            
+            console.log('FAQTRIGGERS')
+
+            const oldFaqTriggersModel = require('../legacy/models/faqTriggers').model(oldDatabase, Sequelize.DataTypes)
+            const oldFaqTriggers = await oldFaqTriggersModel.findAll()
+    
+            const newFaqTriggersModel = require('../models/faqTriggers').model(newDatabase, Sequelize.DataTypes)
+            for (const FaqTrigger of oldFaqTriggers) await newFaqTriggersModel.create(FaqTrigger.dataValues, { transaction })
+
+            /////////// INACTIVITYTRIGGERS /////////////
+            
+            console.log('INACTIVITYTRIGGERS')
+
+            const oldInactivityTriggersModel = require('../legacy/models/inactivityTriggers').model(oldDatabase, Sequelize.DataTypes)
+            const oldInactivityTriggers = await oldInactivityTriggersModel.findAll()
+    
+            const newInactivityTriggers = oldInactivityTriggers.map(({ dataValues }) => ({
+                ...dataValues,
+                EnterpriseId: oldEnterprise.id
+            }))
+
+            const newInactivityTriggersModel = require('../models/inactivityTriggers').model(newDatabase, Sequelize.DataTypes)
+            for (const InactivityTrigger of newInactivityTriggers) await newInactivityTriggersModel.create(InactivityTrigger, { transaction })
+
+            /////////// RETURNHSMS /////////////
+    
+            console.log('RETURNHSMS')
+    
+            console.log('Migrando Postbacks Interaxa')
+    
+            const oldReturnHsmsModel = require('../legacy/models/returnHsm').model(oldDatabase, Sequelize.DataTypes)
+            const oldReturnHsmsCount = await oldReturnHsmsModel.count({
+                order: [['createdAt', 'ASC']]
+            })
+    
+            const newReturnHsmsModel = require('../models/returnHsm').model(newDatabase, Sequelize.DataTypes)
+    
+            console.log('total de Postbacks Gupshup:', oldReturnHsmsCount)
+    
+            const pagesReturnHsm = Math.ceil(oldReturnHsmsCount / 1000)
+    
+            console.log('total de páginas:', pagesReturnHsm)
+    
+            for (let i = 0; i < pagesReturnHsm; i++) {
+    
+                console.log(`processando: página ${i + 1} de ${pagesReturnHsm}`)
+    
+                const offset = i * 1000
+    
+                const oldReturnHsms = await oldReturnHsmsModel.findAll({
+                    attributes: { exclude: ['id'] },
+                    order: [['createdAt', 'ASC']],
+                    offset, limit: 1000
+                })
+    
+                const newReturnHsms = oldReturnHsms.map(({ dataValues }) => dataValues)
+                console.log('inserindo registros...')
+                await newReturnHsmsModel.bulkCreate(newReturnHsms, { transaction })
+            }
+
+            /////////// TRANSHIPCONVERSATIONS /////////////
+    
+            console.log('TRANSHIPCONVERSATIONS')
+    
+            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)
+    
+            console.log('total de mensagens:', oldTranshipConversationsCount)
+    
+            const pagesTranshipConversations = Math.ceil(oldTranshipConversationsCount / 1000)
+    
+            console.log('total de páginas:', pagesTranshipConversations)
+    
+            for (let i = 0; i < pagesTranshipConversations; i++) {
+    
+                console.log(`processando: página ${i + 1} de ${pagesTranshipConversations}`)
+    
+                const offset = i * 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
+                }))
+    
+                await newTranshipConversationsModel.bulkCreate(newTranshipConversations, { transaction })
+            }
+
+            /////////// BLACKLISTCONTACTS /////////////
+            
+            console.log('BLACKLISTCONTACTS')
+
+            const oldBlacklistContactsModel = require('../legacy/models/blacklistContacts').model(oldDatabase, Sequelize.DataTypes)
+            const oldBlacklistContacts = await oldBlacklistContactsModel.findAll()
+    
+            const newBlacklistContacts = oldBlacklistContacts.map(({ dataValues }) => ({
+                ...dataValues,
+                EnterpriseId: oldEnterprise.id
+            }))
+
+            const newBlacklistContactsModel = require('../models/blacklistContacts').model(newDatabase, Sequelize.DataTypes)
+            for (const blacklistContact of newBlacklistContacts) await newBlacklistContactsModel.create(blacklistContact, { transaction })
+
+            /////////// WHITELISTCONTACTS /////////////
+            
+            console.log('WHITELISTCONTACTS')
+
+            const oldWhitelistContactsModel = require('../legacy/models/whitelistContacts').model(oldDatabase, Sequelize.DataTypes)
+            const oldWhitelistContacts = await oldWhitelistContactsModel.findAll()
+    
+            const newWhitelistContacts = oldWhitelistContacts.map(({ dataValues }) => ({
+                ...dataValues,
+                EnterpriseId: oldEnterprise.id
+            }))
+
+            const newWhitelistContactsModel = require('../models/whitelistContacts').model(newDatabase, Sequelize.DataTypes)
+            for (const whitelistContact of newWhitelistContacts) await newWhitelistContactsModel.create(whitelistContact, { transaction })
+            
+            ////////////////////////////////////////
+
+            await transaction.commit()
+
+            console.log(`\n\n*** CLIENTE ${enterprise.alias} MIGRAGO COM SUCESSO!! ***\n\n`)
+
+        } catch (error) {
+
+            console.error('\n\n***ERRO NA MIGRAÇÃO DO CLIENTE', enterprise.alias)
+            console.error(error)
+            await transaction.rollback()
+        }
+
+        
+    }
+}
+
+const validationSequence = [
+    `\nEste processo foi iniciado à partir do diretório: ${process.cwd()}\nEstá correto?`,
+    '\nO arquivo _leanbot_enterprises_map.json foi criado e está correto?',
+    '\nO arquivo .env foi criado e está correto?',
+    `\nO destino desta migração será executada no host ${process.env.DATABASE_HOST}, database ${process.env.DATABASE_NAME}. Está correto?`
+]
+
+async function main() {
+    
+    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, unificate)
+}
+
+main()