public DirectoryInfo trataCaixa(CaixaProperties caixa, ConfiguracaoProperties configApp, ReleaseJucecProperties releaseJucec, string path, ProjetoProperties projetoObj, DocumentosProperties documento)
{
String subStringCaixa = string.Empty;
String destino = string.Empty;
DirectoryInfo dirDestino;
if (caixa.DsCaixa.Length >= 9)
{
subStringCaixa = caixa.DsCaixa.Substring(caixa.DsCaixa.Length - 9);
}
subStringCaixa = subStringCaixa.Replace(".", "");
DateTime dataAtual = DateTime.Now;
string dataAtualFormatada = dataAtual.ToString("yyyyMMdd");
string pathDestino = string.Concat(new string[] { configApp.pastaPrincipal, "TCIReleaseJucec_2017\\", "Data_" + dataAtualFormatada, "\\", "Caixa_" + subStringCaixa, "\\", "Protocolo_" + Util.Util.ajustaDiretorio(releaseJucec.numProtocolo), "\\", "Processo_" + documento.idProcesso.ToString(), "\\", "Documento_" + documento.idDocumento.ToString() });
if (path.Contains(";") && projetoObj.nmProjeto.ToUpper() != "JUCEC - CADASTRO SINCRONIZADO")
{
pathDestino = pathDestino.Replace("NUMERO_PROTOCOLO\\", "NIRE_ARQUIVAMENTO\\");
}
dirDestino = new DirectoryInfo(pathDestino);
return(dirDestino);
}
public FileInfo[] getPdfs(ConfiguracaoProperties configApp, CaixaProperties caixa, DirectoryInfo pathDestino)
{
FileInfo[] filesPdf = new DirectoryInfo(pathDestino.FullName).GetFiles("*_.*pdf", SearchOption.AllDirectories);
log.escreveLog("Arquivos para assinar no diretorio: ", configApp);
return(filesPdf);
}
public ConfiguracaoProperties ConfiguracaoApp()
{
configObj = new ConfiguracaoProperties();
try
{
if (ConfigurationSettings.AppSettings["intervaloExecucaoMinutos"] != null)
{
configObj.intervalo *= 60000;
}
if (ConfigurationSettings.AppSettings["idProjeto"] != null)
{
configObj.idProjeto = int.Parse(ConfigurationSettings.AppSettings["idProjeto"]);
if (ConfigurationSettings.AppSettings["pastaPrincipal"] != null)
{
configObj.pastaPrincipal = ConfigurationSettings.AppSettings["pastaPrincipal"];
configObj.pastaPrincipal += ((configObj.pastaPrincipal.Substring(configObj.pastaPrincipal.Length - 1) != "\\") ? "\\" : "");
}
}
if (ConfigurationSettings.AppSettings["valorFixoArquivo"] != null)
{
configObj.valorFixoArquivo = ConfigurationSettings.AppSettings["valorFixoArquivo"];
}
if (ConfigurationSettings.AppSettings["caminhoLog"] != null)
{
configObj.caminhoLog = ConfigurationSettings.AppSettings["caminhoLog"];
}
if (ConfigurationSettings.AppSettings["nomeCertificado"] != null)
{
configObj.NomeCertificado = ConfigurationSettings.AppSettings["nomeCertificado"];
}
if (ConfigurationSettings.AppSettings["caminhoPdfSemAssinatura"] != null)
{
configObj.caminhoPdfSemAssinatura = ConfigurationSettings.AppSettings["caminhoPdfSemAssinatura"];
}
}
catch (Exception ex)
{
log = new LogUtil();
log.escreveLog(string.Concat(new string[] { "Ocorreu o seguinte erro:", Environment.NewLine, ex.Message, Environment.NewLine, ex.StackTrace }), configObj);
}
return(configObj);
}
public void gerarArquivoXML(DocumentosProperties documento, string xml, ConfiguracaoProperties configApp, DirectoryInfo pathDestino)
{
try
{
this.escreveArquivo(string.Concat(new object[]
{
pathDestino.Parent.FullName.Replace("\\NUMERO_PROTOCOLO\\", "\\NIRE_ARQUIVAMENTO\\"), "\\", documento.idProcesso, ".xml"
}), xml);
}
catch (Exception ex)
{
log.escreveLog("Erro em geraArquivoSefaz XML :" + ex.Message + "\n" + ex.StackTrace, configApp);
}
}
public void atualizarStatusProtocolo(ProtocoloProperties protocolo, ConfiguracaoProperties configApp)
{
log.escreveLog("atualizarStatusProtocoloDao: ", configApp);
bool statusOk = dao.atualizaProtocolo(protocolo);
if (statusOk)
{
log.escreveLog("Status alterado com seucesso IdProtocolo" + protocolo.idProtocolo, configApp);
}
else
{
log.escreveLog("Erro ao alterar o status IdProtocolo" + protocolo.idProtocolo, configApp);
}
}
public List <ProtocoloProperties> pesquisaProtocolosLiberadosCarga(ConfiguracaoProperties configApp)
{
ProtocoloProperties protocoloProperties = null;
SqlConnection con = ConnectionFactory.ConnectionFactory.getConnection();
List <ProtocoloProperties> listaProtocoloProperties = new List <ProtocoloProperties>();
try
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("select distinct dsprotocolo, idprotocolo from (");
sb.AppendLine("select a.dsprotocolo, b.idprotocolo, b.idcaixa, count(b.idprocesso)totalProcessos, count(c.idprocesso)totalProcessosAprovados ");
sb.AppendLine("from tb_protocolo a with(nolock)");
sb.AppendLine("inner join tb_processo b with(nolock) on a.idprotocolo = b.idprotocolo and a.idprojeto = " + configApp.idProjeto + " and b.idstatus not in(24,16,15)");
sb.AppendLine("left join tb_processo c with(nolock) on b.idprocesso = c.idprocesso and b.idstatus = " + Constantes.PRONTO_PARA_ENVIO);
sb.AppendLine("group by a.dsprotocolo, b.idprotocolo, b.idcaixa)a1");
sb.AppendLine("where totalProcessos = totalProcessosAprovados");
sb.AppendLine("order by 1");
con.Open();
SqlCommand cmd = new SqlCommand(sb.ToString(), con);
cmd.CommandType = CommandType.Text;
cmd.CommandTimeout = 120;
IDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
protocoloProperties = new ProtocoloProperties();
protocoloProperties.idProtocolo = reader.GetInt32(reader.GetOrdinal("idprotocolo"));
protocoloProperties.dsProtocolo = reader.GetString(reader.GetOrdinal("dsprotocolo"));
listaProtocoloProperties.Add(protocoloProperties);
}
}
catch (Exception ex)
{
throw new Exception("Erro ao pesquisaDocumentosLiberadosCarga: " + ex.ToString() + "\n" + ex.StackTrace);
}
finally
{
ConnectionFactory.ConnectionFactory.fechaConexão(con);
}
return(listaProtocoloProperties);
}
public ProjetoProperties getProjeto(ConfiguracaoProperties configApp)
{
SqlConnection con = ConnectionFactory.ConnectionFactory.getConnection();
ProjetoProperties projeto = new ProjetoProperties();
try
{
String strSql = "select idProjeto,NmProjeto,NmProjetoCompleto,Ativo,TemCapturaDistribuida,QtHoraExpurgo,DtAtualizacao,QtDiaExpurgoBaseLocal,MsRelPCP from tb_projeto with(nolock) where idProjeto = " + configApp.idProjeto;
con.Open();
SqlCommand cmd = new SqlCommand(strSql, con);
cmd.CommandType = CommandType.Text;
cmd.CommandTimeout = 120;
IDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
projeto.idProjeto = reader.GetInt32(reader.GetOrdinal("IdProjeto"));
projeto.nmProjeto = reader.GetString(reader.GetOrdinal("NmProjeto"));
projeto.nmProjetoCompleto = reader.GetString(reader.GetOrdinal("NmProjetoCompleto"));
projeto.ativo = reader.GetBoolean(reader.GetOrdinal("Ativo"));
projeto.temCaptureDistribuida = reader.GetBoolean(reader.GetOrdinal("TemCapturaDistribuida"));
projeto.QHoraExpurgo = reader.GetInt32(reader.GetOrdinal("QtHoraExpurgo"));
projeto.dtAtualizacao = reader.GetDateTime(reader.GetOrdinal("DtAtualizacao"));
projeto.qtDiaExpurgoBaseLocal = reader.GetInt32(reader.GetOrdinal("QtDiaExpurgoBaseLocal"));
projeto.msRefPCP = reader.GetString(reader.GetOrdinal("MsRelPCP"));
}
}
catch (Exception ex)
{
throw new Exception("Erro getProjeto: " + ex.Message + "\n" + ex.ToString());
}
finally
{
ConnectionFactory.ConnectionFactory.fechaConexão(con);
}
return(projeto);
}
public void escreveLog(string msg, ConfiguracaoProperties config)
{
try
{
if (!string.IsNullOrEmpty(config.caminhoLog))
{
if (!Directory.Exists(config.caminhoLog + "\\log\\"))
{
Directory.CreateDirectory(config.caminhoLog);
}
}
using (StreamWriter streamWriter = new StreamWriter(config.caminhoLog + "log" + DateTime.Now.ToString("yyyyMMdd_HH") + "00.txt", true, Encoding.Default))
{
streamWriter.WriteLine(DateTime.Now.ToString("dd/MM/yyyy HH:mm:ss") + " - " + msg);
streamWriter.Close();
}
}
catch (Exception ex)
{
MessageBox.Show(ex.StackTrace);
}
}
public ParametroProdutoProjetoProperties getParametroProdutoProjeto(ProjetoProperties projetoObj, ConfiguracaoProperties configApp)
{
ParametroProdutoProjetoProperties parametroProdutoProjetoProperties = dao.parametroProdutoProjeto(projetoObj);
log.escreveLog(string.Concat(new object[] { "Parametro produto projeto ", parametroProdutoProjetoProperties.NmValorParametro, "para o id projeto", projetoObj.idProjeto }), configApp);
return(parametroProdutoProjetoProperties);
}
public ThreadTci()
{
configObj = new ConfiguracaoProperties();
this.InitializeComponent();
}
public ReleaseJucecProperties getImagem(DocumentosProperties documento, ReleaseJucecProperties releaseJucec, ConfiguracaoProperties configApp, ParametroProdutoProjetoProperties parametroProdutoProjetoPropertie, DirectoryInfo pathDestino, ProjetoProperties projetoObj)
{
ImagemDao dao = new ImagemDaoImpl();
try
{
List <ImagemProperties> listaImagems = dao.ImagemProcessa(documento);
log.escreveLog("Quantidade de imagem para o documento " + documento.idDocumento.ToString() + listaImagems.Count.ToString(), configApp);
if (listaImagems.Count > 0)
{
//releaseJucec.penultimaImg = listaImagems[listaImagems.Count - 2].NmImagem;
//log.escreveLog("PenultimaImg " + releaseJucec.penultimaImg, configApp);
releaseJucec.flagSemImagem = true;
}
else
{
//releaseJucec.penultimaImg = string.Empty;
//log.escreveLog("PenultimaImg " + releaseJucec.penultimaImg, configApp);
releaseJucec.flagSemImagem = true;
}
if (releaseJucec.flagSemImagem)
{
releaseJucec.ultimaImg = listaImagems[listaImagems.Count - 1].NmImagem;
log.escreveLog("UltimaImg " + releaseJucec.ultimaImg, configApp);
FileInfo fileDestinoPdf = null;
foreach (ImagemProperties imagem in listaImagems)
{
log.escreveLog("lendo a imagem id " + imagem.IdImagem + " Nome imagem " + imagem.NmImagem, configApp);
log.escreveLog("Caminho da imagem no banco " + imagem.NmCaminhoImagem, configApp);
FileInfo fileOrigem = new FileInfo(parametroProdutoProjetoPropertie.NmValorParametro + imagem.NmCaminhoImagem);
log.escreveLog("Origem da imagem .Tiff " + fileOrigem.FullName.ToString(), configApp);
log.escreveLog("Destino do .CSV, .PDF sem assinatura, .PDF assinado " + pathDestino.FullName, configApp);
fileDestinoPdf = new FileInfo(pathDestino.FullName + "\\");
log.escreveLog("Destino com PDF " + fileDestinoPdf.FullName.ToString(), configApp);
if (!fileDestinoPdf.Directory.Exists)
{
fileDestinoPdf.Directory.Create();
}
if (new FileInfo(fileOrigem.FullName).Exists)
{
if (projetoObj.nmProjeto.ToUpper() != Constantes.DESCRICSO_PROJETO)
{
fileOrigem.CopyTo(fileDestinoPdf.FullName, true);
}
else
{
fileDestinoPdf = new FileInfo(string.Concat(new object[] { fileDestinoPdf.FullName, "\\", releaseJucec.numProtocolo, "_.pdf" }));
this.processaImagem(fileOrigem, fileDestinoPdf, listaImagems.Count, configApp);
dao.logImagem(imagem, Constantes.ENVIADO_FTP);
}
log.escreveLog("A Imagem [" + fileOrigem.FullName + "] copiada para o diretorio " + fileDestinoPdf.FullName, configApp);
}
else
{
log.escreveLog("A Imagem [" + fileOrigem.FullName + "] não existe no diretorio", configApp);
}
}
}
// processo
//dao.atualizaStatus(imagem, Constantes.PDF_GERADO);
releaseJucec.flag = true;
}
catch (Exception ex)
{
log.escreveLog("Erro ao tentar processaImagem:" + ex.Message + "\n" + ex.StackTrace, configApp);
throw new Exception(ex.Message + "\n" + ex.StackTrace);
}
return(releaseJucec);
}
public List <ProtocoloProperties> getProtocoloProtocolosLiberado(ConfiguracaoProperties configApp)
{
log.escreveLog("Pesquisando por protocolo liberado ", configApp);
return(dao.pesquisaProtocolosLiberadosCarga(configApp));
}
private void assinarArquivo(FileInfo arquivoAssinar, ReleaseJucecProperties releaseJucec, ConfiguracaoProperties configApp)
{
clsPDF clsPDF = new clsPDF();
string xml = string.Empty;
string idCertificadoNOde = string.Empty;
try
{
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml(new clsCertificados
{
Licenca = this.pegaCodLicenca()
}.ListarCertificadosPessoais());
if (string.IsNullOrEmpty(configApp.NomeCertificado))
{
throw new Exception("Tag [nomeCertificado] não configurada no arquivo .config.");
}
log.escreveLog("Buscando Certificado" + "Nome do Certificado " + configApp.NomeCertificado, configApp);
foreach (XmlNode xmlNode in xmlDocument.SelectNodes("//Certificado"))
{
log.escreveLog("XML Node: " + xmlNode.InnerText.ToUpper(), configApp);
if (xmlNode.InnerText.ToUpper().Contains(configApp.NomeCertificado.ToUpper()))
{
idCertificadoNOde = xmlNode.SelectSingleNode("IDCertificado").FirstChild.InnerText;
log.escreveLog(string.Format("Id do Certificado {0} encontrado para {1}:...", configApp.NomeCertificado.ToString(), idCertificadoNOde), configApp);
break;
}
}
if (string.IsNullOrEmpty(idCertificadoNOde))
{
throw new Exception(string.Format("Certificado não encontrado nesta maquina [{0}]!.{1}É preciso existir um certificado válido para [{2}]", Environment.MachineName, Environment.NewLine, idCertificadoNOde));
}
clsPDF.Licenca = this.pegaCodLicenca();
xml = clsPDF.Assinar(this.carregaXML(arquivoAssinar, idCertificadoNOde));
log.escreveLog("Aviso: " + xml.ToString(), configApp);
log.escreveLog("Aviso: Caminho: " + arquivoAssinar.FullName, configApp);
xmlDocument.LoadXml(xml);
string xmlErro = xmlDocument.SelectSingleNode("//DeskSignerSDKPDF/CodErro").FirstChild.InnerText;
if (xmlErro != "0")
{
log.escreveLog("Erro ao assinar o Arquivo " + this.traducaoErro(xmlErro).ToString(), configApp);
}
}
catch (Exception ex)
{
log.escreveLog("Erro ao assinar o Arquivo " + ex.ToString(), configApp);
throw ex;
}
finally
{
clsPDF = null;
}
}
public bool arquivoParaAssinar(FileInfo filePdf, ReleaseJucecProperties releaseJucec, ConfiguracaoProperties configApp)
{
bool pdfisOk = true;
try
{
if (filePdf.Exists)
{
log.escreveLog("inicio da assinatura do PDF: " + filePdf.FullName, configApp);
this.assinarArquivo(filePdf, releaseJucec, configApp);
}
}
catch (Exception ex)
{
pdfisOk = false;
log.escreveLog("Erro : " + ex.Message + Environment.NewLine + ex.StackTrace, configApp);
filePdf.Delete();
}
return(pdfisOk);
}
// Autor:Eduardo Nofre
// Date: 04/04/2017
// Motivação: solicitação do cliente para o Rafael Lira que esteve no cliente em Recifie
// action: move os arquivos pdf sem assinatura para um diretorio definido pelo cliente
// essa configuração fica no appConfig ou melhor appConfig.ini
public Boolean moverPdfSemAssinaturaSRM(FileInfo arquivoMover, ReleaseJucecProperties releaseJucec, DocumentosProperties documento, ConfiguracaoProperties configApp)
{
RegrasDocumentos regrasDocumentos = new RegrasDocumentos();
bool isJucec = regrasDocumentos.tipoIndexDocumento_Jucec_Sesaz(documento);
if (isJucec)
{
if (arquivoMover.FullName != "")
{
FileInfo dirOrigemPdf = new FileInfo(arquivoMover.FullName);
if (Directory.Exists(configApp.caminhoPdfSemAssinatura))
{
if (!File.Exists(configApp.caminhoPdfSemAssinatura + "\\" + releaseJucec.numProtocolo + ".pdf"))
{
System.IO.File.Copy(arquivoMover.FullName, configApp.caminhoPdfSemAssinatura + "\\" + releaseJucec.numProtocolo + ".pdf");
log.escreveLog(".PDF sem assinatura enviado para o SRM " + arquivoMover.Name, configApp);
regrasDocumentos.LogDocumento(documento, Constantes.ENVIADO_SRM);
return(true);
}
else
{
log.escreveLog("Aviso: Não foi possivel enviar para o SRM porque talvez o arquivo pdf ja exista neste diretorio " + configApp.caminhoPdfSemAssinatura + "\\" + releaseJucec.numProtocolo + ".pdf", configApp);
return(true);
}
}
else
{
log.escreveLog("Aviso: Diretorio não existe " + configApp.caminhoPdfSemAssinatura, configApp);
System.IO.Directory.CreateDirectory(configApp.caminhoPdfSemAssinatura);
if (Directory.Exists(configApp.caminhoPdfSemAssinatura))
{
log.escreveLog("Aviso: Diretorio criado comsucesso " + configApp.caminhoPdfSemAssinatura, configApp);
System.IO.File.Copy(arquivoMover.FullName, configApp.caminhoPdfSemAssinatura + "\\" + releaseJucec.numProtocolo + ".pdf");
log.escreveLog("Aviso: Enviado SRM " + arquivoMover.Name, configApp);
regrasDocumentos.LogDocumento(documento, Constantes.ENVIADO_SRM);
return(true);
}
else
{
log.escreveLog("Não foi possivel criar o diretorio verifique a permissão na pasta protocolo SRM" + releaseJucec.numProtocolo, configApp);
return(false);
}
}
}
}
return(false);
}
public ReleaseJucecProperties getIndexerProcesso(DocumentosProperties documento, ProjetoProperties projetoObj, ProtocoloProperties protocolo, ConfiguracaoProperties configApp)
{
try
{
List <ValorIndiceProcessoProperties> listaIndexerProcesso = dao.indexerProcesso(documento);
if (listaIndexerProcesso.Count > 0)
{
releaseJucec = new ReleaseJucecProperties();
foreach (ValorIndiceProcessoProperties indexerProcesso in listaIndexerProcesso)
{
// siarco consulta para carregar os indices
if (indexerProcesso.indiceObject.NmIndiceSistema != null)
{
if (!(indexerProcesso.indiceObject.NmIndiceSistema == "NUMERO_PROTOCOLO"))
{
if (!(indexerProcesso.indiceObject.NmIndiceSistema == "NIRE"))
{
if (!(indexerProcesso.indiceObject.NmIndiceSistema == "CNPJ"))
{
if (!(indexerProcesso.indiceObject.NmIndiceSistema == "NOME_EMPRESARIAL"))
{
if (!(indexerProcesso.indiceObject.NmIndiceSistema == "ATO"))
{
if (!(indexerProcesso.indiceObject.NmIndiceSistema == "EVENTO"))
{
if (!(indexerProcesso.indiceObject.NmIndiceSistema == "DESCRICAO"))
{
if (!(indexerProcesso.indiceObject.NmIndiceSistema == "MUNICIPIO"))
{
if (indexerProcesso.indiceObject.NmIndiceSistema == "NUMERO_ARQUIVAMENTO")
{
if (!string.IsNullOrEmpty(indexerProcesso.NmValorIndiceProcesso.ToString().Trim()))
{
releaseJucec.numArquivamento = indexerProcesso.NmValorIndiceProcesso;
}
else
{
releaseJucec.numArquivamento = "000000";
}
}
}
else
{
releaseJucec.municipio = indexerProcesso.NmValorIndiceProcesso.ToString();
}
}
else
{
releaseJucec.descricao = indexerProcesso.NmValorIndiceProcesso.ToString();
}
}
else
{
releaseJucec.evento = indexerProcesso.NmValorIndiceProcesso.ToString();
}
}
else
{
releaseJucec.ato = indexerProcesso.NmValorIndiceProcesso.ToString();
}
}
else
{
releaseJucec.nomeempresarial = indexerProcesso.NmValorIndiceProcesso.ToString();
}
}
else
{
releaseJucec.cnpj = indexerProcesso.NmValorIndiceProcesso.ToString();
}
}
else if (!string.IsNullOrEmpty(indexerProcesso.NmValorIndiceProcesso.ToString().Trim()))
{
releaseJucec.nire = indexerProcesso.NmValorIndiceProcesso.ToString();
}
}
else
{
releaseJucec.numProtocolo = indexerProcesso.NmValorIndiceProcesso.ToString();
}
}
}
}
if (projetoObj.nmProjeto.ToUpper() != "JUCEC - CADASTRO SINCRONIZADO")
{
if (projetoObj.nmProjeto != string.Empty)
{
releaseJucec.nireConcatnumArquivamento = releaseJucec.nireConcatnumArquivamento + "\\" + protocolo.dsProtocolo;
}
else if (releaseJucec.nire != string.Empty && releaseJucec.numArquivamento != string.Empty)
{
string concat = releaseJucec.nireConcatnumArquivamento;
releaseJucec.nireConcatnumArquivamento = string.Concat(new string[] { concat, "\\", releaseJucec.nire, "\";\"", releaseJucec.numArquivamento });
}
else
{
releaseJucec.nireConcatnumArquivamento += "\\000\";\"000000";
}
}
else
{
string text3 = releaseJucec.nireConcatnumArquivamento;
releaseJucec.nireConcatnumArquivamento = string.Concat(new string[] { text3, "\\", releaseJucec.nire, "\";\"", releaseJucec.numArquivamento });
}
}
catch (Exception ex)
{
if (ex.Message.Contains("Quantidade de Indices"))
{
log.escreveLog(ex.Message + Environment.NewLine + ex.StackTrace, configApp);
return(null);
}
throw new Exception("Erro em obterNumProtocolo:" + ex.Message + "\n" + ex.StackTrace);
}
releaseJucec.nireConcatnumArquivamento = releaseJucec.nireConcatnumArquivamento.Replace("\\", "").Replace("/", "").Replace("-", "").Replace("_", "");
return(releaseJucec);
}
private void processaImagem(FileInfo origem, FileInfo destino, int QtdImgDoc, ConfiguracaoProperties configApp)
{
try
{
destino = new FileInfo(string.Concat(new string[] {
destino.Directory.FullName.Replace("\\NUMERO_PROTOCOLO\\", "\\NIRE_ARQUIVAMENTO\\"), "\\", destino.Name
}));
if (!destino.Directory.Exists)
{
destino.Directory.Create();
}
ClassUtil.Instancia.ConvertTIFtoMultiPage(origem, destino, "pdf");
}
catch (Exception ex)
{
log.escreveLog("Erro ao tentar processaImagemSefaz: " + "\n" + ex.Message + "\n" + ex.StackTrace, configApp);
throw new Exception(ex.Message + "\n" + ex.StackTrace);
}
}
public ProjetoProperties getProjeto(ConfiguracaoProperties configApp)
{
log.escreveLog("Pesquisando projeto", configApp);
return(dao.getProjeto(configApp));
}
public MainPrincipal()
{
this.InitializeComponent();
this.configApp = config.ConfiguracaoApp();
}