/**
  * Execute the console command.
  *
  * @return mixed
  */
 public function handle()
 {
     $softRollback = $this->option('soft');
     //Modulos ja carregados
     $oldLoadedModules = Configs::getConfig(PathHelper::getModuleGeneralConfig(), Strings::CONFIG_LOADED_MODULES);
     if ($oldLoadedModules != Strings::EMPTY_STRING) {
         //Pega modulos carredos em forma de array
         $explodedLoadedModules = ModulesHelper::getLoadedModules($oldLoadedModules);
         if (is_array($explodedLoadedModules)) {
             $lastModule = $explodedLoadedModules[count($explodedLoadedModules) - 1];
             $lastModuleExploded = explode(Strings::MODULE_TYPE_NAME_SEPARATOR, $lastModule);
             if (is_array($lastModuleExploded)) {
                 $lastModuleType = $lastModuleExploded[0];
                 $lastModuleName = $lastModuleExploded[1];
                 $this->info(Strings::rollingBackModuleInfo($lastModuleExploded[0], $lastModuleExploded[1]));
                 $lastModuleRollbackFile = PathHelper::getModuleRollbackFile($lastModuleType, $lastModuleName);
                 if ($softRollback) {
                     RollbackManager::execSoftRollback($lastModuleRollbackFile, $this);
                 } else {
                     RollbackManager::execHardRollback($lastModuleType, $lastModuleName, $this);
                 }
             } else {
                 $this->error(Strings::ERROR_CANT_RESOLVE_MODULE_NAME);
             }
         } else {
             $this->error(Strings::ERROR_CANT_RESOLVE_LOADED_MODULES);
         }
     } else {
         $this->info(Strings::STATUS_NO_MODULES_LOADED);
     }
 }
Exemplo n.º 2
0
 /**
  * Execute the console command.
  *
  * @return mixed
  */
 public function handle()
 {
     //Modulos ja carregados
     $oldLoadedModules = Configs::getConfig(PathHelper::getModuleGeneralConfig(), Strings::CONFIG_LOADED_MODULES);
     if ($oldLoadedModules != Strings::EMPTY_STRING) {
         //Pega modulos carredos em forma de array
         $explodedLoadedModules = ModulesHelper::getLoadedModules($oldLoadedModules);
         foreach ($explodedLoadedModules as $key => $module) {
             $this->info($key . ' - ' . $module);
         }
     } else {
         $this->info(Strings::STATUS_NO_MODULES_LOADED);
     }
 }
 /**
  * Remove o modulo da lista de modulos carregados
  *
  * @param array $rollback
  * @return array|bool
  */
 private static function moduleUnregister($rollback)
 {
     $errors = [];
     if (array_key_exists(Strings::ROLLBACK_LOADED_MODULE_TAG, $rollback)) {
         $loadedModules = Configs::getConfig(PathHelper::getModuleGeneralConfig(), Strings::CONFIG_LOADED_MODULES);
         if ($loadedModules != false) {
             $explodedModules = explode(Strings::MODULE_SEPARATOR, $loadedModules);
             if (($key = array_search($rollback[Strings::ROLLBACK_LOADED_MODULE_TAG], $explodedModules)) !== false) {
                 unset($explodedModules[$key]);
                 $implodedNewModules = implode(Strings::MODULE_SEPARATOR, $explodedModules);
                 if (Configs::setConfig(PathHelper::getModuleGeneralConfig(), Strings::CONFIG_LOADED_MODULES, $implodedNewModules) == false) {
                     $errors[] = Strings::ERROR_ALTER_CONFIG_ROLLBACK;
                 }
             }
         } else {
             $errors[] = Strings::ERROR_MODULE_LIST_GET;
         }
     }
     return !empty($errors) ? $errors : true;
 }
 /**
  * Copia arquivos convencionais do modulo (qualquer coisa exceto migrations) para as respectivas pastas
  *
  * @param string $moduleType
  * @param string $moduleName
  * @param string $copyAll
  * @param array $rollback
  * @param Command $command
  * @param bool $allowReplace
  * @return array|bool
  */
 public static function makeMigrationsCopies($moduleType, $moduleName, &$copyAll, array &$rollback, Command $command, $allowReplace = true)
 {
     $errors = [];
     //Inicia o Rollback de arquivos copiados
     $rollback[Strings::ROLLBACK_MODULE_MIGRATION_FILE_TAG] = array();
     //Inicia o Rollback de arquivos deletados
     $rollback[Strings::ROLLBACK_MODULE_MIGRATION_DELETED_FILE_TAG] = array();
     //Copia lista de arquivos no diretorio de migrations para variavel arquivos
     $arquivos = scandir(PathHelper::getModuleMigrationsPath($moduleType, $moduleName));
     //Loop em todos os arquivos do modulo
     for ($i = Constants::FIRST_FILE; $i < count($arquivos); $i++) {
         //Quebra as palavras  da migration dentro de um array
         $explodedModuleMigrationName = explode(Strings::MIGRATIONS_WORD_SEPARATOR, $arquivos[$i]);
         //Pega remove a parte do nome referente ao timestamp
         $SimplifiedModuleMigrationName = implode(Strings::MIGRATIONS_WORD_SEPARATOR, array_slice($explodedModuleMigrationName, Constants::MIGRATION_FILE_NAME_ARRAY_START));
         //Flag que indica se o arquivo existe
         $migrationPos = false;
         //Pega migrations do projeto
         $migrationFiles = scandir(PathHelper::getLaravelMigrationsPath());
         foreach ($migrationFiles as $migrationIndex => $migrationFile) {
             //Quebra as palavras  da migration dentro de um array
             $explodedMigrationFileName = explode(Strings::MIGRATIONS_WORD_SEPARATOR, $migrationFile);
             //Pega remove a parte do nome referente ao timestamp
             $SimplifiedMigratioFileName = implode(Strings::MIGRATIONS_WORD_SEPARATOR, array_slice($explodedMigrationFileName, Constants::MIGRATION_FILE_NAME_ARRAY_START));
             //Verifica se a migration já existe
             if ($SimplifiedMigratioFileName == $SimplifiedModuleMigrationName) {
                 //marca o arquivo de migration existente migration
                 $migrationPos = $migrationIndex;
                 //quebra o loop
                 break;
             }
         }
         $explodedFileName = explode(Strings::PATH_SEPARATOR, PathHelper::getModuleMigrationsPath($moduleType, $moduleName) . $arquivos[$i]);
         $filename = $explodedFileName[count($explodedFileName) - 1];
         if (strtoupper($filename) != strtoupper(Strings::GIT_KEEP_FILE_NAME)) {
             if ($migrationPos == false) {
                 //Se o arquivo não existir
                 $migrationCounter = Configs::getConfig(PathHelper::getModuleGeneralConfig(), Strings::CONFIG_MIGRATIONS_COUNTER);
                 Configs::setConfig(PathHelper::getModuleGeneralConfig(), Strings::CONFIG_MIGRATIONS_COUNTER, $migrationCounter + 1);
                 if (copy(PathHelper::getModuleMigrationsPath($moduleType, $moduleName) . $arquivos[$i], PathHelper::getLaravelMigrationsPath() . Strings::timestampPadding($migrationCounter) . Strings::MIGRATIONS_WORD_SEPARATOR . $SimplifiedModuleMigrationName) == false) {
                     $errors[] = Strings::migrationsFileCopyError($arquivos[$i]);
                 }
                 //Sinaliza o no arquivo copiado
                 $rollback[Strings::ROLLBACK_MODULE_MIGRATION_FILE_TAG][] = EscapeHelper::encode(PathHelper::getLaravelMigrationsPath() . Strings::timestampPadding($migrationCounter) . Strings::MIGRATIONS_WORD_SEPARATOR . $SimplifiedModuleMigrationName);
             } else {
                 //Se o arquivo ja existir
                 if ($allowReplace) {
                     //Inicializa variavel que vai receber resposta do usuario dizendo o que fazer
                     // com o conflito
                     $answer = Strings::EMPTY_STRING;
                     //Enquanto o usuario não devolver uma resposta valida
                     while ($copyAll != true && $answer != Strings::SHORT_YES && $answer != Strings::SHORT_NO && $answer != Strings::SHORT_ALL && $answer != Strings::SHORT_CANCEL) {
                         //Faz pergunta para o usuario de como proceder
                         $answer = $command->ask(Strings::replaceMigrationFiles($arquivos[$i]), false);
                     }
                     //Se a resposta for sim, ou all
                     if (strtolower($answer) == Strings::SHORT_YES || strtolower($answer) == Strings::SHORT_ALL || $copyAll == true) {
                         //se a resposta for all
                         if (strtolower($answer) == Strings::SHORT_ALL) {
                             //seta variavel all para true
                             $copyAll = true;
                         }
                         //Captura o numero da migration
                         $migrationCounter = Configs::getConfig(PathHelper::getModuleGeneralConfig(), Strings::CONFIG_MIGRATIONS_COUNTER);
                         //Atualiza o contador de migrations
                         Configs::setConfig(PathHelper::getModuleGeneralConfig(), Strings::CONFIG_MIGRATIONS_COUNTER, $migrationCounter + 1);
                         //Sinaliza o no arquivo copiado
                         $rollback[Strings::ROLLBACK_MODULE_MIGRATION_FILE_TAG][] = EscapeHelper::encode(PathHelper::getModuleMigrationsPath($moduleType, $moduleName) . Strings::timestampPadding($migrationCounter) . Strings::MIGRATIONS_WORD_SEPARATOR . $SimplifiedModuleMigrationName);
                         //Faz backup do arquivo que será substituido
                         $rollback[Strings::ROLLBACK_MODULE_MIGRATION_DELETED_FILE_TAG][EscapeHelper::encode(PathHelper::getLaravelMigrationsPath() . $migrationFiles[$migrationPos])] = EscapeHelper::encode(file_get_contents(PathHelper::getLaravelMigrationsPath() . $migrationFiles[$migrationPos]));
                         //Deletar o arquivo antigo
                         if (unlink(PathHelper::getLaravelMigrationsPath() . $migrationFiles[$migrationPos]) == false) {
                             $errors[] = Strings::migrationsFileDeleteError($arquivos[$i]);
                         }
                         //verifica se a substituição ocorreu com sucesso
                         if (copy(PathHelper::getModuleMigrationsPath($moduleType, $moduleName) . $arquivos[$i], Strings::timestampPadding($migrationCounter) . Strings::MIGRATIONS_WORD_SEPARATOR . $SimplifiedModuleMigrationName) == false) {
                             $errors[] = Strings::migrationsFileCopyError($arquivos[$i]);
                         }
                     } else {
                         if (strtolower($answer) == Strings::SHORT_CANCEL) {
                             //se a resposta foi cancelar
                             //Printa msg de erro
                             $errors[] = Strings::userRequestedAbort();
                             //break the file loop
                             break;
                         }
                     }
                 }
             }
         }
     }
     return !empty($errors) ? $errors : true;
 }
Exemplo n.º 5
0
 /**
  * Execute the console command.
  *
  * @return mixed
  */
 public function handle()
 {
     //saved instace of this
     $that = $this;
     //Tipo do modulo
     $moduleType = $this->argument("type");
     //Nome do modulo
     $moduleName = $this->argument("name");
     //Inicializa variavel erros
     LoadModule::$errors = [];
     //Prepara variavel de rollback caso aja erro
     $rollback = [];
     //Verifica se foram passados os comandos inline
     if (is_null($moduleType) && is_null($moduleName)) {
         //pede o tipo do modulo
         $moduleType = $this->ask(Strings::MODULE_TYPE);
         //pede o nome do modulo
         $moduleName = $this->ask(Strings::moduleNameForThisType($moduleType));
     }
     //Modulos ja carregados
     $oldLoadedModules = Configs::getConfig(PathHelper::getModuleGeneralConfig(), Strings::CONFIG_LOADED_MODULES);
     //Inicializa variavel de array dos modulos carregados
     $explodedLoadedModules = null;
     //Inicializa variavel de array dos tipos de modulos carregados
     $explodedLoadedTypes = null;
     //Seta override de todos os arquivos para false
     $copyAll = false;
     //Pega modulos carredos em forma de array
     $explodedLoadedModules = ModulesHelper::getLoadedModules($oldLoadedModules);
     //Separa os tipos dos modulos carregados em um array
     $explodedLoadedTypes = ModulesHelper::explodeTypes($explodedLoadedModules);
     //Cria table de verificação das migrations
     LoadModule::$errors = ModulesHelper::createMigrationsCheckTable();
     /////////////////////////////////CHECA PELA EXISTENCIA DO MODULO////////////////////////////////////////////////
     ModulesHelper::executeHelperMethod(empty(LoadModule::$errors), function () use($moduleType, $moduleName) {
         return ModulesHelper::checkModuleExistence($moduleType, $moduleName);
     }, function ($result) {
         if ($result !== true) {
             LoadModule::$errors = array_merge(LoadModule::$errors, $result);
         }
     }, $this, Strings::checkModuleExistence($moduleType, $moduleName));
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     //TODO: checar se o modulo ja esta carregado
     /////////////////////////////////CHECA POR CONFLITOS ENTRE OS MODULOS///////////////////////////////////////////
     ModulesHelper::executeHelperMethod(empty(LoadModule::$errors), function () use($moduleType, $moduleName, $explodedLoadedModules, $explodedLoadedTypes) {
         return ModulesHelper::checkModuleConflicts(Configs::getConfig(PathHelper::getModuleConfigPath($moduleType, $moduleName), Strings::MODULE_CONFIG_CONFLICT), $explodedLoadedModules, $explodedLoadedTypes);
     }, function ($result) {
         if ($result !== true) {
             LoadModule::$errors = array_merge(LoadModule::$errors, $result);
         }
     });
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     //////////////////////////////CHECA POR ERROS DE DEPENDENCIA ENTRE OS MODULOS///////////////////////////////////
     ModulesHelper::executeHelperMethod(empty(LoadModule::$errors), function () use($moduleType, $moduleName, $explodedLoadedModules, $explodedLoadedTypes) {
         return ModulesHelper::checkModuleDependencies(Configs::getConfig(PathHelper::getModuleConfigPath($moduleType, $moduleName), Strings::MODULE_CONFIG_DEPENDENCIES), $explodedLoadedModules, $explodedLoadedTypes);
     }, function ($result) {
         if ($result !== true) {
             LoadModule::$errors = array_merge(LoadModule::$errors, $result);
         }
     });
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     ////////////////////////////////////MARCA O MODULO COMO CARREGADO///////////////////////////////////////////////
     ModulesHelper::executeHelperMethod(empty(LoadModule::$errors), function () use($explodedLoadedModules, $moduleType, $moduleName, &$rollback) {
         return ModulesHelper::setModuleAsLoaded($explodedLoadedModules, $moduleType, $moduleName, $rollback);
     }, function ($result) {
         if ($result !== true) {
             LoadModule::$errors = array_merge(LoadModule::$errors, $result);
         }
     }, $this, Strings::STATUS_SETING_AS_LOADED);
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     //////////////////////////////APLICA AS CONFIGURAÇÕES REQUERIDAS PELO MODULO////////////////////////////////////
     ModulesHelper::executeHelperMethod(empty(LoadModule::$errors), function () use($moduleType, $moduleName, &$rollback) {
         return ModulesHelper::makeModuleConfigs($moduleType, $moduleName, $rollback);
     }, function ($result) {
         if ($result !== true) {
             LoadModule::$errors = array_merge(LoadModule::$errors, $result);
         }
     }, $this, Strings::STATUS_SETTING_MODULE_CONFIGS);
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     //////////////////////////////////////////////ORDINARY FILE COPY////////////////////////////////////////////////
     ModulesHelper::executeHelperMethod(empty(LoadModule::$errors), function () use($moduleType, $moduleName, $copyAll, &$rollback, $that) {
         return ModulesHelper::makeOrdinaryCopies($moduleType, $moduleName, $copyAll, $rollback, $that);
     }, function ($result) {
         if ($result !== true) {
             LoadModule::$errors = array_merge(LoadModule::$errors, $result);
         }
     }, $this, Strings::STATUS_COPYING_ORDINARY_FILES);
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     ////////////////////////////////////////////MIGRATION FILES COPY////////////////////////////////////////////////
     ModulesHelper::executeHelperMethod(empty(LoadModule::$errors), function () use($moduleType, $moduleName, $copyAll, &$rollback, $that) {
         return ModulesHelper::makeMigrationsCopies($moduleType, $moduleName, $copyAll, $rollback, $that);
     }, function ($result) {
         if ($result !== true) {
             LoadModule::$errors = array_merge(LoadModule::$errors, $result);
         }
     }, $this, Strings::STATUS_COPYING_MIGRATION_FILES);
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     ////////////////////////////////////////////////ROUTE_BUILDER///////////////////////////////////////////////////
     ModulesHelper::executeHelperMethod(empty(LoadModule::$errors), function () use($moduleType, $moduleName, &$rollback) {
         return ModulesHelper::buildRoutes($moduleType, $moduleName, $rollback);
     }, function ($result) {
         if ($result !== true) {
             LoadModule::$errors = array_merge(LoadModule::$errors, $result);
         }
     }, $this, Strings::STATUS_BUILDING_ROUTES);
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     ////////////////////////////////////////////////RUN MODULE MIGRATIONS///////////////////////////////////////////
     ModulesHelper::executeHelperMethod(empty(LoadModule::$errors), function () use($moduleType, $moduleName, &$rollback, $that) {
         return ModulesHelper::runMigrations($moduleType, $moduleName, $rollback, $that);
     }, function ($result) {
         if ($result !== true) {
             LoadModule::$errors = array_merge(LoadModule::$errors, $result);
         }
     }, $this, Strings::STATUS_RUNING_MIGRATIONS);
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     ////////////////////////////////////////////////GENERATE ROLLBACK FILE//////////////////////////////////////////
     ModulesHelper::executeHelperMethod(empty(LoadModule::$errors), function () use($moduleType, $moduleName, &$rollback) {
         return ModulesHelper::createRollbackFile($moduleType, $moduleName, $rollback);
     }, function ($result) {
         if ($result !== true) {
             LoadModule::$errors = array_merge(LoadModule::$errors, $result);
         }
     }, $this, Strings::STATUS_GEN_ROLLBACK);
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     ////////////////////////////////////////////////RESPONSE (OUTPUT)///////////////////////////////////////////////
     if (empty(LoadModule::$errors)) {
         //Se os comandos rodarem com sucesso
         //Comentario comando executado com sucesso
         $this->comment(Strings::successfullyRunModuleLoad($moduleType, $moduleName));
         return true;
     } else {
         //Se ocorrer erro ao rodar os comandos
         foreach (LoadModule::$errors as $error) {
             $this->error($error);
         }
         RollbackManager::execSoftRollback($rollback, $this);
         return false;
     }
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 }
 /**
  * Execute the console command.
  *
  * @return mixed
  */
 public function handle()
 {
     //saved instace of this
     $that = $this;
     //Tipo do modulo
     $moduleType = $this->argument("type");
     //Nome do modulo
     $moduleName = $this->argument("name");
     //Inicializa variavel erros
     self::$errors = [];
     //Prepara variavel de rollback caso haja erro
     $rollback = [];
     //Verifica se foram passados os comandos inline
     if (is_null($moduleType) && is_null($moduleName)) {
         //pede o tipo do modulo
         $moduleType = $this->ask(Strings::MODULE_TYPE);
         //pede o nome do modulo
         $moduleName = $this->ask(Strings::moduleNameForThisType($moduleType));
     }
     //Modulos ja carregados
     $oldLoadedModules = Configs::getConfig(PathHelper::getModuleGeneralConfig(), Strings::CONFIG_LOADED_MODULES);
     //Inicializa variavel de array dos modulos carregados
     $explodedLoadedModules = null;
     //Inicializa variavel de array dos tipos de modulos carregados
     $explodedLoadedTypes = null;
     //Seta override de todos os arquivos para false
     $copyAll = false;
     //Pega modulos carredos em forma de array
     $explodedLoadedModules = ModulesHelper::getLoadedModules($oldLoadedModules);
     /////////////////////////////////DEFINE TIPO DO ROLLBACK COMO REFRESH///////////////////////////////////////////
     ModulesHelper::executeHelperMethod(empty(RefreshModule::$errors), function () use($moduleType, $moduleName, &$rollback) {
         return ModulesHelper::setRollbackFileAsRefreshType($moduleType, $moduleName, $rollback);
     });
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     /////////////////////////////////CHECA PELA EXISTENCIA DO MODULO////////////////////////////////////////////////
     ModulesHelper::executeHelperMethod(empty(RefreshModule::$errors), function () use($moduleType, $moduleName) {
         return ModulesHelper::checkModuleExistence($moduleType, $moduleName);
     }, function ($result) {
         if ($result !== true) {
             RefreshModule::$errors = array_merge(RefreshModule::$errors, $result);
         }
     }, $this, Strings::checkModuleExistence($moduleType, $moduleName));
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     /////////////////////////////////CHECA SE O MODULO SELECIONADO ESTA CARREGADO///////////////////////////////////
     ModulesHelper::executeHelperMethod(empty(RefreshModule::$errors), function () use($moduleType, $moduleName, $explodedLoadedModules) {
         return ModulesHelper::checkIfModuleLoaded($moduleType, $moduleName, $explodedLoadedModules);
     }, function ($result) {
         if ($result !== true) {
             RefreshModule::$errors = array_merge(RefreshModule::$errors, $result);
         }
     }, $this, Strings::checkIfModuleLoaded($moduleType, $moduleName));
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     //////////////////////////////////////////////ORDINARY FILE COPY////////////////////////////////////////////////
     ModulesHelper::executeHelperMethod(empty(RefreshModule::$errors), function () use($moduleType, $moduleName, $copyAll, &$rollback, $that) {
         return ModulesHelper::makeOrdinaryCopies($moduleType, $moduleName, $copyAll, $rollback, $that);
     }, function ($result) {
         if ($result !== true) {
             RefreshModule::$errors = array_merge(RefreshModule::$errors, $result);
         }
     }, $this, Strings::STATUS_COPYING_ORDINARY_FILES);
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     ////////////////////////////////////////////MIGRATION FILES COPY////////////////////////////////////////////////
     ModulesHelper::executeHelperMethod(empty(RefreshModule::$errors), function () use($moduleType, $moduleName, $copyAll, &$rollback, $that) {
         return ModulesHelper::makeMigrationsCopies($moduleType, $moduleName, $copyAll, $rollback, $that, false);
     }, function ($result) {
         if ($result !== true) {
             RefreshModule::$errors = array_merge(RefreshModule::$errors, $result);
         }
     }, $this, Strings::STATUS_COPYING_MIGRATION_FILES);
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     ////////////////////////////////////////////////ROUTE_BUILDER///////////////////////////////////////////////////
     ModulesHelper::executeHelperMethod(empty(RefreshModule::$errors), function () use($moduleType, $moduleName, &$rollback) {
         return ModulesHelper::buildRoutes($moduleType, $moduleName, $rollback);
     }, function ($result) {
         if ($result !== true) {
             RefreshModule::$errors = array_merge(RefreshModule::$errors, $result);
         }
     }, $this, Strings::STATUS_BUILDING_ROUTES);
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     ////////////////////////////////////////////////GENERATE ROLLBACK FILE//////////////////////////////////////////
     ModulesHelper::executeHelperMethod(empty(RefreshModule::$errors), function () use($moduleType, $moduleName, &$rollback) {
         return ModulesHelper::createRollbackFile($moduleType, $moduleName, $rollback);
     }, function ($result) {
         if ($result !== true) {
             RefreshModule::$errors = array_merge(RefreshModule::$errors, $result);
         }
     }, $this, Strings::STATUS_GEN_ROLLBACK);
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     ////////////////////////////////////////////////RESPONSE (OUTPUT)///////////////////////////////////////////////
     if (empty(RefreshModule::$errors)) {
         //Se os comandos rodarem com sucesso
         //Comentario comando executado com sucesso
         $this->comment(Strings::successfullyRunModuleRefresh($moduleType, $moduleName));
         return true;
     } else {
         //Se ocorrer erro ao rodar os comandos
         foreach (RefreshModule::$errors as $error) {
             $this->error($error);
         }
         RollbackManager::execSoftRollback($rollback, $this);
         return false;
     }
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 }