コード例 #1
0
 /**
  * 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);
     }
 }
コード例 #2
0
 /**
  * Copia recurssivamente os arquivos e diretorios de um array de paths
  *
  * @param array $errors
  * @param bool $copyAll
  * @param array $rollback
  * @param Command $command
  * @param array $paths
  */
 public static function recursiveCopy(array &$errors, &$copyAll, array &$rollback, Command $command, array $paths)
 {
     //loop em todos os diretorios de destino
     foreach ($paths as $key => $value) {
         if (!is_dir($value)) {
             //Se o diretorio não existir
             //Cria o diretorio que não existe
             if (mkdir($value)) {
                 //Cria registro no rollback dizendo uma pasta foi criada
                 $rollback[Strings::ROLLBACK_DIR_CREATED_TAG][] = $value;
             }
         }
     }
     //Loop em todas as pastas
     foreach ($paths as $key => $value) {
         if (empty($errors)) {
             //Se os comandos anteriores rodarem com sucesso
             //Copia lista de arquivos no diretorio para variavel arquivos
             $arquivos = scandir($key);
             //Loop em todos os arquivos do modulo
             for ($i = Constants::FIRST_FILE; $i < count($arquivos); $i++) {
                 if (empty($errors)) {
                     if (!is_dir($key . $arquivos[$i])) {
                         //Se os comandos anteriores rodarem com sucesso e o arquivo não for uma pasta
                         $explodedFileName = explode(Strings::PATH_SEPARATOR, $value . $arquivos[$i]);
                         $filename = $explodedFileName[count($explodedFileName) - 1];
                         //Verifica se o arquivo existe
                         if (!file_exists($value . $arquivos[$i])) {
                             //Cria registro no rollback dizendo que o arquivo foi copiado
                             $rollback[Strings::ROLLBACK_MODULE_ORDINARY_FILE_COPY_TAG][EscapeHelper::encode($value . $arquivos[$i])] = Strings::EMPTY_STRING;
                             //verifica se a copia ocorreu com sucesso
                             if (copy($key . $arquivos[$i], $value . $arquivos[$i]) == false) {
                                 //Printa msg de erro
                                 $errors[] = Strings::ordinaryFileCopyError($value . $arquivos[$i]);
                             }
                         } else {
                             if (strtoupper($filename) != strtoupper(Strings::GIT_KEEP_FILE_NAME)) {
                                 //Caso ja exista um arquivo com o mesmo nome no diretorio de destino
                                 //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::replaceOrdinaryFiles($value . $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;
                                     }
                                     //Faz backup do arquivo que será substituido
                                     $rollback[Strings::ROLLBACK_MODULE_ORDINARY_FILE_COPY_TAG][EscapeHelper::encode($value . $arquivos[$i])] = EscapeHelper::encode(file_get_contents($value . $arquivos[$i]));
                                     //verifica se a substituição ocorreu com sucesso
                                     if (copy($key . $arquivos[$i], $value . $arquivos[$i]) == false) {
                                         //Se houver erro ao copiar arquivo
                                         //Printa msg de erro
                                         $errors[] = Strings::ordinaryFileReplaceError($value . $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 2;
                                     }
                                 }
                             }
                         }
                     } else {
                         $newPath = [$key . $arquivos[$i] . "/" => $value . $arquivos[$i] . "/"];
                         self::recursiveCopy($errors, $copyAll, $rollback, $command, $newPath);
                     }
                 }
             }
         }
     }
 }
コード例 #3
0
 /**
  * Constroi as rotas dos modulos
  *
  * @param string $moduleType
  * @param string $moduleName
  * @param array $rollback
  * @param Command $command
  * @return array|bool
  */
 public static function runMigrations($moduleType, $moduleName, array &$rollback, Command $command)
 {
     try {
         $errors = [];
         //Roda dump autoload
         shell_exec(Strings::COMMAND_DUMP_AUTOLOAD);
         //Tenta Rodar a migration
         $command->call(Strings::COMMAND_MIGRATE);
         //Seta a flag de migrations para true no rollback
         $rollback[Strings::ROLLBACK_MIGRATE] = Strings::TRUE_STRING;
         /////VERIFICAR SE MIGRATE RODOU DE FORMA ADEQUADA//////
         if (!(count(DB::table(Strings::TABLE_PROJECT_MODULES)->where(Strings::TABLE_PROJECT_MODULES_NAME, $moduleType . Strings::MODULE_TYPE_NAME_SEPARATOR . $moduleName)->first()) > 0)) {
             $errors[] = Strings::ERROR_MIGRATE;
         }
         ///////////////////////////////////////////////////////
     } catch (\Exception $e) {
         $errors[] = Strings::migrationException($e->getMessage());
     }
     return !empty($errors) ? $errors : true;
 }
コード例 #4
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;
     }
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 }
コード例 #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
     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;
     }
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 }