private static void CriaPropriedades(List<DadosColunas> colunas, StringBuilder retorno, IEnumerable<DadosAssociation> listaFk, List<string> enumeradores, ParametrosCriarProjetos parametros)
{
colunas = colunas.OrderByDescending(c => c.Pk).ToList();
foreach (var coluna in colunas)
{
var colunaRequirida = false;
if (parametros.MapLinq)
{
if (coluna.Pk || coluna.AceitaNull == false)
{
retorno.AppendFormat("[Required, DisplayName(\"{0}\")]{1}", coluna.Coluna, Environment.NewLine);
colunaRequirida = !coluna.AceitaNull;
}
if (enumeradores != null)
{
var coluna1 = coluna;
foreach (var dom in enumeradores.Where(domain => coluna1.Coluna == domain.Split('|')[0]).Select(domain => string.Format("[DomainValidator(new object[]<{0}>)]{1}", domain.Split('|')[1], Environment.NewLine)).Select(prodDomain => prodDomain.Replace("<", "{").Replace(">", "}").Replace("'", "\"")))
{
retorno.Append(dom);
}
}
//valida o tamanho do campo de texto
if (coluna.Tipo.ToLower().Contains("char") || coluna.Tipo.ToLower() == "string")
{
switch (colunaRequirida)
{
case true:
retorno.AppendFormat("[StringLength({0})]{1}", coluna.Tamanho, Environment.NewLine);
break;
default:
retorno.AppendFormat("[StringLength({0}), DisplayName(\"{1}\")]{2}", coluna.Tamanho, coluna.Coluna, Environment.NewLine);
break;
}
}
//valida se o campo possui validação personalizada
if (!string.IsNullOrEmpty(coluna.RegExp))
{
retorno.AppendLine(string.Format("[RegularExpression(@\"{0}\")]", coluna.RegExp));
}
retorno.Append(RetornaMapColumn(coluna)).Append(Environment.NewLine);
}
if (parametros.MapWcf)
{
retorno.AppendFormat("[DataMember]{0}", Environment.NewLine);
}
retorno.Append(string.Format("public {0}{1} {2} {{ get; set; }}", coluna.Tipo, VerificaNullable(coluna.Tipo, coluna.AceitaNull), RemoveCaracteresInvalidos(coluna.Coluna)) + Environment.NewLine + Environment.NewLine);
}
CriaAssociacoes(retorno, listaFk);
retorno.Append("}" + Environment.NewLine);
retorno.Append("}" + Environment.NewLine);
}
/// <summary>
/// Gera os arquivos ORM (TO/DAL/BLL)
/// </summary>
public static void Gerar(ParametrosCriarProjetos parametros)
{
foreach (var objetoOrm in parametros.ObjetosMapeaveis)
{
GeraClassesORM(objetoOrm.Key, objetoOrm.Value, parametros);
}
}
/// <summary>
/// Gera os arquivos base para o ORM
/// </summary>
/// <param name="caminho">caminho para gravação dos arquivos</param>
/// <param name="strNamespace">NameSpace usado no projeto</param>
public static void GravaArquivosBaseOrm(ParametrosCriarProjetos parametro, string nomeProvider)
{
GeraArquivosLINQ(parametro, nomeProvider);
GeraArquivosBLL(parametro.CaminhoDestino, parametro.NameSpace);
GeraArquivosTO(parametro.CaminhoDestino);
GeraArquivosInterface(parametro.CaminhoDestino, parametro.NameSpace);
}
private static void GeraClassesORM(TipoObjetoBanco objOrm, List<DadosColunas> colunasObjeto, ParametrosCriarProjetos parametros)
{
var gerador = new Gerador { Log = Log };
var nomeArquivo = Gerador.RetornaNomeClasseAjustado(objOrm.NomeObjeto);
var arquivo = gerador.GerarClasseTO(colunasObjeto, objOrm.NomeObjeto, parametros.NameSpace, objOrm.Associacoes, objOrm.Enumns, parametros);
var arquivoBLL = gerador.GerarClasseBLL(nomeArquivo, parametros.NameSpace, objOrm.TipoObjeto, objOrm.Parametros);
var arquivoDAL = gerador.GerarClasseDAL(nomeArquivo, parametros.NameSpace, objOrm.TipoObjeto, objOrm.Parametros, objOrm.QuerySql);
File.WriteAllText(string.Format("{0}\\TO\\{1}TO.cs", parametros.CaminhoDestino, nomeArquivo), arquivo);
File.WriteAllText(string.Format("{0}\\BLL\\{1}BLL.cs", parametros.CaminhoDestino, nomeArquivo), arquivoBLL);
File.WriteAllText(string.Format("{0}\\DAL\\{1}DAL.cs", parametros.CaminhoDestino, nomeArquivo), arquivoDAL);
}
public static void Gerar(ParametrosCriarProjetos parametros, string provider)
{
var guidProjInterface = Guid.NewGuid().ToString().ToUpper();
var guidProjTO = Guid.NewGuid().ToString().ToUpper().ToUpper();
var guidProjDal = Guid.NewGuid().ToString().ToUpper().ToUpper();
var guidProjBll = Guid.NewGuid().ToString().ToUpper().ToUpper();
var guidProjWcf = Guid.NewGuid().ToString().ToUpper().ToUpper();
var arquivosInterface = (from KeyValuePair<TipoObjetoBanco, List<DadosColunas>> t in parametros.ObjetosMapeaveis select string.Format("<Compile Include=\"IPersistence{0}.cs\" />", Gerador.RetornaNomeClasseAjustado(t.Key.NomeObjeto).Replace(" ", ""))).ToList();
var arquivosTO = (from KeyValuePair<TipoObjetoBanco, List<DadosColunas>> t in parametros.ObjetosMapeaveis select string.Format("<Compile Include=\"{0}TO.cs\" />", Gerador.RetornaNomeClasseAjustado(t.Key.NomeObjeto))).ToList();
var arquivosDal = (from KeyValuePair<TipoObjetoBanco, List<DadosColunas>> t in parametros.ObjetosMapeaveis select string.Format("<Compile Include=\"{0}DAL.cs\" />", Gerador.RetornaNomeClasseAjustado(t.Key.NomeObjeto))).ToList();
var arquivosBll = (from KeyValuePair<TipoObjetoBanco, List<DadosColunas>> t in parametros.ObjetosMapeaveis select string.Format("<Compile Include=\"{0}BLL.cs\" />", Gerador.RetornaNomeClasseAjustado(t.Key.NomeObjeto))).ToList();
var sbLog4Net = new StringBuilder();
sbLog4Net.AppendLine("<Reference Include=\"log4net, Version=1.2.10.0, Culture=neutral, PublicKeyToken=692fbea5521e1304, processorArchitecture=AMD64\">");
sbLog4Net.AppendLine("<SpecificVersion>False</SpecificVersion>");
sbLog4Net.AppendLine("<HintPath>..\\log4net.dll</HintPath>");
sbLog4Net.AppendLine("</Reference>");
var templateAssembly = AssinaProjeto(parametros);
GeraProjetoInterface(parametros, guidProjInterface, arquivosInterface, templateAssembly);
GeraProjetoTo(parametros, guidProjTO, guidProjInterface, arquivosTO, templateAssembly);
GeraProjetoDal(parametros, provider, guidProjDal, guidProjInterface, guidProjTO, arquivosDal, sbLog4Net, templateAssembly);
GeraProjetoBll(parametros, guidProjBll, guidProjInterface, guidProjTO, guidProjDal, arquivosBll, sbLog4Net, templateAssembly);
if (parametros.MapWcf)
{
GeraProjetoWcf(parametros, guidProjWcf);
}
else
{
guidProjWcf = null;
}
GeraSoluction(parametros, guidProjTO, guidProjDal, guidProjInterface, guidProjBll, guidProjWcf);
Directory.Move(string.Format("{0}\\TO", parametros.CaminhoDestino), string.Format("{0}\\{1}TO", parametros.CaminhoDestino, parametros.NameSpace.Replace(".", "")));
Directory.Move(string.Format("{0}\\DAL", parametros.CaminhoDestino), string.Format("{0}\\{1}DAL", parametros.CaminhoDestino, parametros.NameSpace.Replace(".", "")));
Directory.Move(string.Format("{0}\\BLL", parametros.CaminhoDestino), string.Format("{0}\\{1}BLL", parametros.CaminhoDestino, parametros.NameSpace.Replace(".", "")));
Directory.Move(string.Format("{0}\\Interfaces", parametros.CaminhoDestino), string.Format("{0}\\{1}Interfaces", parametros.CaminhoDestino, parametros.NameSpace.Replace(".", "")));
}
public static void Gerar(ParametrosCriarProjetos parametros)
{
if (!parametros.GerarAppConfig) return;
var sbAppConfig = new StringBuilder();
sbAppConfig.AppendLine("<?xml version=\"1.0\" encoding=\"utf-8\" ?>");
sbAppConfig.AppendLine("<configuration>");
sbAppConfig.AppendLine("<connectionStrings>");
sbAppConfig.AppendLine(string.Format("<add name=\"STRING_CONNECTION\" connectionString=\"Data Source = {0}; Initial Catalog = {2}; " +
"Persist Security Info = True; User ID = {1}; Password = {3}; " +
"\" providerName=\"System.Data.SqlClient\" />", parametros.DadosConexao.Servidor,
parametros.DadosConexao.Usuario, parametros.DadosConexao.DataBase, parametros.DadosConexao.Senha));
sbAppConfig.AppendLine("</connectionStrings>");
sbAppConfig.AppendLine("</configuration>");
File.WriteAllText(string.Format("{0}\\app.config", parametros.CaminhoDestino), sbAppConfig.ToString());
}
private static void GeraSoluction(ParametrosCriarProjetos parametros, string guidProjTO, string guidProjDAL, string guidProjInterface, string guidProjBLL, string guidProjWcf)
{
var trocasSolution = new Hashtable
{
{"[guid]", Guid.NewGuid().ToString().ToUpper().ToUpper()},
{"[namespace]", parametros.NameSpace},
{"[guidTO]", guidProjTO},
{"[guidDAL]", guidProjDAL},
{"[guidInterface]", guidProjInterface},
{"[guidBLL]", guidProjBLL}
};
var projSolution = Gerador.RetornaTextoBase("noituloS");
if (parametros.MapWcf)
{
projSolution = projSolution.Replace("[guidWcf]", string.Format("Project(\"{{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}}\") = \"{0}Wcf\", \"{0}Wcf\\{0}Wcf.csproj\", \"{{53034ACE-081D-4CDA-8075-D3B158C7DAF9}}\"{1}EndProject", parametros.NameSpace, Environment.NewLine));
projSolution = projSolution.Replace("[guidGlobalWcf]", string.Format("{{{0}}}.Debug|Any CPU.ActiveCfg = Debug|Any CPU{1}{{{0}}}.Debug|Any CPU.Build.0 = Debug|Any CPU{1}{{{0}}}.Release|Any CPU.ActiveCfg = Release|Any CPU{1}{{{0}}}.Release|Any CPU.Build.0 = Release|Any CPU", guidProjWcf, Environment.NewLine));
}
else
{
projSolution = projSolution.Replace("[guidWcf]", "");
projSolution = projSolution.Replace("[guidGlobalWcf]", "");
}
switch (parametros.VersaoFramework)
{
case "v2.0":
projSolution = projSolution.Replace("2010", "2008");
projSolution = projSolution.Replace("11.00", "10.00");
break;
case "v4.5":
projSolution = projSolution.Replace("2010", "2012");
projSolution = projSolution.Replace("11.00", "12.00");
break;
}
projSolution = trocasSolution.Cast<DictionaryEntry>().Aggregate(projSolution, (current, entry) => current.Replace(entry.Key.ToString(), entry.Value.ToString()));
File.WriteAllText(string.Format("{0}\\{1}.sln", parametros.CaminhoDestino, parametros.NameSpace), projSolution);
}
/// <summary>
/// Cria o TO da tabela selecionada
/// </summary>
/// <param name="colunas">Colunas usadas no TO</param>
/// <param name="nomeTabela">nome da classe TO</param>
/// <param name="strNamespace">Namespace do Projeto</param>
/// <param name="listaFk">lista de FK do objeto FK </param>
/// <param name="enumeradores">Lista de Enuns do bando de dados </param>
/// <param name="parametros"></param>
/// <returns></returns>
public string GerarClasseTO(List<DadosColunas> colunas, string nomeTabela, string strNamespace, List<DadosAssociation> listaFk, List<string> enumeradores, ParametrosCriarProjetos parametros)
{
var retorno = new StringBuilder();
CriaCabecario(nomeTabela, strNamespace, retorno, parametros);
CriaEnumeradores(enumeradores, retorno);
CriaPropriedades(colunas, retorno, listaFk, enumeradores, parametros);
return retorno.ToString();
}
private static void CriaCabecario(string nomeTabela, string strNamespace, StringBuilder retorno, ParametrosCriarProjetos parametros)
{
retorno.AppendFormat("using System;{0}", Environment.NewLine);
if (parametros.MapLinq)
{
retorno.AppendFormat("using System.ComponentModel;{0}", Environment.NewLine);
retorno.AppendFormat("using System.ComponentModel.DataAnnotations;{0}", Environment.NewLine);
retorno.AppendFormat("using System.Data.Linq.Mapping;{0}", Environment.NewLine);
}
if (parametros.MapWcf)
{
retorno.AppendFormat("using System.Runtime.Serialization;{0}", Environment.NewLine);
}
retorno.AppendLine();
retorno.AppendFormat("{0}{1}", string.Format("namespace {0}TO", strNamespace), Environment.NewLine);
retorno.AppendFormat("{{{0}", Environment.NewLine);
if (parametros.MapLinq)
{
retorno.AppendFormat("{0}{1}", string.Format("[Table(Name = \"{0}\")]", nomeTabela), Environment.NewLine);
}
if (parametros.MapWcf)
{
retorno.AppendFormat("{0}{1}", "[DataContract]", Environment.NewLine);
}
retorno.AppendFormat("{0}{1}", string.Format("public class {0}TO", RetornaNomeClasseAjustado(nomeTabela)), Environment.NewLine);
retorno.AppendFormat("{{{0}{0}", Environment.NewLine);
}
/// <summary>
/// Cria todos os arquivos de mapeamento
/// </summary>
/// <param name="parametros"></param>
public void CriarArquivosProjeto(ParametrosCriarProjetos parametros)
{
DiretoriosBase.Criar(parametros.CaminhoDestino);
ArquivosORM.GravaArquivosBaseOrm(parametros, "MySqlFormatter");
ArquivosObjetos.Gerar(parametros);
ArquivosProjeto.Gerar(parametros, "MySqlFormatter");
ArquivoAppConfig.Gerar(parametros);
}
private static void GeraArquivosLINQ(ParametrosCriarProjetos parametro, string nomeProvider)
{
// ReSharper disable ResourceItemNotResolved
var dbExpressions = Template.RetornaValor("DbExpressions").Value;
var dbExpressionVisitor = Template.RetornaValor("DbExpressionVisitor").Value;
var expressionVisitor = Template.RetornaValor("ExpressionVisitor").Value;
var queryExecutor = Template.RetornaValor("QueryExecutor").Value;
var queryLanguage = Template.RetornaValor("QueryLanguage").Value;
var queryMapping = Template.RetornaValor("QueryMapping").Value;
var queryTypeSystem = Template.RetornaValor("QueryTypeSystem").Value;
var sqlFormatter = Template.RetornaValor("SqlFormatter").Value;
var ISqlFormatter = Template.RetornaValor("ISqlFormatter").Value;
var provider = Template.RetornaValor(nomeProvider).Value;
string funcoesCrud;
if (nomeProvider.StartsWith("MySql"))
{
funcoesCrud = parametro.TiposObjetosAcaoBanco.Aggregate(Template.RetornaValor("FuncoesCrud").Value, (current, param) => current.Replace(param.Key, param.Value)).Replace("{namespace}",parametro.NameSpace);
}
else
{
funcoesCrud = parametro.TiposObjetosAcaoBanco.Aggregate(Template.RetornaValor("SSFuncoesCrud").Value, (current, param) => current.Replace(param.Key, param.Value)).Replace("{namespace}", parametro.NameSpace);
}
var sqlLanguage = Template.RetornaValor("SqlLanguage").Value;
var crudBase = parametro.TiposObjetosAcaoBanco.Aggregate(Template.RetornaValor("CrudBase").Value, (current, param) => current.Replace(param.Key, param.Value));
var singleton = parametro.TiposObjetosAcaoBanco.Aggregate(Template.RetornaValor("Singleton").Value, (current, param) => current.Replace(param.Key, param.Value));
var eTipoConsulta = Template.RetornaValor("ETipoConsulta").Value;
var cmdMap = parametro.TiposObjetosAcaoBanco.Aggregate(Template.RetornaValor("CmdMap").Value, (current, param) => current.Replace(param.Key, param.Value));
var transaction = parametro.TiposObjetosAcaoBanco.Aggregate(Template.RetornaValor("Transaction").Value, (current, param) => current.Replace(param.Key, param.Value));
var fastInvoke = Template.RetornaValor("FastInvoke").Value;
var mapExtension = Template.RetornaValor("MapExtension").Value;
var cachingMannager = Template.RetornaValor("CachingMannager").Value;
var eCacheAcao = Template.RetornaValor("ECacheAcao").Value;
var cacheChangedEventArgs = Template.RetornaValor("CacheChangedEventArgs").Value;
var cacheChangedEventHandler = Template.RetornaValor("CacheChangedEventHandler").Value;
var cachingProvider = Template.RetornaValor("ICachingProvider").Value;
File.WriteAllText(string.Format("{0}\\DAL\\DataDrain\\TSqlORM\\DbExpressions.cs", parametro.CaminhoDestino), dbExpressions);
File.WriteAllText(string.Format("{0}\\DAL\\DataDrain\\TSqlORM\\DbExpressionVisitor.cs", parametro.CaminhoDestino), dbExpressionVisitor);
File.WriteAllText(string.Format("{0}\\DAL\\DataDrain\\TSqlORM\\ExpressionVisitor.cs", parametro.CaminhoDestino), expressionVisitor);
File.WriteAllText(string.Format("{0}\\DAL\\DataDrain\\TSqlORM\\QueryExecutor.cs", parametro.CaminhoDestino), queryExecutor);
File.WriteAllText(string.Format("{0}\\DAL\\DataDrain\\TSqlORM\\QueryLanguage.cs", parametro.CaminhoDestino), queryLanguage);
File.WriteAllText(string.Format("{0}\\DAL\\DataDrain\\TSqlORM\\QueryMapping.cs", parametro.CaminhoDestino), queryMapping);
File.WriteAllText(string.Format("{0}\\DAL\\DataDrain\\TSqlORM\\QueryTypeSystem.cs", parametro.CaminhoDestino), queryTypeSystem);
File.WriteAllText(string.Format("{0}\\DAL\\DataDrain\\TSqlORM\\SqlFormatter.cs", parametro.CaminhoDestino), sqlFormatter);
File.WriteAllText(string.Format("{0}\\DAL\\ORM\\FastInvoke.cs", parametro.CaminhoDestino), fastInvoke);
File.WriteAllText(string.Format("{0}\\DAL\\ORM\\MapExtension.cs", parametro.CaminhoDestino), mapExtension);
File.WriteAllText(string.Format("{0}\\DAL\\ORM\\Caching\\CachingMannager.cs", parametro.CaminhoDestino), cachingMannager);
File.WriteAllText(string.Format("{0}\\DAL\\ORM\\Caching\\Enuns\\ECacheAcao.cs", parametro.CaminhoDestino), eCacheAcao);
File.WriteAllText(string.Format("{0}\\DAL\\ORM\\Caching\\Events\\CacheChangedEventArgs.cs", parametro.CaminhoDestino), cacheChangedEventArgs);
File.WriteAllText(string.Format("{0}\\DAL\\ORM\\Caching\\Events\\CacheChangedEventHandler.cs", parametro.CaminhoDestino), cacheChangedEventHandler);
File.WriteAllText(string.Format("{0}\\DAL\\ORM\\Caching\\Interfaces\\ICachingProvider.cs", parametro.CaminhoDestino), cachingProvider);
File.WriteAllText(string.Format("{0}\\DAL\\DataDrain\\Factories\\ISqlFormatter.cs", parametro.CaminhoDestino), ISqlFormatter.Replace("TesteDAL", string.Format("{0}DAL", parametro.NameSpace)));
File.WriteAllText(string.Format("{0}\\DAL\\DataDrain\\Factories\\{1}.cs", parametro.CaminhoDestino, nomeProvider), provider.Replace("TesteDAL", string.Format("{0}DAL", parametro.NameSpace)));
File.WriteAllText(string.Format("{0}\\DAL\\DataDrain\\FuncoesCrud.cs", parametro.CaminhoDestino), funcoesCrud.Replace("TesteDAL", string.Format("{0}DAL", parametro.NameSpace)));
File.WriteAllText(string.Format("{0}\\DAL\\DataDrain\\SqlLanguage.cs", parametro.CaminhoDestino), sqlLanguage.Replace("TesteDAL", string.Format("{0}DAL", parametro.NameSpace)));
File.WriteAllText(string.Format("{0}\\DAL\\Apoio\\Base\\CrudBase.cs", parametro.CaminhoDestino), crudBase.Replace("TesteDAL", string.Format("{0}DAL", parametro.NameSpace)).Replace("{namespace}", parametro.NameSpace));
File.WriteAllText(string.Format("{0}\\DAL\\Apoio\\Conexao\\Singleton.cs", parametro.CaminhoDestino), singleton.Replace("TesteDAL", string.Format("{0}DAL", parametro.NameSpace)));
File.WriteAllText(string.Format("{0}\\DAL\\Apoio\\Enumeradores\\ETipoConsulta.cs", parametro.CaminhoDestino), eTipoConsulta.Replace("TesteDAL", string.Format("{0}DAL", parametro.NameSpace)));
File.WriteAllText(string.Format("{0}\\DAL\\Apoio\\CommandMap\\CmdMap.cs", parametro.CaminhoDestino), cmdMap);
File.WriteAllText(string.Format("{0}\\DAL\\Apoio\\CommandMap\\Transaction.cs", parametro.CaminhoDestino), transaction);
}
private static string AssinaProjeto(ParametrosCriarProjetos parametros)
{
var templateAssembly = Gerador.RetornaTextoBase("ofnIylbmessA");
var tmpAssInfo = string.Empty;
if (parametros.AssinarProjeto)
{
if (string.IsNullOrEmpty(parametros.CaminhoStrongName))
{
var nomeSnkFile = string.Format("{0}.snk", parametros.NameSpace);
GerarKey(string.Format("{0}\\{1}", parametros.CaminhoDestino, nomeSnkFile));
tmpAssInfo = string.Format("[assembly: AssemblyKeyFile({0}\"{1}{2}\")]", "@", "..\\", nomeSnkFile);
}
else
{
tmpAssInfo = string.Format("[assembly: AssemblyKeyFile({0}\"{1}\")]", "@", parametros.CaminhoStrongName);
}
}
templateAssembly = templateAssembly.Replace("{sing}", tmpAssInfo);
return templateAssembly;
}
private static void GeraProjetoWcf(ParametrosCriarProjetos parametros, string guidProjWcf)
{
var servicos = new List<string>();
var servicosCode = new List<string>();
var servicosInterface = new List<string>();
Directory.CreateDirectory(string.Format("{0}\\{1}Wcf\\", parametros.CaminhoDestino, parametros.NameSpace));
Directory.CreateDirectory(string.Format("{0}\\{1}Wcf\\Interface", parametros.CaminhoDestino, parametros.NameSpace));
Directory.CreateDirectory(string.Format("{0}\\{1}Wcf\\Properties", parametros.CaminhoDestino, parametros.NameSpace));
var assemblyInfoWcf = Gerador.RetornaTextoBase("AssemblyInfoWcf").Replace("{namespace}", parametros.NameSpace).Replace("{guid}", Guid.NewGuid().ToString("D"));
File.WriteAllText(string.Format("{0}\\{1}Wcf\\Properties\\AssemblyInfo.cs", parametros.CaminhoDestino, parametros.NameSpace), assemblyInfoWcf);
foreach (var classe in parametros.ObjetosMapeaveis)
{
File.WriteAllText(string.Format("{0}\\{1}Wcf\\{2}.cs", parametros.CaminhoDestino, parametros.NameSpace, classe.Key.NomeObjeto), string.Format("<%@ ServiceHost Language=\"C#\" Debug=\"true\" Service=\"CorpWcf.Aceite\" CodeBehind=\"{0}.svc.cs\" %>", classe.Key.NomeObjeto));
var corpoServico = Gerador.RetornaTextoBase("corpoServico").Replace("{namespace}", parametros.NameSpace).Replace("{classe}", classe.Key.NomeObjeto);
File.WriteAllText(string.Format("{0}\\{1}Wcf\\{2}.svc.cs", parametros.CaminhoDestino, parametros.NameSpace, classe.Key.NomeObjeto), corpoServico);
var corpoInterfaceServico = Gerador.RetornaTextoBase("corpoInterfaceServico").Replace("{namespace}", parametros.NameSpace).Replace("{classe}", classe.Key.NomeObjeto); ;
File.WriteAllText(string.Format("{0}\\{1}Wcf\\Interface\\I{2}.cs", parametros.CaminhoDestino, parametros.NameSpace, classe.Key.NomeObjeto), corpoInterfaceServico);
servicos.Add(string.Format("<Content Include=\"{0}.svc\" />", classe.Key.NomeObjeto));
servicosCode.Add(string.Format("<Compile Include=\"{0}.svc.cs\">{1}<DependentUpon>{0}.svc</DependentUpon>{1}</Compile>", classe.Key.NomeObjeto, Environment.NewLine));
servicosInterface.Add(string.Format("<Compile Include=\"Interface\\I{0}.cs\" />", classe.Key.NomeObjeto));
}
var corpoProjetoWcf = Gerador.RetornaTextoBase("corpoProjetoWcf").Replace("{namespace}", parametros.NameSpace)
.Replace("{servicos}", string.Join("\n", servicos))
.Replace("{servicosCode}", string.Join("\n", servicosCode))
.Replace("[guid]", guidProjWcf)
.Replace("{servicosInterface}", string.Join("\n", servicosInterface));
File.WriteAllText(string.Format("{0}\\{1}Wcf\\{2}Wcf.csproj", parametros.CaminhoDestino, parametros.NameSpace, parametros.NameSpace), corpoProjetoWcf);
var corpoWebConfig = Gerador.RetornaTextoBase("corpoWebConfig");
File.WriteAllText(string.Format("{0}\\{1}Wcf\\Web.config", parametros.CaminhoDestino, parametros.NameSpace), corpoWebConfig);
}
private static void GeraProjetoInterface(ParametrosCriarProjetos parametros, string guidProjInterface, List<string> arquivosInterface, string templateAssembly)
{
var trocasInterface = new Hashtable
{
{"[guid]", guidProjInterface},
{"[namespace]", parametros.NameSpace},
{"[arquivos]", string.Join("\n", arquivosInterface.ToArray())}
};
var projInterface = Gerador.RetornaTextoBase("secafretnIetalpmeT");
projInterface = trocasInterface.Cast<DictionaryEntry>().Aggregate(projInterface, (current, entry) => current.Replace(entry.Key.ToString(), entry.Value.ToString()));
projInterface = projInterface.Replace("[versao]", parametros.VersaoFramework);
var assemblyInterface = templateAssembly.Replace("[log]", "");
assemblyInterface = assemblyInterface.Replace("[namespace]", parametros.NameSpace);
assemblyInterface = assemblyInterface.Replace("[guid]", guidProjInterface);
File.WriteAllText(string.Format("{0}\\Interfaces\\{1}Interfaces.csproj", parametros.CaminhoDestino, parametros.NameSpace), projInterface);
File.WriteAllText(string.Format("{0}\\Interfaces\\Properties\\AssemblyInfo.cs", parametros.CaminhoDestino), assemblyInterface);
}
private static void GeraProjetoDal(ParametrosCriarProjetos parametros, string provider, string guidProjDAL, string guidProjInterface, string guidProjTO, List<string> arquivosDAL, StringBuilder sbLog4Net, string templateAssembly)
{
var trocasDAL = new Hashtable
{
{"[guid]", guidProjDAL},
{"[namespace]", parametros.NameSpace},
{"[guidInterface]", guidProjInterface},
{"[guidTO]", guidProjTO},
{"[provider]", string.Format("<Compile Include=\"DataDrain\\Factories\\{0}.cs\" />", provider)},
{"[arquivos]", string.Join("\n", arquivosDAL.ToArray())},
};
var projDAL = Gerador.RetornaTextoBase("SSLADetalpmet").Replace("[log]", "");
projDAL = trocasDAL.Cast<DictionaryEntry>().Aggregate(projDAL, (current, entry) => current.Replace(entry.Key.ToString(), entry.Value.ToString()));
projDAL = projDAL.Replace("[versao]", parametros.VersaoFramework);
var assemblyDAL = templateAssembly.Replace("[camada]", "DAL").Replace("[log]", "");
assemblyDAL = assemblyDAL.Replace("[namespace]", parametros.NameSpace);
assemblyDAL = assemblyDAL.Replace("[guid]", guidProjDAL);
File.WriteAllText(string.Format("{0}\\DAL\\{1}DAL.csproj", parametros.CaminhoDestino, parametros.NameSpace), projDAL);
File.WriteAllText(string.Format("{0}\\DAL\\Properties\\AssemblyInfo.cs", parametros.CaminhoDestino), assemblyDAL);
}
private static void GeraProjetoBll(ParametrosCriarProjetos parametros, string guidProjBLL, string guidProjInterface, string guidProjTO, string guidProjDAL, List<string> arquivosBLL, StringBuilder sbLog4Net, string templateAssembly)
{
var trocasBLL = new Hashtable
{
{"[guid]", guidProjBLL},
{"[namespace]", parametros.NameSpace},
{"[guidInterface]", guidProjInterface},
{"[guidTO]", guidProjTO},
{"[guidDAL]", guidProjDAL},
{"[arquivos]", string.Join("\n", arquivosBLL.ToArray())},
};
var projBLL = Gerador.RetornaTextoBase("LLBetalpmet").Replace("[log]", "");
projBLL = trocasBLL.Cast<DictionaryEntry>().Aggregate(projBLL, (current, entry) => current.Replace(entry.Key.ToString(), entry.Value.ToString()));
projBLL = projBLL.Replace("[versao]", parametros.VersaoFramework);
var assemblyBLL = templateAssembly.Replace("[camada]", "bll").Replace("[log]", "");
assemblyBLL = assemblyBLL.Replace("[namespace]", parametros.NameSpace);
assemblyBLL = assemblyBLL.Replace("[guid]", guidProjBLL);
File.WriteAllText(string.Format("{0}\\BLL\\{1}BLL.csproj", parametros.CaminhoDestino, parametros.NameSpace), projBLL);
File.WriteAllText(string.Format("{0}\\BLL\\Properties\\AssemblyInfo.cs", parametros.CaminhoDestino), assemblyBLL);
}