private void Importar1DoSinacor()
{
ReceberEntidadeCadastroResponse <SinacorClienteInfo> RetornoClienteSinacor = new ReceberEntidadeCadastroResponse <SinacorClienteInfo>();
ReceberEntidadeCadastroRequest <SinacorClienteInfo> EntradaClienteSinacor = new ReceberEntidadeCadastroRequest <SinacorClienteInfo>();
EntradaClienteSinacor.EntidadeCadastro = new SinacorClienteInfo();
EntradaClienteSinacor.EntidadeCadastro.ChaveCliente = new SinacorChaveClienteInfo()
{
CD_CON_DEP = 1,
DT_NASC_FUND = new DateTime(1965, 08, 24),
CD_CPFCGC = 11137855860
};
//Pegando o cliente completo do Sinacor
RetornoClienteSinacor = ServicoPersistenciaCadastro.ReceberEntidadeCadastro <SinacorClienteInfo>(EntradaClienteSinacor);
SalvarEntidadeCadastroRequest <SinacorClienteInfo> EntradaCliente = new SalvarEntidadeCadastroRequest <SinacorClienteInfo>();
SalvarEntidadeCadastroResponse RetornoCliente = new SalvarEntidadeCadastroResponse();
EntradaCliente.EntidadeCadastro = RetornoClienteSinacor.EntidadeCadastro;
//Salvando no Cadastro
RetornoCliente = ServicoPersistenciaCadastro.SalvarEntidadeCadastro <SinacorClienteInfo>(EntradaCliente);
VerificaErro(RetornoCliente);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="parametros"></param>
/// <returns></returns>
public ReceberEntidadeCadastroResponse <T> ReceberEntidadeCadastro <T>(ReceberEntidadeCadastroRequest <T> parametros) where T : ICodigoEntidade
{
IServicoPersistencia servicoPersistencia = Ativador.Get <IServicoPersistencia>();
ReceberEntidadeCadastroResponse <T> resposta =
new ReceberEntidadeCadastroResponse <T>()
{
CodigoMensagemRequest = parametros.CodigoMensagem
};
try
{
logger.Error("respostaReceber");
ReceberObjetoResponse <T> respostaReceber =
servicoPersistencia.ReceberObjeto <T>(
new ReceberEntidadeRequest <T>()
{
Objeto = parametros.EntidadeCadastro,
IdUsuarioLogado = parametros.IdUsuarioLogado,
DescricaoUsuarioLogado = parametros.DescricaoUsuarioLogado
});
resposta.EntidadeCadastro = respostaReceber.Objeto;
}
catch (Exception ex)
{
logger.Error(parametros, ex);
resposta.DescricaoResposta = ex.ToString();
resposta.StatusResposta = MensagemResponseStatusEnum.ErroPrograma;
}
return(resposta);
}
public ReceberEntidadeCadastroResponse <T> ReceberEntidadeCadastro <T>(ReceberEntidadeCadastroRequest <T> pParametros) where T : ICodigoEntidade
{
if (typeof(T) == typeof(ClienteInfo))
{
ReceberEntidadeCadastroResponse <ClienteInfo> lResponse = new ReceberEntidadeCadastroResponse <ClienteInfo>();
lResponse.EntidadeCadastro = RetornarClienteInfo(pParametros.CodigoEntidadeCadastro);
lResponse.CodigoMensagemRequest = pParametros.CodigoMensagem;
return(lResponse as ReceberEntidadeCadastroResponse <T>);
}
else if (typeof(T) == typeof(ClienteSituacaoFinanceiraPatrimonialInfo))
{
ReceberEntidadeCadastroResponse <ClienteSituacaoFinanceiraPatrimonialInfo> lResponse = new ReceberEntidadeCadastroResponse <ClienteSituacaoFinanceiraPatrimonialInfo>();
lResponse.EntidadeCadastro = RetornarClienteSituacaoFinanceiraPatrimonialInfo(pParametros.CodigoEntidadeCadastro);
lResponse.CodigoMensagemRequest = pParametros.CodigoMensagem;
return(lResponse as ReceberEntidadeCadastroResponse <T>);
}
else
{
return(null);
}
}
private string ValidaClienteCompleto()
{
var lRetorno = new StringBuilder();
int lIdCliente = this.GetIdCliente;
//Ver assessor Inicial
ReceberEntidadeCadastroResponse <ClienteInfo> lCliente =
this.ServicoPersistenciaCadastro.ReceberEntidadeCadastro <ClienteInfo>(
new ReceberEntidadeCadastroRequest <ClienteInfo>()
{
EntidadeCadastro = new ClienteInfo()
{
IdCliente = lIdCliente
}
});
if (lCliente.EntidadeCadastro.TpDesejaAplicar.ToUpper().Contains("CAM") || lCliente.EntidadeCadastro.TpDesejaAplicar.ToUpper().Contains("TODAS") || lCliente.EntidadeCadastro.TpDesejaAplicar.ToUpper().Contains("TODOS"))
{
TemFichaCambio = true;
}
DesejaAplicar = lCliente.EntidadeCadastro.TpDesejaAplicar.ToUpper();
if (lCliente.EntidadeCadastro.StPasso < 4 && (lCliente.EntidadeCadastro.IdAssessorInicial == null || lCliente.EntidadeCadastro.IdAssessorInicial == 0))
{
lRetorno.Append("\n\tO Cliente Precisa ter um Assessor Inicial Cadastrado;");
}
ClienteBancoInfo lBancoPrincipal = Gradual.Intranet.Servicos.BancoDeDados.Persistencias.ClienteDbLib.GetClienteBancoPrincipal(lCliente.EntidadeCadastro);
ClienteEnderecoInfo lEnderecoPrincipal = Gradual.Intranet.Servicos.BancoDeDados.Persistencias.ClienteDbLib.GetClienteEnderecoPrincipal(lCliente.EntidadeCadastro);
ClienteTelefoneInfo lTelefonePrincipal = Gradual.Intranet.Servicos.BancoDeDados.Persistencias.ClienteDbLib.GetClienteTelefonePrincipal(lCliente.EntidadeCadastro);
//Telefone
if (null == lTelefonePrincipal || null == lTelefonePrincipal.DsNumero || lTelefonePrincipal.DsNumero.Trim().Length == 0)
{
lRetorno.Append("\n\tÉ Necessário Cadastrar um Telefone Principal para o Cliente;");
}
//Endereço
if (null == lEnderecoPrincipal || null == lEnderecoPrincipal.DsLogradouro || lEnderecoPrincipal.DsLogradouro.Trim().Length == 0)
{
lRetorno.Append("\n\tÉ Necessário Cadastrar um Endereço Principal para o Cliente;");
}
//Conta Bancária
if (null == lBancoPrincipal || null == lBancoPrincipal.DsAgencia || lBancoPrincipal.DsAgencia.Trim().Length == 0)
{
lRetorno.Append("\n\tÉ Necessário Cadastrar uma Conta Bancária Principal para o Cliente.");
}
return(lRetorno.ToString());
}
private void ResponderBuscarItensParaListagemSimples()
{
gDadosCorretagem = null;
gDadosCadastrais = null;
gDadosCarteira = null;
this.CarregarDadosCadastrais();
this.CarregarCorretagem();
this.CarregarCarteiras();
}
private string ResponderCarregarHtmlComDados()
{
var lPendencias = string.Empty;
var lEntradaPendencia = new ReceberEntidadeCadastroRequest <TipoDePendenciaCadastralInfo>();
var lRetornoPendencia = new ReceberEntidadeCadastroResponse <TipoDePendenciaCadastralInfo>();
var lEntradaPendenciaCliente = new ConsultarEntidadeCadastroRequest <ClientePendenciaCadastralInfo>()
{
EntidadeCadastro = new ClientePendenciaCadastralInfo()
{
IdCliente = this.GetIdCliente
}
};
var lRetornoPendenciaCliente = this.ServicoPersistenciaCadastro.ConsultarEntidadeCadastro <ClientePendenciaCadastralInfo>(lEntradaPendenciaCliente);
if (lRetornoPendenciaCliente.StatusResposta != MensagemResponseStatusEnum.OK)
{
return(RetornarErroAjax("Erro ao verificar pendências cadastrais", lRetornoPendenciaCliente.DescricaoResposta));
}
foreach (ClientePendenciaCadastralInfo item in lRetornoPendenciaCliente.Resultado)
{ // Pegar apenas as sem baixa
if (null == item.DtResolucao || item.DtResolucao.Value == DateTime.MinValue)
{
lEntradaPendencia = new ReceberEntidadeCadastroRequest <TipoDePendenciaCadastralInfo>();
lEntradaPendencia.EntidadeCadastro = new TipoDePendenciaCadastralInfo();
lEntradaPendencia.EntidadeCadastro.IdTipoPendencia = item.IdTipoPendencia;
lRetornoPendencia = this.ServicoPersistenciaCadastro.ReceberEntidadeCadastro <TipoDePendenciaCadastralInfo>(lEntradaPendencia);
if (lRetornoPendencia.StatusResposta != MensagemResponseStatusEnum.OK)
{
return(RetornarErroAjax("Erro ao verificar pendências cadastrais", lRetornoPendencia.DescricaoResposta));
}
lPendencias += string.Concat(lRetornoPendencia.EntidadeCadastro.DsPendencia, "<br/>");
}
}
if (lPendencias.Trim().Length > 0)
{
//Exibir mensagem em Vermelho
this.spnClientes_SincronizarComSinacor_PendenciaCadastral.InnerHtml = string.Concat("A exportação de clientes com pendências pode acarretar em problemas de auditoria.<br/>O cliente possui as pendências cadastrais descritas abaixo.<br />", lPendencias);
}
else
{
this.spnClientes_SincronizarComSinacor_PendenciaCadastral.InnerHtml = "";
}
return(string.Empty);
}
private void ResponderBuscarItensParaListagemSimples()
{
gResumoDoAssessorCadastro = null;
gResumoDoAssessorReceita = null;
gResumoDoAssessorCanal = null;
gResumoDoAssessorMetricas = null;
gResumoDoAssessorTop10 = null;
this.CarregarDadosCadastro();
this.CarregarDadosReceita();
this.CarregarDadosCanal();
this.CarregarDadosMetricas();
this.CarregarClientesTop10();
}
public decimal CalcularTaxaPtax(decimal taxaOperada)
{
decimal lRetorno = 0.0M;
ReceberEntidadeCadastroRequest <MonitoramentoRiscoLucroTaxaPTAXInfo> lRequest =
new ReceberEntidadeCadastroRequest <MonitoramentoRiscoLucroTaxaPTAXInfo>();
ReceberEntidadeCadastroResponse <MonitoramentoRiscoLucroTaxaPTAXInfo> lResponse =
new ReceberEntidadeCadastroResponse <MonitoramentoRiscoLucroTaxaPTAXInfo>();
lResponse = ServicoPersistenciaCadastro.ReceberEntidadeCadastro <MonitoramentoRiscoLucroTaxaPTAXInfo>(lRequest);
decimal taxaMercado = lResponse.EntidadeCadastro.ValorPtax;
lRetorno = taxaOperada * taxaMercado;
return(lRetorno);
}
public void SelecionarAtivacao()
{
ReceberEntidadeCadastroResponse <ClienteAtivarInativarInfo> RetornoClienteAtivar = new ReceberEntidadeCadastroResponse <ClienteAtivarInativarInfo>();
ReceberEntidadeCadastroRequest <ClienteAtivarInativarInfo> EntradaClienteAtivar = new ReceberEntidadeCadastroRequest <ClienteAtivarInativarInfo>();
EntradaClienteAtivar.EntidadeCadastro = new ClienteAtivarInativarInfo()
{
IdCliente = 71089
};
RetornoClienteAtivar = ServicoPersistenciaCadastro.ReceberEntidadeCadastro <ClienteAtivarInativarInfo>(EntradaClienteAtivar);
SalvarEntidadeCadastroRequest <ClienteAtivarInativarInfo> EntradaSalvar = new SalvarEntidadeCadastroRequest <ClienteAtivarInativarInfo>();
EntradaSalvar.EntidadeCadastro = RetornoClienteAtivar.EntidadeCadastro;
//Testar Alterações
SalvarEntidadeCadastroResponse RetornoSalvar = ServicoPersistenciaCadastro.SalvarEntidadeCadastro <ClienteAtivarInativarInfo>(EntradaSalvar);
}
public void ProcessRequest(HttpContext context)
{
int id = int.Parse(context.Request.QueryString["ID"]);
ReceberEntidadeCadastroRequest <ArquivoContratoInfo> lRequest = new ReceberEntidadeCadastroRequest <ArquivoContratoInfo>()
{
EntidadeCadastro = new ArquivoContratoInfo()
{
IdArquivoContrato = id
}
};
ReceberEntidadeCadastroResponse <ArquivoContratoInfo> lResponse = new ReceberEntidadeCadastroResponse <ArquivoContratoInfo>();
IServicoPersistenciaCadastro iServicoPersistencia = RetornarServicoPersistencia(context);
lResponse = iServicoPersistencia.ReceberEntidadeCadastro <ArquivoContratoInfo>(lRequest);
context.Response.ContentType = lResponse.EntidadeCadastro.MIMEType;
context.Response.AddHeader("Content-Disposition", "attachment; filename=" + lResponse.EntidadeCadastro.Nome);
context.Response.AddHeader("Content-Length", lResponse.EntidadeCadastro.Tamanho.ToString());
//context.Response.OutputStream.
context.Response.OutputStream.Write(lResponse.EntidadeCadastro.Arquivo, 0, lResponse.EntidadeCadastro.Tamanho);
}
public void VerificaErro(ReceberEntidadeCadastroResponse <MensagemAjudaInfo> pObjeto)
{
VerificaErro(pObjeto.StatusResposta, pObjeto.DescricaoResposta);
}
private string ResponderBuscarItensParaSelecao()
{
string lRetorno = "Erro...";
var lRequest = new ConsultarEntidadeCadastroRequest <ClienteResumidoInfo>();
var lResponse = new ConsultarEntidadeCadastroResponse <ClienteResumidoInfo>();
var lDadosDeBusca = new ClienteResumidoInfo();
string lTermoDeBusca, lBuscarPor, lTipo;
bool lStatus_Ativo = false, lStatus_Inativo = false,
lPasso_Visitante = false, lPasso_Cadastrado = false, lPasso_ExportadoSinacor = false,
lPendencia_ComPendenciaCadastral = false, lPendencia_ComSolicitacaoAlteracao = false;
lTermoDeBusca = Request.Form["TermoDeBusca"];
lBuscarPor = Request.Form["BuscarPor"];
lTipo = Request.Form["Tipo"];
try
{
lStatus_Ativo = Convert.ToBoolean(Request.Form["Status_Ativo"]);
lStatus_Inativo = Convert.ToBoolean(Request.Form["Status_Inativo"]);
lPasso_Visitante = Convert.ToBoolean(Request.Form["Passo_Visitante"]);
lPasso_Cadastrado = Convert.ToBoolean(Request.Form["Passo_Cadastrado"]);
lPasso_ExportadoSinacor = Convert.ToBoolean(Request.Form["Passo_ExportadoSinacor"]);
lPendencia_ComPendenciaCadastral = Convert.ToBoolean(Request.Form["Pendencia_ComPendenciaCadastral"]);
lPendencia_ComSolicitacaoAlteracao = Convert.ToBoolean(Request.Form["Pendencia_ComSolicitacaoAlteracao"]);
}
catch { }
lDadosDeBusca.TipoCliente = lTipo;
lDadosDeBusca.TermoDeBusca = lTermoDeBusca;
try
{
lDadosDeBusca.OpcaoBuscarPor = (OpcoesBuscarPor)Enum.Parse(typeof(OpcoesBuscarPor), lBuscarPor);
}
catch (Exception)
{
lDadosDeBusca.OpcaoBuscarPor = OpcoesBuscarPor.NomeCliente;
}
{ //--> Setando o status da consulta
if (lStatus_Ativo && lStatus_Inativo)
{
lDadosDeBusca.OpcaoStatus = lDadosDeBusca.OpcaoStatus;
}
else if (lStatus_Ativo)
{
lDadosDeBusca.OpcaoStatus = OpcoesStatus.Ativo;
}
else if (lStatus_Inativo)
{
lDadosDeBusca.OpcaoStatus = OpcoesStatus.Inativo;
}
}
{ //--> Definindo o passo do cadastro
if (lPasso_Visitante && lPasso_Cadastrado && lPasso_ExportadoSinacor)
{
lDadosDeBusca.OpcaoPasso = OpcoesPasso.Visitante | OpcoesPasso.Cadastrado | OpcoesPasso.Exportado;
}
else if (lPasso_Visitante && lPasso_Cadastrado)
{
lDadosDeBusca.OpcaoPasso = OpcoesPasso.Visitante | OpcoesPasso.Cadastrado;
}
else if (lPasso_Visitante && lPasso_ExportadoSinacor)
{
lDadosDeBusca.OpcaoPasso = OpcoesPasso.Visitante | OpcoesPasso.Exportado;
}
else if (lPasso_Cadastrado && lPasso_ExportadoSinacor)
{
lDadosDeBusca.OpcaoPasso = OpcoesPasso.Cadastrado | OpcoesPasso.Exportado;
}
else if (lPasso_Visitante)
{
lDadosDeBusca.OpcaoPasso = OpcoesPasso.Visitante;
}
else if (lPasso_Cadastrado)
{
lDadosDeBusca.OpcaoPasso = OpcoesPasso.Cadastrado;
}
else if (lPasso_ExportadoSinacor)
{
lDadosDeBusca.OpcaoPasso = OpcoesPasso.Exportado;
}
}
if (lPendencia_ComPendenciaCadastral && !lPendencia_ComSolicitacaoAlteracao)
{
lDadosDeBusca.OpcaoPendencia = OpcoesPendencia.ComPendenciaCadastral;
}
else if (!lPendencia_ComPendenciaCadastral && lPendencia_ComSolicitacaoAlteracao)
{
lDadosDeBusca.OpcaoPendencia = OpcoesPendencia.ComSolicitacaoAlteracao;
}
else if (!lPendencia_ComPendenciaCadastral && !lPendencia_ComSolicitacaoAlteracao)
{
lDadosDeBusca.OpcaoPendencia = 0;
}
lRequest.EntidadeCadastro = lDadosDeBusca;
try
{
ReceberEntidadeCadastroRequest <LoginInfo> lEntradaLogin = new ReceberEntidadeCadastroRequest <LoginInfo>();
lEntradaLogin.EntidadeCadastro = new LoginInfo()
{
IdLogin = base.UsuarioLogado.Id
};
ReceberEntidadeCadastroResponse <LoginInfo> lRetornoLogin = this.ServicoPersistenciaCadastro.ReceberEntidadeCadastro <LoginInfo>(lEntradaLogin);
if (lRetornoLogin.EntidadeCadastro.TpAcesso == eTipoAcesso.Assessor)
{
lRequest.EntidadeCadastro.CodAssessor = lRetornoLogin.EntidadeCadastro.CdAssessor;
}
else
{
lRequest.EntidadeCadastro.CodAssessor = null;
}
//--> Realizando a Consulta
lResponse = this.ServicoPersistenciaCadastro.ConsultarEntidadeCadastro <ClienteResumidoInfo>(lRequest);
if (MensagemResponseStatusEnum.OK.Equals(lResponse.StatusResposta))
{
if (lDadosDeBusca.OpcaoBuscarPor == OpcoesBuscarPor.CodBovespa)
{
if (lResponse.Resultado != null && lResponse.Resultado.Count == 1 &&
(lResponse.Resultado[0].CodGradual != lDadosDeBusca.TermoDeBusca))
{
var lContas = this.ServicoPersistenciaCadastro.ConsultarEntidadeCadastro <ClienteContaInfo>(
new ConsultarEntidadeCadastroRequest <ClienteContaInfo>()
{
DescricaoUsuarioLogado = base.UsuarioLogado.Nome,
IdUsuarioLogado = base.UsuarioLogado.Id,
EntidadeCadastro = new ClienteContaInfo()
{
IdCliente = lResponse.Resultado[0].IdCliente
}
});
foreach (ClienteContaInfo item in lContas.Resultado)
{
if (item.CdCodigo == int.Parse(lDadosDeBusca.TermoDeBusca) &&
(item.CdSistema == eAtividade.BOL) &&
(item.StContaInvestimento))
{
lResponse.Resultado[0].CodGradual = lDadosDeBusca.TermoDeBusca;
lResponse.Resultado[0].CodBovespa = lDadosDeBusca.TermoDeBusca;
if (item.StAtiva)
{
lResponse.Resultado[0].CodBovespaAtiva = "A";
}
else
{
lResponse.Resultado[0].CodBovespaAtiva = "I";
}
}
}
}
}
this.SessionUltimoResultadoDeBusca = lResponse.Resultado;
TransporteDeListaPaginada lListaPaginada = BuscarPaginaDeResultados(1);
lRetorno = RetornarSucessoAjax(lListaPaginada, "Encontrados [{0}] clientes", lResponse.Resultado.Count);
}
else
{
lRetorno = RetornarErroAjax("Erro durante a busca.", string.Format("{0}\r\n\r\n{1}\r\n\r\n{2}", lResponse.StatusResposta, lResponse.StatusResposta, lResponse.DescricaoResposta));
}
}
catch (Exception exBusca)
{
lRetorno = RetornarErroAjax("Erro durante a busca", exBusca);
}
return(lRetorno);
}
private string ResponderSincronizarComSinacor()
{
var lResposta = string.Empty;
var lPrimeira = true;
var lCodigo = new Nullable <int>();
//Pegar Cliente
var lEntradaCliente = new ReceberEntidadeCadastroRequest <ClienteInfo>()
{
};
var lRetornoCliente = new ReceberEntidadeCadastroResponse <ClienteInfo>();
lEntradaCliente.EntidadeCadastro = new ClienteInfo();
lEntradaCliente.EntidadeCadastro.IdCliente = this.GetIdCliente;
lEntradaCliente.IdUsuarioLogado = base.UsuarioLogado.Id;
lEntradaCliente.DescricaoUsuarioLogado = base.UsuarioLogado.Nome;
lRetornoCliente = this.ServicoPersistenciaCadastro.ReceberEntidadeCadastro(lEntradaCliente);
if (lRetornoCliente.EntidadeCadastro.StPasso < 3)
{
lResposta = RetornarErroAjax("É preciso gerar a ficha cadastral antes de exportar o cliente.");
}
else
{
//Passo e Conta
if (lRetornoCliente.EntidadeCadastro.StPasso == 4)
{
lPrimeira = false;
//Pegar o Códio Principal
var lEntradaConta = new ConsultarEntidadeCadastroRequest <ClienteContaInfo>();
var lRetornoConta = new ConsultarEntidadeCadastroResponse <ClienteContaInfo>();
lEntradaConta.EntidadeCadastro = new ClienteContaInfo();
lEntradaConta.EntidadeCadastro.IdCliente = lRetornoCliente.EntidadeCadastro.IdCliente.Value;
lEntradaConta.DescricaoUsuarioLogado = base.UsuarioLogado.Nome;
lEntradaConta.IdUsuarioLogado = base.UsuarioLogado.Id;
lRetornoConta = this.ServicoPersistenciaCadastro.ConsultarEntidadeCadastro <ClienteContaInfo>(lEntradaConta);
List <ClienteContaInfo> lListaConta = lRetornoConta.Resultado;
foreach (ClienteContaInfo lConta in lListaConta)
{
if (null != lConta.StPrincipal && lConta.StPrincipal.Value)
{
lCodigo = lConta.CdCodigo;
break;
}
}
}
//Exportação
var lEntradaExportacao = new SalvarEntidadeCadastroRequest <SinacorExportarInfo>();
var lRetornoExportacao = new SalvarEntidadeCadastroResponse();
lEntradaExportacao.EntidadeCadastro = new SinacorExportarInfo();
lEntradaExportacao.EntidadeCadastro.Entrada = new SinacorExportacaoEntradaInfo();
lEntradaExportacao.EntidadeCadastro.Entrada.IdCliente = lRetornoCliente.EntidadeCadastro.IdCliente.Value;
lEntradaExportacao.EntidadeCadastro.Entrada.CdCodigo = lCodigo;
lEntradaExportacao.EntidadeCadastro.Entrada.PrimeiraExportacao = lPrimeira;
lEntradaExportacao.DescricaoUsuarioLogado = base.UsuarioLogado.Nome;
lEntradaExportacao.IdUsuarioLogado = base.UsuarioLogado.Id;
lRetornoExportacao = this.ServicoPersistenciaCadastro.SalvarEntidadeCadastro <SinacorExportarInfo>(lEntradaExportacao);
//Retorno da Exportação
var lTransporte = new TransporteSincronizacaoComSinacor()
{
GridErro = new List <GridSincronizacao>()
};
if (lRetornoExportacao.StatusResposta == MensagemResponseStatusEnum.OK)
{
SinacorExportarInfo lRetorno = (SinacorExportarInfo)lRetornoExportacao.Objeto;
GridSincronizacao lGrig;
if (!lRetorno.Retorno.DadosClienteOk)
{ //Erro na validação do Cliente
lTransporte.Resultado = gResultadoErroCadastro;
foreach (var item in lRetorno.Retorno.DadosClienteMensagens)
{
lGrig = new GridSincronizacao();
lGrig.Tipo = gTipoPendencia;
lGrig.Descricao = item.Mensagem;
lTransporte.GridErro.Add(lGrig);
}
}
else
{
if (!lRetorno.Retorno.ExportacaoSinacorOk)
{ //Erro no processo CliExterno
lTransporte.Resultado = gResultadoErroClieExterno;
foreach (var item in lRetorno.Retorno.ExportacaoSinacorMensagens)
{
lGrig = new GridSincronizacao();
lGrig.Tipo = gTipoCliExterno;
lGrig.Descricao = string.Concat(item.DS_OBS, " - ", item.DS_AUX);
lTransporte.GridErro.Add(lGrig);
}
}
else
{
//Cliente Exportado
//Verificação do Resultado:
if (lRetorno.Retorno.ExportacaoAtualizarCadastroOk && lRetorno.Retorno.ExportacaoComplementosOk)//Tudo OK
{
lTransporte.Resultado = gResultadoOk;
}
else //Com resalvas
{
lTransporte.Resultado = gResultadoOkParcial;
if (!lRetorno.Retorno.ExportacaoAtualizarCadastroOk) //Atualizacao OK
{
lTransporte.Mensagens.Add(gResultadoErroAtualizacao);
}
if (!lRetorno.Retorno.ExportacaoRiscoOk) //Risco OK
{
lTransporte.Mensagens.Add(gResultadoErroRisco);
}
if (!lRetorno.Retorno.ExportacaoComplementosOk) //Complementos OK
{
lTransporte.Mensagens.Add(gResultadoErroComplementos);
}
}
//Montando o Grid
if (!lRetorno.Retorno.ExportacaoAtualizarCadastroOk)
{
foreach (var item in lRetorno.Retorno.ExportacaoAtualizarCadastroMensagens)
{
lGrig = new GridSincronizacao();
lGrig.Tipo = gTipoAtualizacao;
lGrig.Descricao = item.Mensagem;
lTransporte.GridErro.Add(lGrig);
}
}
if (!lRetorno.Retorno.ExportacaoRiscoOk)
{
foreach (var item in lRetorno.Retorno.ExportacaoRiscoMensagens)
{
lGrig = new GridSincronizacao();
lGrig.Tipo = gTipoRisco;
lGrig.Descricao = item.Mensagem;
lTransporte.GridErro.Add(lGrig);
}
}
if (!lRetorno.Retorno.ExportacaoComplementosOk)
{
foreach (var item in lRetorno.Retorno.ExportacaoComplementosMensagens)
{
lGrig = new GridSincronizacao();
lGrig.Tipo = gTipoComplementos;
lGrig.Descricao = item.Mensagem;
lTransporte.GridErro.Add(lGrig);
}
}
this.EnviarEmailCodigo(lRetorno, lRetornoCliente.EntidadeCadastro);
} // Fim Cliente Exportado
}
}
else
{
lTransporte.Resultado = lRetornoExportacao.DescricaoResposta;
lResposta = RetornarErroAjax(lRetornoExportacao.DescricaoResposta);
}
lResposta = RetornarSucessoAjax(lTransporte, "Comunicação com o Sinacor realizada.");
base.RegistrarLogAlteracao(new Contratos.Dados.Cadastro.LogIntranetInfo()
{
IdClienteAfetado = this.GetIdCliente,
DsObservacao = string.Concat("Cliente sincronizado: id_cliente: ", this.GetIdCliente)
});
}
return(lResposta);
}
private void ImportarTodosClientesSinacor()
{
//SinacorChaveClienteInfo lChave = new SinacorChaveClienteInfo();
//EntidadeCadastro = lChave
string ok = "";
string erro = "";
try
{
//Listar Todas as chaves
#region "Listar Chaves do Sinacor"
SinacorImportarDbLib lib = new SinacorImportarDbLib();
ObjetosCompartilhados.lHashClientes = lib.ObterLoginClienteSistemaDuc();
ConsultarEntidadeCadastroRequest <SinacorChaveClienteInfo> EntradaChaveSinacor = new ConsultarEntidadeCadastroRequest <SinacorChaveClienteInfo>();
ConsultarEntidadeCadastroResponse <SinacorChaveClienteInfo> RetornoChaveSinacor = new ConsultarEntidadeCadastroResponse <SinacorChaveClienteInfo>();
EntradaChaveSinacor.EntidadeCadastro = new SinacorChaveClienteInfo()
{
CD_CPFCGC = 33414115859, CD_CON_DEP = 1, DT_NASC_FUND = new DateTime(1985, 10, 2)
};
RetornoChaveSinacor = ServicoPersistenciaCadastro.ConsultarEntidadeCadastro <SinacorChaveClienteInfo>(EntradaChaveSinacor);
#endregion
//Para cada chave, pegar o Cliente na estrutura do Sinacor
//System.Collections.Generic.List<SinacorClienteInfo> lTodosClienteSinacorCompleto = new System.Collections.Generic.List<SinacorClienteInfo>();
#region "Listar Clientes do Sinacor a partir das Chaves"
ReceberEntidadeCadastroResponse <SinacorClienteInfo> RetornoClienteSinacor;
ReceberEntidadeCadastroRequest <SinacorClienteInfo> EntradaClienteSinacor;
SalvarEntidadeCadastroRequest <SinacorClienteInfo> EntradaCliente;
SalvarEntidadeCadastroResponse RetornoCliente;
foreach (SinacorChaveClienteInfo item in RetornoChaveSinacor.Resultado)
{
string lKey = string.Format("{0}-{1}", item.CD_CPFCGC, item.DT_NASC_FUND.ToString("ddMMyyyy"));
RetornoClienteSinacor = new ReceberEntidadeCadastroResponse <SinacorClienteInfo>();
EntradaClienteSinacor = new ReceberEntidadeCadastroRequest <SinacorClienteInfo>();
EntradaClienteSinacor.EntidadeCadastro = new SinacorClienteInfo();
EntradaClienteSinacor.EntidadeCadastro.ChaveCliente = item;
RetornoClienteSinacor = ServicoPersistenciaCadastro.ReceberEntidadeCadastro <SinacorClienteInfo>(EntradaClienteSinacor);
//antes adidionava em um list, agora inclui
//lTodosClienteSinacorCompleto.Add(lClienteSinacor.EntidadeCadastro);
EntradaCliente = new SalvarEntidadeCadastroRequest <SinacorClienteInfo>();
RetornoCliente = new SalvarEntidadeCadastroResponse();
EntradaCliente.EntidadeCadastro = RetornoClienteSinacor.EntidadeCadastro;
EntradaCliente.EntidadeCadastro.StReimportacao = true;
try
{
RetornoCliente = ServicoPersistenciaCadastro.SalvarEntidadeCadastro <SinacorClienteInfo>(EntradaCliente);
VerificaErro(RetornoCliente);
ok += EntradaCliente.EntidadeCadastro.ChaveCliente.CD_CPFCGC + " - " + Environment.NewLine;
}
catch (Exception ex)
{
erro += EntradaCliente.EntidadeCadastro.ChaveCliente.CD_CPFCGC + " - " + ex.Message + " - " + Environment.NewLine;
}
}
#endregion
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
string lOk = ok;
string lErro = erro;
}
/* Importação de Solicitação de Alteração(clientes 123 e importação de LoginAlteracaoPasso4) joga a realização para o login 1
*
* SET IDENTITY_INSERT tb_login ON
*
* INSERT INTO tb_login
* (cd_senha,cd_assinaturaeletronica,nr_tentativaserradas,id_frase,ds_respostafrase,dt_ultimaexpiracao,ds_email,tp_acesso,cd_assessor,ds_nome,id_login)
* VALUES
* ('senha','Assinatura',0,1,'',getdate(),'*****@*****.**',1,null,'Usuario de Importação',1)
*
* SET IDENTITY_INSERT tb_login OFF
*
*/
public void ImportarLoginsAlteracoesPasso4()
{
//****************************************************************************************************************************
//****************************************************************************************************************************
//****************************************************************************************************************************
//****************************************************************************************************************************
///TODO OBS. Pegar o login do Administrador do cadastro
int IdLoginAlteracao = 65859;
//****************************************************************************************************************************
//****************************************************************************************************************************
//pegar todos os clientes no sistema novo
//para cada cliente
//Se passo = 4
//Pegar o Login no sistema antido apartir do CPF
//Salvar todas as Solicitações de alteração
//salvar o Login no sistema Novo
ConsultarEntidadeCadastroRequest <ClienteInfo> lEntradaCliente = new ConsultarEntidadeCadastroRequest <ClienteInfo>();
ConsultarEntidadeCadastroResponse <ClienteInfo> lRetornoCliente = null;
lEntradaCliente.EntidadeCadastro = new ClienteInfo();
lRetornoCliente = ServicoPersistenciaCadastro.ConsultarEntidadeCadastro <ClienteInfo>(lEntradaCliente);
string Ok = "";
string erro = "";
int iok = 0;
int ierro = 0;
ReceberEntidadeCadastroRequest <LoginInfo> lEntradaLoginNovo;
ReceberEntidadeCadastroResponse <LoginInfo> lRetornoLoginNovo = null;
ELogin lLoginAntigo;
SalvarObjetoRequest <LoginInfo> lEntradaSalvarLogin;
foreach (ClienteInfo lCliente in lRetornoCliente.Resultado)
{
if (lCliente.StPasso == 4)
{
try
{
//Pegar Login no novo
lEntradaLoginNovo = new ReceberEntidadeCadastroRequest <LoginInfo>();
lEntradaLoginNovo.EntidadeCadastro = new LoginInfo();
lEntradaLoginNovo.EntidadeCadastro.IdLogin = lCliente.IdLogin.Value;
lRetornoLoginNovo = ServicoPersistenciaCadastro.ReceberEntidadeCadastro <LoginInfo>(lEntradaLoginNovo);
//Pegar Login no Antigo apartir do CPF
lLoginAntigo = new NLogin().SelecionarPorCPF(lCliente.DsCpfCnpj);
//Sobreacrever o Login novo com os dados do antigo
lRetornoLoginNovo.EntidadeCadastro.CdAssessor = null;
lRetornoLoginNovo.EntidadeCadastro.CdAssinaturaEletronica = lLoginAntigo.Assinatura;
lRetornoLoginNovo.EntidadeCadastro.CdSenha = lLoginAntigo.Senha;
lRetornoLoginNovo.EntidadeCadastro.DsEmail = lLoginAntigo.Email;
lRetornoLoginNovo.EntidadeCadastro.DsNome = "";//já está no cliente
lRetornoLoginNovo.EntidadeCadastro.DsRespostaFrase = "";
lRetornoLoginNovo.EntidadeCadastro.DtUltimaExpiracao = DateTime.Now;
lRetornoLoginNovo.EntidadeCadastro.IdFrase = null;
lRetornoLoginNovo.EntidadeCadastro.NrTentativasErradas = 0;
lRetornoLoginNovo.EntidadeCadastro.TpAcesso = 0;
CarregarSoliciacaoAlteracao(lCliente.IdCliente.Value, lCliente.DsCpfCnpj, IdLoginAlteracao);
//Salvar o Login novo
lEntradaSalvarLogin = new SalvarObjetoRequest <LoginInfo>();
lEntradaSalvarLogin.Objeto = lRetornoLoginNovo.EntidadeCadastro;
//lRetornoSalvarLogin = ServicoPersistenciaCadastro.SalvarEntidadeCadastro<LoginInfo>(lEntradaSalvarLogin);
ClienteDbLib.AtualizarPorImportacao(lEntradaSalvarLogin);
Ok += lCliente.DsCpfCnpj + Environment.NewLine;
iok++;
}
catch (Exception ex)
{
if (ex.Message != "CPF não encontrado no Sistema Antigo!")
{
erro += lCliente.DsCpfCnpj + ": " + ex.Message + " - " + ex.StackTrace + Environment.NewLine;
ierro++;
}
}
}
}
}
public void VerificaErro(ReceberEntidadeCadastroResponse <EsqueciAssinaturaEletronicaInfo> pObjeto)
{
VerificaErro(pObjeto.StatusResposta, pObjeto.DescricaoResposta);
}
public void VerificaErro(ReceberEntidadeCadastroResponse <PrimeiroAcessoValidaInfo> pObjeto)
{
VerificaErro(pObjeto.StatusResposta, pObjeto.DescricaoResposta);
}
public void VerificaErro(ReceberEntidadeCadastroResponse <ClienteSituacaoFinanceiraPatrimonialInfo> pObjeto)
{
VerificaErro(pObjeto.StatusResposta, pObjeto.DescricaoResposta);
}
private string RealizarImportacao()
{
string lRetorno = string.Empty;
string lObjetoJson = this.Request["ObjetoJson"];
if (!string.IsNullOrEmpty(lObjetoJson))
{
TransporteImportacao lTransporteImportacao = JsonConvert.DeserializeObject <TransporteImportacao>(lObjetoJson);
if (string.IsNullOrWhiteSpace(lTransporteImportacao.CPF_CNPJ) || string.IsNullOrWhiteSpace(lTransporteImportacao.DataNascimento))
{
return(RetornarErroAjax("Todos os Campos precisam ser preenchidos"));
}
ReceberEntidadeCadastroResponse <SinacorClienteInfo> RetornoClienteSinacor = new ReceberEntidadeCadastroResponse <SinacorClienteInfo>();
ReceberEntidadeCadastroRequest <SinacorClienteInfo> EntradaClienteSinacor = new ReceberEntidadeCadastroRequest <SinacorClienteInfo>();
EntradaClienteSinacor.EntidadeCadastro = new SinacorClienteInfo();
EntradaClienteSinacor.IdUsuarioLogado = base.UsuarioLogado.Id;
EntradaClienteSinacor.DescricaoUsuarioLogado = base.UsuarioLogado.Nome;
EntradaClienteSinacor.EntidadeCadastro.ChaveCliente = lTransporteImportacao.ToSinacorChaveInfo();
//Pegando o cliente completo do Sinacor
RetornoClienteSinacor = this.ServicoPersistenciaCadastro.ReceberEntidadeCadastro <SinacorClienteInfo>(EntradaClienteSinacor);
if (RetornoClienteSinacor.StatusResposta == OMS.Library.MensagemResponseStatusEnum.OK)
{
SalvarEntidadeCadastroRequest <SinacorClienteInfo> EntradaCliente = new SalvarEntidadeCadastroRequest <SinacorClienteInfo>();
SalvarEntidadeCadastroResponse RetornoCliente = new SalvarEntidadeCadastroResponse();
EntradaCliente.EntidadeCadastro = RetornoClienteSinacor.EntidadeCadastro;
EntradaCliente.IdUsuarioLogado = base.UsuarioLogado.Id;
EntradaCliente.DescricaoUsuarioLogado = base.UsuarioLogado.Nome;
EntradaCliente.EntidadeCadastro.StReimportacao = this.gStReimportacao;
//Salvando no Cadastro
RetornoCliente = ServicoPersistenciaCadastro.SalvarEntidadeCadastro <SinacorClienteInfo>(EntradaCliente);
if (RetornoCliente.StatusResposta == OMS.Library.MensagemResponseStatusEnum.OK)
{
lRetorno = base.RetornarSucessoAjax("Cliente Importado com sucesso");
string lLogFraseObservacao = string.Empty;
if (gStReimportacao)
{
lLogFraseObservacao = string.Concat("Requisitada a REIMPORTAÇÃO do cliente: cd_cliente = ", RetornoCliente.DescricaoResposta);
}
else
{
lLogFraseObservacao = string.Concat("Requisitada a IMPORTAÇÃO do cliente: cd_cliente = ", RetornoCliente.DescricaoResposta);
}
base.RegistrarLogConsulta(new Contratos.Dados.Cadastro.LogIntranetInfo()
{
IdClienteAfetado = RetornoCliente.DescricaoResposta.DBToInt32(), DsObservacao = lLogFraseObservacao
});
}
else
{
if (RetornoCliente.DescricaoResposta.ToUpper().Contains("CPF/CNPJ já cadastrado para outro Cliente".ToUpper()))
{
lRetorno = base.RetornarSucessoAjax("Erro ao Tentar Importar o Cliente: CPF/CNPJ já cadastrado");
}
else
{
lRetorno = base.RetornarErroAjax("Erro ao Tentar Importar o Cliente", RetornoCliente.DescricaoResposta);
}
}
}
else
{
if (RetornoClienteSinacor.DescricaoResposta.ToUpper().Contains("Cliente não encontrado no Sinacor".ToUpper()))
{
lRetorno = base.RetornarErroAjax("Erro ao Tentar Importar o Cliente: Cliente não encontrado no Sinacor");
}
else
{
lRetorno = base.RetornarErroAjax("Erro ao Tentar Importar o Cliente", RetornoClienteSinacor.DescricaoResposta);
}
}
}
else
{
lRetorno = base.RetornarErroAjax("Foi enviada ação de cadastro sem objeto para alterar");
}
return(lRetorno);
}
public void VerificaErro(ReceberEntidadeCadastroResponse <TipoEnderecoInfo> pObjeto)
{
VerificaErro(pObjeto.StatusResposta, pObjeto.DescricaoResposta);
}
public void VerificaErro(ReceberEntidadeCadastroResponse <EfetuarLoginInfo> pObjeto)
{
VerificaErro(pObjeto.StatusResposta, pObjeto.DescricaoResposta);
}
private string ResponderBuscarItensParaListagemSimples()
{
string lRetorno = "Erro...";
ConsultarEntidadeCadastroRequest <ClienteResumidoInfo> lRequest = new ConsultarEntidadeCadastroRequest <ClienteResumidoInfo>();
ConsultarEntidadeCadastroResponse <ClienteResumidoInfo> lResponse = new ConsultarEntidadeCadastroResponse <ClienteResumidoInfo>();
ClienteResumidoInfo lDadosDeBusca = new ClienteResumidoInfo();
string lTermoDeBusca, lBuscarPor, lTipo;
lTermoDeBusca = Request.Form["TermoDeBusca"];
lBuscarPor = Request.Form["BuscarPor"];
lTipo = Request.Form["Tipo"];
lDadosDeBusca.TipoCliente = lTipo;
lDadosDeBusca.TermoDeBusca = lTermoDeBusca;
OpcoesBuscarPor lOpcoesBuscarPor;
if (Enum.TryParse <OpcoesBuscarPor>(lBuscarPor, true, out lOpcoesBuscarPor))
{
lDadosDeBusca.OpcaoBuscarPor = lOpcoesBuscarPor;
}
else
{
lDadosDeBusca.OpcaoBuscarPor = OpcoesBuscarPor.NomeCliente;
}
lDadosDeBusca.OpcaoStatus = OpcoesStatus.Ativo | OpcoesStatus.Inativo;
lDadosDeBusca.OpcaoPasso = OpcoesPasso.Exportado;
lDadosDeBusca.OpcaoPendencia = OpcoesPendencia.ComPendenciaCadastral | OpcoesPendencia.ComSolicitacaoAlteracao | 0;
lRequest.EntidadeCadastro = lDadosDeBusca;
try
{
ReceberEntidadeCadastroRequest <LoginInfo> lEntradaLogin = new ReceberEntidadeCadastroRequest <LoginInfo>();
lEntradaLogin.EntidadeCadastro = new LoginInfo()
{
IdLogin = base.UsuarioLogado.Id
};
ReceberEntidadeCadastroResponse <LoginInfo> lRetornoLogin = this.ServicoPersistenciaCadastro.ReceberEntidadeCadastro <LoginInfo>(lEntradaLogin);
lRequest.EntidadeCadastro.CodAssessor = lRetornoLogin.EntidadeCadastro.CdAssessor;
lResponse = this.ServicoPersistenciaCadastro.ConsultarEntidadeCadastro <ClienteResumidoInfo>(lRequest);
if (MensagemResponseStatusEnum.OK.Equals(lResponse.StatusResposta))
{
lResponse.Resultado.ForEach(cri => cri.NomeCliente = cri.NomeCliente.ToStringFormatoNome()); //--> Normalizando o nome dos clientes.
lResponse.Resultado.Sort((a, b) => string.Compare(a.NomeCliente.Trim(), b.NomeCliente.Trim())); //--> Ordenando o resultado por nome.
this.SessionUltimoResultadoDeBusca = lResponse.Resultado;
rowLinhaDeNenhumItem.Visible = !(lResponse.Resultado.Count > 0);
TransporteDeListaPaginada lListaPaginada = BuscarPaginaDeResultados(1);
lRetorno = RetornarSucessoAjax(lListaPaginada, "Encontrados [{0}] clientes", lResponse.Resultado.Count);
}
else
{
lRetorno = RetornarErroAjax("Erro durante a busca.", string.Format("{0}\r\n\r\n{1}\r\n\r\n{2}", lResponse.StatusResposta, lResponse.StatusResposta, lResponse.DescricaoResposta));
}
}
catch (Exception exBusca)
{
RetornarErroAjax("Erro durante a busca", exBusca);
}
return(lRetorno);
}
public void VerificaErro(ReceberEntidadeCadastroResponse <ArquivoContratoInfo> pObjeto)
{
VerificaErro(pObjeto.StatusResposta, pObjeto.DescricaoResposta);
}
public void VerificaErro(ReceberEntidadeCadastroResponse <SessaoPortalInfo> pObjeto)
{
VerificaErro(pObjeto.StatusResposta, pObjeto.DescricaoResposta);
}
