Ejemplo n.º 1
0
        public void CriarArquivos(Entidade entidade)
        {
            Diretorio.CriarSeNaoExistirDiretorio(_diretorioProjeto + $@"\UseCases\{entidade.Nome}\Base\");
            Diretorio.CriarSeNaoExistirDiretorio(_diretorioProjeto + $@"\UseCases\{entidade.Nome}\Base\Validations\");
            Diretorio.CriarSeNaoExistirDiretorio(_diretorioProjeto + $@"\Interfaces\Repositories\");
            Diretorio.CriarSeNaoExistirDiretorio(_diretorioProjeto + $@"\Interfaces\UseCases\");

            if (entidade.Regerar)
            {
                CriarRequestGenerated(entidade);
                CriarResponseGenerated(entidade);
                CriarValidacoesInserirGenerated(entidade);
                CriarValidacoesAlterarGenerated(entidade);
            }
            else
            {
                CriarRequestGenerated(entidade);
                CriarRequest(entidade);
                CriarResponseGenerated(entidade);
                CriarResponse(entidade);
                CriarIRepository(entidade.Nome);
                CriarIUseCase(entidade.Nome);
                CriarUseCase(entidade.Nome);
                CriarValidacoesInserirGenerated(entidade);
                CriarValidacoesInserir(entidade);
                CriarValidacoesAlterarGenerated(entidade);
                CriarValidacoesAlterar(entidade);
            }
        }
        public void CriarArquivos(Entidade entidade)
        {
            var nomeEntidade = entidade.Nome;
            var projectName  = InfoProjeto.Nome;
            var pathDestino  = InfoProjeto.Diretorio;
            var resourceName = ResourceNameTemplates + "Backend.Api.nameController.txt";

            pathDestino += $@"\Controllers\";
            var fileDestino = $"{pathDestino + nomeEntidade}Controller.cs";

            Diretorio.CriarSeNaoExistirDiretorio(pathDestino);

            using (Stream stream = Assembly.GetManifestResourceStream(resourceName))
                using (StreamReader reader = new StreamReader(stream))
                {
                    var namespaceApplication = ProjectHelper.ProjectDetails(eProjeto.Application).Nome;
                    var textoTemplate        = reader.ReadToEnd();

                    var textoTratado = textoTemplate
                                       .Replace("{{name}}", nomeEntidade)
                                       .Replace("{{nameCamelCase}}", nomeEntidade.ToCamelCase())
                                       .Replace("{{namespace}}", projectName)
                                       .Replace("{{namespaceApplication}}", namespaceApplication);

                    File.WriteAllText(fileDestino, textoTratado);
                }
        }
        public void CriarArquivos(string nomeEntidade, string urlProjeto)
        {
            basePath              = urlProjeto + @"\src\app\core";
            this.nomeEntidade     = nomeEntidade;
            nomeEntidadeCamelCase = nomeEntidade.ToCamelCase();
            Diretorio.CriarSeNaoExistirDiretorio(basePath + @"\usecases\" + nomeEntidadeCamelCase);
            Diretorio.CriarSeNaoExistirDiretorio(basePath + @"\usecases\" + nomeEntidadeCamelCase + @"\base\");

            CriarUseCase();
        }
        public void CriarArquivos(Entidade entidade, string urlProjeto)
        {
            this.entidade = entidade;
            basePath      = $@"{urlProjeto}\src\app\core\usecases\{entidade.Nome.ToCamelCase()}\base\validations\";
            Diretorio.CriarSeNaoExistirDiretorio(basePath);
            CriarValidatorGenerated();

            if (!entidade.Regerar)
            {
                CriarValidator();
            }
        }
Ejemplo n.º 5
0
        public GitConfig RetornarConfigGit()
        {
            var diretorioFinal = toolsFolder + "Config";

            Diretorio.CriarSeNaoExistirDiretorio(diretorioFinal);

            if (!Diretorio.ExisteArquivos(diretorioFinal, "git.json"))
            {
                return(new GitConfig());
            }

            return(JsonConvert.DeserializeObject <GitConfig>(File.ReadAllText($"{toolsFolder}Config\\git.json")));
        }
Ejemplo n.º 6
0
        public void CriarJsonConfigGit(GitConfig gitConfig)
        {
            var diretorioConfig = $@"{toolsFolder}Config\";

            Diretorio.CriarSeNaoExistirDiretorio(diretorioConfig);
            var fileDestino = $@"{diretorioConfig}\git.json";

            using (StreamWriter fileWriter = File.CreateText(fileDestino))
            {
                var serializer = new JsonSerializer();
                serializer.Serialize(fileWriter, gitConfig);
            }
        }
        public void CriarArquivos(Entidade entidade, string urlProjeto)
        {
            basePath = urlProjeto + @"\src\app\core";
            Diretorio.CriarSeNaoExistirDiretorio(basePath + @"\Domain\Entities\");
            string nomeCamelCase = entidade.Nome.ToCamelCase();

            CriarModelGenereted(entidade, nomeCamelCase);

            if (!entidade.Regerar)
            {
                CriarModel(entidade, nomeCamelCase);
            }
        }
Ejemplo n.º 8
0
        public void CriarArquivos(string nomeEntidade, string urlProjeto)
        {
            basePath          = urlProjeto + @"\src\app\core";
            this.nomeEntidade = nomeEntidade;
            Diretorio.CriarSeNaoExistirDiretorio(basePath + @"\interfaces\repositories\");
            Diretorio.CriarSeNaoExistirDiretorio(basePath + @"\interfaces\usecases\");
            Diretorio.CriarSeNaoExistirDiretorio(basePath + @"\interfaces\services\");
            Diretorio.CriarSeNaoExistirDiretorio(basePath + @"\interfaces\validations\");

            CriarIRepository();
            CriarIService();
            CriarIUseCase();
            CriarIValidator();
        }
        public void CriarArquivos(Entidade entidade)
        {
            Diretorio.CriarSeNaoExistirDiretorio(_diretorioProjeto);

            if (entidade.Regerar)
            {
                CriarArquivoGenerated(entidade);
            }
            else
            {
                CriarArquivo(entidade);
                CriarArquivoGenerated(entidade);
                VincularPartialClass(InfoProjeto, $"{entidade.Nome}Model", $@"Entities\{entidade.Nome}Model");
            }
        }
Ejemplo n.º 10
0
        public void CriarArquivos(Entidade entidade)
        {
            var nomeEntidade = entidade.Nome;
            var diretorio    = $@"{_diretorioProjeto}\AutoMapper\Generated\";
            var arquivoFinal = $@"{diretorio}\{nomeEntidade}Profile.cs";

            propriedadesReferencias = entidade.Propriedades.Where(a => a.Tipo == eTipoPropriedade.Reference && !a.IsCollection);

            if (!propriedadesReferencias.Any())
            {
                if (File.Exists(arquivoFinal))
                {
                    File.Delete(arquivoFinal);
                }

                return;
            }

            Diretorio.CriarSeNaoExistirDiretorio(diretorio);
            CriarProfile(nomeEntidade, arquivoFinal);
        }
Ejemplo n.º 11
0
        public void Mappings(Entidade entidade)
        {
            var nomeEntidade  = entidade.Nome;
            var pastaEntidade = $@"{_diretorioProjeto}\{_pastaOrm}\Mappings\{nomeEntidade}";

            Diretorio.CriarSeNaoExistirDiretorio(pastaEntidade);

            var resourceName = ResourceNameTemplates + "Backend.Infra.Data.NHibernateDataAccess.mapGenerated.txt";
            var fileDestino  = $@"{pastaEntidade}\{nomeEntidade}MapGenerated.cs";

            using (Stream stream = Assembly.GetManifestResourceStream(resourceName))
                using (StreamReader reader = new StreamReader(stream))
                {
                    var textoTemplate = reader.ReadToEnd();

                    var textoTratado = TratarConteudoMapping(entidade.Propriedades, textoTemplate);
                    textoTratado = textoTratado
                                   .Replace("{{name}}", nomeEntidade)
                                   .Replace("{{namespace}}", _nomeProjeto);
                    File.WriteAllText(fileDestino, textoTratado);
                }
        }
Ejemplo n.º 12
0
        public void CriarArquivos(Entidade entidade)
        {
            Diretorio.CriarSeNaoExistirDiretorio($@"{_diretorioProjeto}\{_pastaOrm}\DataModels\");
            Diretorio.CriarSeNaoExistirDiretorio($@"{_diretorioProjeto}\{_pastaOrm}\Repositories\");

            CriarDataGenerated(entidade);
            if (_tipoOrm == eTipoOrm.NHibernate)
            {
                Mappings(entidade);
            }

            if (!entidade.Regerar)
            {
                CriarData(entidade);
                CriarRepository(entidade.Nome);
                VincularPartialClass(InfoProjeto, $"{entidade.Nome}Data", $@"{_pastaOrm}\DataModels\{entidade.Nome}Data");

                if (_tipoOrm == eTipoOrm.EntityFramework)
                {
                    AlterarContext(entidade.Nome);
                }
            }
        }