//persiste o relacionamento com UnidadesRelacionadas
private bool RelacionaUnidadesNegocio(Intelbras.Message.Helper.MSG0152 xml, SolicitacaoBeneficio solicitacaoBeneficio)
{
if (xml.CodigoSolicitacaoBeneficio != null)
{
List <SolicitacaoXUnidades> solicitacaoXUnidades = new SolicitacaoXUnidadesService(this.Organizacao, this.IsOffline).ListarPor(new Guid(xml.CodigoSolicitacaoBeneficio));
foreach (SolicitacaoXUnidades solicitacaoXUnidade in solicitacaoXUnidades)
{
new SolicitacaoXUnidadesService(this.Organizacao, this.IsOffline).Deletar(solicitacaoXUnidade.ID.Value);
}
}
if (xml.UnidadesRelacionadas != null && xml.UnidadesRelacionadas.Count > 0)
{
foreach (var unidadesRelacionadas in xml.UnidadesRelacionadas)
{
UnidadeNegocio unidadeNegocio = new Servicos.UnidadeNegocioService(this.Organizacao, this.IsOffline).BuscaUnidadeNegocioPorChaveIntegracao(unidadesRelacionadas.CodigoUnidadeNegocio);
if (unidadeNegocio.ID != Guid.Empty)
{
SolicitacaoXUnidades solicitacaoXUnidadesNovo = new SolicitacaoXUnidades();
solicitacaoXUnidadesNovo.Unidades = new Lookup(unidadeNegocio.ID.Value, "businessunit");
solicitacaoXUnidadesNovo.Solicitacao = new Lookup(solicitacaoBeneficio.ID.Value, "itbc_solicitacaodebeneficio");
new SolicitacaoXUnidadesService(this.Organizacao, this.IsOffline).Criar(solicitacaoXUnidadesNovo);
}
}
}
return(true);
}
public void AtualizarTarefaNaoAjusteManual(SolicitacaoBeneficio SolBenef)
{
Guid tipoAtividadeExecucao;
if (!Guid.TryParse(ConfigurationManager.GetSettingValue("TipoAtividadeExecucao"), out tipoAtividadeExecucao))
{
throw new ArgumentException("(CRM) Faltando parâmetro TipoAtividadeExecucao no SDKore");
}
if (SolBenef.TipoSolicitacao != null && !SolBenef.AjusteSaldo.Value)
{
var tarefaService = new TarefaService(RepositoryService);
Lookup referenteA = new Lookup(SolBenef.ID.Value, "");
Lookup tipoAtividade = new Lookup(tipoAtividadeExecucao, "");
var tarefa = tarefaService.ObterPor(referenteA.Id, tipoAtividade.Id, (int)Enum.Tarefa.StateCode.Ativo);
if (tarefa != null)
{
tarefa.Resultado = (int)Enum.Tarefa.Resultado.PagamentoEfetuadoPedidoGerado;
tarefa.PareceresAnteriores = "Validada/Aprovada";
tarefa.Status = 5;
tarefa.State = 1;
string retorno;
tarefaService.Persistir(tarefa, out retorno);
}
}
}
public string Executar(string mensagem, string numeroMensagem, Domain.Model.Usuario usuario)
{
try
{
usuarioIntegracao = usuario;
SolicitacaoBeneficio solicitacaoBenficioConsulta = null;
Pollux.Entities.SolicitacaoBeneficioR1 objRetornoPollux = new Pollux.Entities.SolicitacaoBeneficioR1();
var xml = this.CarregarMensagem <Pollux.MSG0148>(mensagem);
//Solicitacao Beneficio
if (!string.IsNullOrEmpty(xml.CodigoSolicitacaoBeneficio) && xml.CodigoSolicitacaoBeneficio.Length == 36)
{
solicitacaoBenficioConsulta = new Servicos.SolicitacaoBeneficioService(this.Organizacao, this.IsOffline).ObterPor(new Guid(xml.CodigoSolicitacaoBeneficio));
if (solicitacaoBenficioConsulta == null)
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "Valor do parâmetro " + xml.CodigoSolicitacaoBeneficio + " não existe.";
retorno.Add("Resultado", resultadoPersistencia);
return(CriarMensagemRetorno <Pollux.MSG0148R1>(numeroMensagem, retorno));
}
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "Parâmetro obrigatório para a consulta não enviado.";
retorno.Add("Resultado", resultadoPersistencia);
return(CriarMensagemRetorno <Pollux.MSG0148R1>(numeroMensagem, retorno));
}
objRetornoPollux = DefinirRetorno(solicitacaoBenficioConsulta);
if (objRetornoPollux == null)
{
resultadoPersistencia.Sucesso = true;
resultadoPersistencia.Mensagem = "Não foram encontrados registros que satisfaçam os critérios de pesquisa.";
retorno.Add("Resultado", resultadoPersistencia);
return(CriarMensagemRetorno <Pollux.MSG0148R1>(numeroMensagem, retorno));
}
else if (!resultadoPersistencia.Sucesso)
{
retorno.Add("Resultado", resultadoPersistencia);
return(CriarMensagemRetorno <Pollux.MSG0148R1>(numeroMensagem, retorno));
}
resultadoPersistencia.Sucesso = true;
resultadoPersistencia.Mensagem = "Integração ocorrida com sucesso!";
retorno.Add("SolicitacaoBeneficio", objRetornoPollux);
retorno.Add("Resultado", resultadoPersistencia);
return(CriarMensagemRetorno <Pollux.MSG0148R1>(numeroMensagem, retorno));
}
catch (Exception e)
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = SDKore.Helper.Error.Handler(e);
retorno.Add("Resultado", resultadoPersistencia);
return(CriarMensagemRetorno <Pollux.MSG0173R1>(numeroMensagem, retorno));
}
}
public ProdutoPortfolio ObterProdutoPortforlio(SolicitacaoBeneficio solicitacaoBeneficio, Guid produtoId)
{
Conta canal = RepositoryService.Conta.Retrieve(solicitacaoBeneficio.Canal.Id);
var produtoService = new ProdutoService(RepositoryService.NomeDaOrganizacao, RepositoryService.IsOffline);
List <ProdutoPortfolio> lstProdutoPortifolio = produtoService.ProdutosPortfolio(canal, canal.Classificacao.Id, solicitacaoBeneficio.UnidadedeNegocio.Id);
return(lstProdutoPortifolio.Find(x => x.Produto.Id == produtoId));
}
public void TesteSolicitacaoBenefico()
{
RepositoryService sRepos = new RepositoryService(OrganizationName, IsOffline);
SolicitacaoBeneficio mSolicitacaoBeneficio = sRepos.SolicitacaoBeneficio.Retrieve(Guid.Parse("79607404-1439-E411-803A-00155D013E44"));
Tarefa mTarefa = sRepos.Tarefa.ObterPor(Guid.Parse("97CC7BCF-1639-E411-803A-00155D013E44"));
Guid usuarioId = Guid.Parse("4EBA8596-4E17-E411-9233-00155D013E44");
//new ProcessoDeSolicitacoesService(sRepos.NomeDaOrganizacao, sRepos.IsOffline).ConcluirTarefaSolicitacaoBeneficio(mTarefa, usuarioId);
new SolicitacaoBeneficioService(sRepos.NomeDaOrganizacao, sRepos.IsOffline).GerarTarefaSolicBeneficio(mSolicitacaoBeneficio, usuarioId, 1);
}
public void VerificaStatusDaSolicitacao(ProdutosdaSolicitacao produtosdaSolicitacao, string origem)
{
SolicitacaoBeneficio mSolicitacaoBeneficio = RepositoryService.SolicitacaoBeneficio.Retrieve(produtosdaSolicitacao.SolicitacaoBeneficio.Id);
if ((mSolicitacaoBeneficio.StatusSolicitacao.Value != (int)Domain.Enum.SolicitacaoBeneficio.StatusSolicitacaoBeneficio.EmAnalise &&
mSolicitacaoBeneficio.StatusSolicitacao.Value != (int)Domain.Enum.SolicitacaoBeneficio.StatusSolicitacaoBeneficio.Criada) &&
(origem != "" && origem != Enum.Sistemas.RetornaSistema(Enum.Sistemas.Sistema.EMS)))
{
throw new ArgumentException("(CRM) Não é Possivel Incluir/Alterar/Excluir Produtos de uma solicitação quando o Status é diferente de Criada/Em Analise.");
}
}
private void ValidaTrocaStatus(SolicitacaoBeneficio target, SolicitacaoBeneficio preImage)
{
if (target.StatusSolicitacao.HasValue)
{
if (target.StatusSolicitacao.Value == (int)Domain.Enum.SolicitacaoBeneficio.StatusSolicitacaoBeneficio.Cancelada)
{
if (preImage.StatusSolicitacao.Value == (int)Domain.Enum.SolicitacaoBeneficio.StatusSolicitacaoBeneficio.PagamentoEfetuado)
{
throw new ArgumentException("(CRM) A solicitação só pode ser cancelada, o status já está finalizado!");
}
}
}
}
public string Enviar(SolicitacaoBeneficio objModel)
{
string resposta;
Pollux.MSG0155 mensagem = DefinirPropriedadesPlugin(objModel);
Servicos.Integracao integracao = new Servicos.Integracao(this.Organizacao, this.IsOffline);
if (integracao.EnviarMensagemBarramento(mensagem.GenerateMessage(true), "1", "1", out resposta))
{
Pollux.MSG0155R1 retorno = CarregarMensagem <Pollux.MSG0155R1>(resposta);
if (!retorno.Resultado.Sucesso)
{
throw new ArgumentException("(CRM) " + retorno.Resultado.Mensagem);
}
else
{
if (retorno.SaldoBeneficioCanal != null)
{
BeneficioDoCanal beneficioCanal = new Servicos.BeneficioDoCanalService(this.Organizacao, this.IsOffline).ObterPor(new Guid(retorno.SaldoBeneficioCanal.CodigoBeneficioCanal));
beneficioCanal.VerbaPeriodoAtual = retorno.SaldoBeneficioCanal.VerbaCalculada.Value;
beneficioCanal.VerbaPeriodosAnteriores = retorno.SaldoBeneficioCanal.VerbaPeriodoAnterior.Value;
beneficioCanal.VerbaBrutaPeriodoAtual = retorno.SaldoBeneficioCanal.VerbaTotal.Value;
beneficioCanal.TotalSolicitacoesAprovadasNaoPagas = retorno.SaldoBeneficioCanal.VerbaEmpenhada.Value;
beneficioCanal.VerbaReembolsada = retorno.SaldoBeneficioCanal.VerbaReembolsada.Value;
beneficioCanal.VerbaCancelada = retorno.SaldoBeneficioCanal.VerbaCancelada.Value;
beneficioCanal.VerbaAjustada = retorno.SaldoBeneficioCanal.VerbaAjustada.Value;
beneficioCanal.VerbaDisponivel = retorno.SaldoBeneficioCanal.VerbaDisponivel.Value;
new Servicos.BeneficioDoCanalService(this.Organizacao, this.IsOffline).AlterarBeneficioCanal(beneficioCanal);
if (objModel.TipoPriceProtection.HasValue && objModel.TipoPriceProtection.Value == (int)Enum.SolicitacaoBeneficio.TipoPriceProtection.Autorizacao)
{
if (objModel.StatusSolicitacao.HasValue && objModel.StatusSolicitacao.Value == (int)Enum.SolicitacaoBeneficio.StatusSolicitacaoBeneficio.PagamentoPendente)
{
objModel.StatusSolicitacao = (int?)Enum.SolicitacaoBeneficio.StatusSolicitacaoBeneficio.PagamentoEfetuado;
}
}
}
}
}
else
{
Intelbras.Message.Helper.ERR0001 erro001 = CarregarMensagem <Pollux.ERR0001>(resposta);
throw new ArgumentException("(CRM) " + erro001.GenerateMessage(false));
}
return(resposta);
}
public void CriaTarefaShowRoom(SolicitacaoBeneficio solicitacaoBeneficio)
{
if (solicitacaoBeneficio != null && solicitacaoBeneficio.UnidadedeNegocio != null && solicitacaoBeneficio.Canal != null)
{
CompromissosDoCanal compromissoCanal = RepositoryService.CompromissosDoCanal
.ObterPor(solicitacaoBeneficio.UnidadedeNegocio.Id, solicitacaoBeneficio.Canal.Id, (int)Enum.CompromissoPrograma.Codigo.Showroom);
if (compromissoCanal == null)
{
throw new ArgumentException("(CRM) Compromisso do canal Envio de evidências de Showroom não localizado, entre em contato com o suporte.");
}
CriarTarefaParaChecklistCompromissoCanal(1, compromissoCanal);
}
}
public void CriarTarefasSolicitacaoBeneficio(SolicitacaoBeneficio mSolicitacaoBeneficio, Guid usuarioId, int Ordem)
{
Guid?beneficioPrograma = null;
if (mSolicitacaoBeneficio.BeneficioPrograma != null)
{
beneficioPrograma = mSolicitacaoBeneficio.BeneficioPrograma.Id;
}
Model.Processo tmpProcesso = RepositoryService.Processo.ObterPorTipoDeSolicitacao(mSolicitacaoBeneficio.TipoSolicitacao.Id, beneficioPrograma);
if (tmpProcesso == null)
{
return;
}
string ParecerAnterior = String.Empty;
if (Ordem > 1)
{
ParecerAnterior = OrdemMaior1(mSolicitacaoBeneficio.ID.Value);
}
List <ParticipantesDoProcesso> lstParticipanteDoProcesso = RepositoryService.ParticipantesDoProcesso.ListarPor(tmpProcesso.ID.Value, Ordem);
bool CriouTarefa = false;
foreach (ParticipantesDoProcesso PartProcesso in lstParticipanteDoProcesso.GroupBy(x => x.Ordem).Select(grp => grp.First()))
{
Lookup referenteA = new Lookup(mSolicitacaoBeneficio.ID.Value, SDKore.Crm.Util.Utility.GetEntityName <SolicitacaoBeneficio>());
CriouTarefa = false;
if (PartProcesso.Papel.Name == "Informado")
{
//TODO: KSYS 45784 - Precisa corrigir o problema para não parar o fluxo
this.CriarEmail(referenteA, PartProcesso);
}
else
{
CriouTarefa = this.CriarTarefa(referenteA, mSolicitacaoBeneficio.TipoSolicitacao.Name, mSolicitacaoBeneficio.Descricao, ParecerAnterior, PartProcesso);
}
if (!CriouTarefa)
{
CriarTarefasSolicitacaoBeneficio(mSolicitacaoBeneficio, usuarioId, Ordem + 1);
}
}
}
private Intelbras.Message.Helper.MSG0152 DefinirPropriedadesPlugin(SolicitacaoBeneficio crm)
{
Intelbras.Message.Helper.MSG0152 objPollux = new Pollux.MSG0152(Domain.Enum.Sistemas.RetornaSistema(Domain.Enum.Sistemas.Sistema.CRM), Helper.Truncate(crm.Nome, 40));
objPollux.CodigoSolicitacaoBeneficio = crm.ID.ToString();
objPollux.ValorAprovado = crm.ValorAprovado;
if (!String.IsNullOrEmpty(crm.Nome))
{
objPollux.NomeSolicitacaoBeneficio = crm.Nome;
}
else
{
throw new ArgumentException("(CRM) Nome SolicitacaoBeneficio não preenchido.");
}
if (crm.UnidadedeNegocio != null)
{
UnidadeNegocio unidadeNegocio = new Servicos.UnidadeNegocioService(this.Organizacao, this.IsOffline).BuscaUnidadeNegocio(crm.UnidadedeNegocio.Id);
if (unidadeNegocio != null)
{
objPollux.CodigoUnidadeNegocio = unidadeNegocio.ChaveIntegracao;
}
}
else
{
throw new ArgumentException("(CRM) UnidadedeNegocio não preenchida.");
}
if (crm.ValorAcao.HasValue)
{
objPollux.ValorAcao = crm.ValorAcao.Value;
}
if (crm.ValorAcao.HasValue == false && crm.AjusteSaldo == false)
{
throw new ArgumentException("(CRM) Valor ação é obrigatório!");
}
if (!String.IsNullOrEmpty(crm.SituacaoIrregular))
{
objPollux.DescricaoSituacaoIrregular = crm.SituacaoIrregular;
}
if (crm.AcaoSubsidiadaVmc != null)
{
objPollux.CodigoAcaoSubsidiadaVMC = crm.AcaoSubsidiadaVmc.Id.ToString();
}
if (crm.AcaoSubsidiadaVmc == null && crm.AjusteSaldo == false)
{
throw new ArgumentException("(CRM) AcaoSubsidiadaVmc não preenchida.");
}
if (crm.BeneficioCanal != null)
{
objPollux.CodigoBeneficioCanal = crm.BeneficioCanal.Id.ToString();
}
else
{
throw new ArgumentException("(CRM) BeneficioCanal não preenchido.");
}
if (crm.ValorSolicitado.HasValue)
{
objPollux.ValorSolicitado = crm.ValorSolicitado.Value;
}
if (!String.IsNullOrEmpty(crm.Descricao))
{
objPollux.DescricaoSolicitacao = crm.Descricao;
}
if (crm.StatusSolicitacao.HasValue)
{
objPollux.SituacaoSolicitacaoBeneficio = crm.StatusSolicitacao.Value;
}
if (crm.State.HasValue)
{
objPollux.Situacao = crm.State.Value;
}
else
{
objPollux.Situacao = 0; //ativo
}
if (crm.Status.HasValue)
{
objPollux.RazaoStatusSolicitacaoBeneficio = crm.Status.Value;
}
if (crm.FormaPagamento != null)
{
objPollux.CodigoFormaPagamento = crm.FormaPagamento.Id.ToString();
}
else
{
throw new ArgumentException("(CRM) FormaPagamento não preenchida.");
}
if (crm.DataIniAcao.HasValue)
{
objPollux.DataInicioAcao = crm.DataIniAcao.Value;
}
if (crm.DataFimAcao.HasValue)
{
objPollux.DataPrevistaRetornoAcao = crm.DataFimAcao.Value.ToLocalTime();
}
if (crm.DataFimAcao.HasValue == false && crm.AjusteSaldo == false)
{
throw new ArgumentException("(CRM) Data Prevista retorno ação é obrigatório!");
}
if (crm.Canal != null)
{
objPollux.CodigoConta = crm.Canal.Id.ToString();
}
else
{
throw new ArgumentException("(CRM) Canal não preenchido.");
}
if (crm.BeneficioPrograma != null)
{
objPollux.CodigoBeneficio = crm.BeneficioPrograma.Id.ToString();
Beneficio benefProg = new Intelbras.CRM2013.Domain.Servicos.BeneficioService(this.Organizacao, this.IsOffline).ObterPor(crm.BeneficioPrograma.Id);
if (benefProg != null && benefProg.Codigo.HasValue)
{
objPollux.BeneficioCodigo = benefProg.Codigo.Value;
}
}
else
{
throw new ArgumentException("(CRM) BeneficioPrograma não preenchido.");
}
if (crm.AjusteSaldo.HasValue)
{
objPollux.SolicitacaoAjuste = crm.AjusteSaldo.Value;
}
if (crm.ValorAbater.HasValue)
{
objPollux.ValorAbater = (decimal)crm.ValorAbater.Value;
}
else
{
objPollux.ValorAbater = new decimal(0);
}
objPollux.Proprietario = "259A8E4F-15E9-E311-9420-00155D013D39";
objPollux.TipoProprietario = "systemuser";
if (crm.TipoSolicitacao != null)
{
objPollux.CodigoTipoSolicitacao = crm.TipoSolicitacao.Id.ToString();
}
else
{
throw new ArgumentException("(CRM) CodigoTipoSolicitacao não enviado.");
}
if (crm.SituacaoIrregularidades.HasValue)
{
objPollux.SolicitacaoIrregular = crm.SituacaoIrregularidades.Value;
}
objPollux.ProdutoSolicitacaoItens = this.RetornaListaItens(crm.ID.Value);
//Novos Campos
if (crm.Assistente == null)
{
throw new ArgumentException("(CRM) Assistente Na Solicitação não cadastrado / Campo Obrigatório.");
}
Usuario assistente = new Servicos.UsuarioService(this.Organizacao, this.IsOffline).ObterPor(crm.Assistente.Id);
if (assistente != null)
{
objPollux.CodigoAssistente = assistente.CodigoAssistenteComercial.Value;
}
else
{
throw new ArgumentException("(CRM) Assistente não cadastrado / Obrigatório.");
}
Usuario supervisor = new Servicos.UsuarioService(this.Organizacao, this.IsOffline).ObterPor(crm.Supervisor.Id);
if (supervisor != null)
{
objPollux.CodigoSupervisorEMS = supervisor.CodigoSupervisorEMS;
}
else
{
throw new ArgumentException("(CRM) Supervisor não cadastrado / Obrigatório.");
}
if (crm.Filial != null)
{
objPollux.CodigoFilial = crm.Filial.Id.ToString();
}
if (crm.StatusPagamento.HasValue)
{
objPollux.StatusPagamento = crm.StatusPagamento;
}
if (crm.ValorPago.HasValue)
{
objPollux.ValorPago = crm.ValorPago.Value;
}
if (crm.ValorCancelado.HasValue)
{
objPollux.ValorCancelado = crm.ValorCancelado.Value;
}
if (crm.DataCriacao.HasValue)
{
objPollux.DataCriacao = crm.DataCriacao.Value.ToLocalTime();
}
else
{
objPollux.DataCriacao = DateTime.MinValue;
//throw new ArgumentException("(CRM) DataCriacao não cadastrada / Obrigatório.");
}
if (crm.DataValidade.HasValue)
{
objPollux.DataValidade = crm.DataValidade;
}
else
{
throw new ArgumentException("(CRM) DataValidade não cadastrada / Obrigatório.");
}
if (crm.CondicaoPagamento != null)
{
CondicaoPagamento condicaoPagamento = new Servicos.CondicaoPagamentoService(this.Organizacao, this.IsOffline).BuscaCondicaoPagamento(crm.CondicaoPagamento.Id);
if (condicaoPagamento != null)
{
if (condicaoPagamento.Codigo.HasValue)
{
objPollux.CodigoCondicaoPagamento = condicaoPagamento.Codigo.Value;
}
}
}
if (crm.DescartarVerba.HasValue)
{
objPollux.DescartarVerba = crm.DescartarVerba.Value;
}
if (!string.IsNullOrEmpty(crm.TrimestreCompetencia))
{
objPollux.TrimestreCompetencia = crm.TrimestreCompetencia;
}
else
{
throw new ArgumentException("(CRM) TrimestreCompetencia não cadastrada / Obrigatório.");
}
if (crm.FormaCancelamento.HasValue)
{
objPollux.FormaCancelamento = crm.FormaCancelamento.Value;
}
if (crm.ResultadoPrevisto.HasValue)
{
objPollux.ResultadoPrevisto = crm.ResultadoPrevisto.Value;
}
if (crm.ResultadoAlcancado.HasValue)
{
objPollux.ResultadoAlcancado = crm.ResultadoAlcancado.Value;
}
//Busca as unidades de negócio relacionadas ao Benefício do canal
List <SolicitacaoXUnidades> lstUnidadesBenef = new Servicos.SolicitacaoXUnidadesService(this.Organizacao, this.IsOffline).ListarPor(crm.ID.Value);
objPollux.UnidadesRelacionadas = this.ConverteLista(lstUnidadesBenef);
#endregion
return(objPollux);
}
public decimal[] CalculoValorUnitarioETotal(ProdutosdaSolicitacao produtoSolicitacao, RepositoryService repoService)
{
decimal[] valoresCalculados = { 0, 0 };
decimal valorUnitario = 0;
SolicitacaoBeneficio solicBen = repoService.SolicitacaoBeneficio.Retrieve(produtoSolicitacao.SolicitacaoBeneficio.Id);
Beneficio beneficio = repoService.Beneficio.ObterPor(solicBen.BeneficioPrograma.Id);
Product produto = repoService.Produto.Retrieve(produtoSolicitacao.Produto.Id);
UnidadeNegocio unidadeNegocio = new UnidadeNegocio(repoService)
{
ID = solicBen.UnidadedeNegocio.Id, Nome = solicBen.UnidadedeNegocio.Name
};
Conta conta = repoService.Conta.Retrieve(solicBen.Canal.Id);
Classificacao classificacao = new Classificacao(conta.OrganizationName, conta.IsOffline)
{
ID = conta.Classificacao.Id, Nome = conta.Classificacao.Name
};
Categoria categoria = repoService.Categoria.ObterPor(conta.Categoria.Id);
if (beneficio.Codigo != (int)Domain.Enum.BeneficiodoPrograma.Codigos.StockRotation)
{
Estabelecimento estabelecimento = repoService.Estabelecimento.ObterPor(produtoSolicitacao.Estabelecimento.Id);
var lstPrecoProduto = new List <PrecoProduto>();
lstPrecoProduto.Add(new PrecoProduto(repoService.NomeDaOrganizacao, repoService.IsOffline)
{
codEstabelecimento = estabelecimento.Codigo.Value,
CodigoProduto = produto.Codigo,
ContaId = solicBen.Canal.Id,
Produto = produto,
TipoCrossSelling = false,
Quantidade = Convert.ToInt32(produtoSolicitacao.QuantidadeAprovada.Value)
});
if (conta.Classificacao.Name != "Revendas")
{
var precoProduto = new ProdutoService(repoService).ListarPor(lstPrecoProduto).First();
if (precoProduto == null || precoProduto.ValorProduto <= 0)
{
throw new ArgumentException("(CRM) Não foi possível calcular o preço do produto [" + produto.Nome + "]. Verifique política comercial");
}
valorUnitario = precoProduto.ValorProduto;
}
else
{
ListaPrecoPSDPPPSCF lstListaPreco = repoService.ListaPrecoPSD.ObterPor(conta.Endereco1Estadoid.Id, produto.UnidadeNegocio.Id);
if (lstListaPreco == null)
{
throw new ArgumentException("(CRM) Não foi possível encontrar uma Lista de Preço(PSD) para o Estado [" + conta.Endereco1Estadoid.Name + "] e Unidade de Negócio [" + produto.UnidadeNegocio.Name + "]");
}
var precoProduto = repoService.ProdutoListaPSD.ListarPor(lstListaPreco.ID.Value, produto.ID).First();
if (precoProduto == null || precoProduto.ValorPSD <= 0)
{
throw new ArgumentException("(CRM) Não foi possível calcular o preço do produto [" + produto.Nome + "]. Verifique a Lista PSD para o Estado [" + conta.Endereco1Estadoid.Name + "]");
}
valorUnitario = precoProduto.ValorPSD.Value;
}
}
else
{
ProdutoFatura prodFatura = repoService.ProdutoFatura.ObterObtemPorNotaFiscal(produtoSolicitacao.Produto.Id, produtoSolicitacao.Fatura.Id);
if (prodFatura != null)
{
valorUnitario = prodFatura.ValorLiquido.Value;
}
else
{
throw new ArgumentException("(CRM) Produto não localizado na nota fiscal informada.");
}
}
valorUnitario = CalcularDescontoValorSolicitado(valorUnitario, beneficio, unidadeNegocio, classificacao, categoria, repoService);
valorUnitario = decimal.Round(valorUnitario, 2);
valoresCalculados[0] = valorUnitario;
valoresCalculados[1] = valorUnitario * produtoSolicitacao.QuantidadeAprovada.Value;
return(valoresCalculados);
}
public bool CriarTarefa(Lookup referenteA, string tiposolicitacaonome, string descricao, string ParecerAnterior, ParticipantesDoProcesso PartProcesso)
{
Guid idProprietario = Guid.Empty;
string tipoProprietario = "";
Model.Tarefa task = new Model.Tarefa(NomeDaOrganizacao, _isOffline);
Model.SolicitacaoBeneficio tmpSolBen = new SolicitacaoBeneficio(NomeDaOrganizacao, _isOffline);
Model.SolicitacaoCadastro tmpSolCad = new SolicitacaoCadastro(NomeDaOrganizacao, _isOffline);
List <RelacionamentoCanal> lstRelacionamento = new List <RelacionamentoCanal>();
task.Assunto = "Plugin - " + referenteA.Name;
task.ReferenteA = new Lookup(referenteA.Id, referenteA.Type);
task.Assunto = PartProcesso.Papel.Name + " - " + tiposolicitacaonome;
task.Ordem = PartProcesso.Ordem;
task.PareceresAnteriores = ParecerAnterior;
task.DescricaoSolicitacao = descricao;
task.Conclusao = DateTime.Now.AddDays(1).AddHours(3);
TipoDeAtividade tmpTipoDeAtividade = RepositoryService.TipoDeAtividade.ObterPorPapel(PartProcesso.Papel.Id);
if (tmpTipoDeAtividade == null)
{
throw new ArgumentException("Tipo de Atividade do Participante Não Encontrado! : " + PartProcesso.Papel.Name + " : " + PartProcesso.Papel.Id.ToString());
}
if (tmpTipoDeAtividade.ID.HasValue)
{
task.TipoDeAtividade = new Lookup(tmpTipoDeAtividade.ID.Value, "itbc_tipoatividade");
}
if (PartProcesso.Equipe != null)
{
idProprietario = PartProcesso.Equipe.Id;
tipoProprietario = PartProcesso.Equipe.Type;
}
if (PartProcesso.Usuario != null)
{
idProprietario = PartProcesso.Usuario.Id;
tipoProprietario = PartProcesso.Usuario.Type;
}
if (PartProcesso.Contato != null)
{
idProprietario = PartProcesso.Contato.Id;
tipoProprietario = PartProcesso.Contato.Type;
}
if (PartProcesso.PapelNoCanal.HasValue)
{
if (referenteA.Type.ToLower().Equals(SDKore.Crm.Util.Utility.GetEntityName <SolicitacaoCadastro>().ToLower()))
{
tmpSolCad = RepositoryService.SolicitacaoCadastro.Retrieve(referenteA.Id);
lstRelacionamento = RepositoryService.RelacionamentoDoCanal.ListarPor(tmpSolCad.Canal.Id);
}
if (referenteA.Type.ToLower().Equals(SDKore.Crm.Util.Utility.GetEntityName <SolicitacaoBeneficio>().ToLower()))
{
tmpSolBen = RepositoryService.SolicitacaoBeneficio.Retrieve(referenteA.Id);
lstRelacionamento = RepositoryService.RelacionamentoDoCanal.ListarPor(tmpSolBen.Canal.Id);
}
if (PartProcesso.PapelNoCanal.Value == (int)Domain.Enum.ParticipanteDoCanal.PapelNoCanal.DiretorDeUnidade)
{
if (lstRelacionamento.First <RelacionamentoCanal>().Supervisor == null)
{
throw new ArgumentException("Diretor da Unidade Não encontrado. Não é possivel criar o próximo passo de Tarefa!");
}
Usuario _usuario = new Intelbras.CRM2013.Domain.Servicos.UsuarioService(RepositoryService.NomeDaOrganizacao, RepositoryService.IsOffline).ObterPor(lstRelacionamento.First <RelacionamentoCanal>().Supervisor.Id);
if (_usuario == null)
{
throw new ArgumentException("Não foi encontrado o usuário.");
}
if (_usuario.Gerente == null)
{
throw new ArgumentException("Gerente do Supervisor não confiurado.Operação cancelada.");
}
//Descemos mais um nivel para pegar o gerente do gerente
_usuario = new Intelbras.CRM2013.Domain.Servicos.UsuarioService(RepositoryService.NomeDaOrganizacao, RepositoryService.IsOffline).ObterPor(_usuario.Gerente.Id);
if (_usuario == null)
{
throw new ArgumentException("Não foi encontrado o usuário.");
}
if (_usuario.Gerente == null)
{
throw new ArgumentException("Gerente do Supervisor não confiurado.Operação cancelada.");
}
idProprietario = _usuario.Gerente.Id;
tipoProprietario = _usuario.Gerente.Type;
}
if (PartProcesso.PapelNoCanal.Value == (int)Domain.Enum.ParticipanteDoCanal.PapelNoCanal.GerenteNacionalGerenteDeDistribuicao)
{
if (lstRelacionamento.First <RelacionamentoCanal>().Supervisor == null)
{
throw new ArgumentException("Gerente Nacional Gerente De Distribuicao Não encontrado. Não é possivel criar o próximo passo de Tarefa!");
}
Usuario _usuario = new Intelbras.CRM2013.Domain.Servicos.UsuarioService(RepositoryService.NomeDaOrganizacao, RepositoryService.IsOffline).ObterPor(lstRelacionamento.First <RelacionamentoCanal>().Supervisor.Id);
if (_usuario == null)
{
throw new ArgumentException("Não foi encontrado o usuário.");
}
if (_usuario.Gerente == null)
{
throw new ArgumentException("Gerente do Supervisor não confiurado.Operação cancelada.");
}
idProprietario = _usuario.Gerente.Id;
tipoProprietario = _usuario.Gerente.Type;
}
if (PartProcesso.PapelNoCanal.Value == (int)Domain.Enum.ParticipanteDoCanal.PapelNoCanal.KeyAccountRepresentante)
{
if (lstRelacionamento.First <RelacionamentoCanal>().Supervisor != null)
{
idProprietario = lstRelacionamento.First <RelacionamentoCanal>().Supervisor.Id;
tipoProprietario = lstRelacionamento.First <RelacionamentoCanal>().Supervisor.Type;
}
else
{
throw new ArgumentException("Key Account Representante Não encontrado. Não é possivel criar o próximo passo de Tarefa!");
}
}
if (PartProcesso.PapelNoCanal.Value == (int)Domain.Enum.ParticipanteDoCanal.PapelNoCanal.SupervisorDeVendas)
{
if (lstRelacionamento.First <RelacionamentoCanal>().Supervisor != null)
{
idProprietario = lstRelacionamento.First <RelacionamentoCanal>().Supervisor.Id;
tipoProprietario = lstRelacionamento.First <RelacionamentoCanal>().Supervisor.Type;
}
else
{
throw new ArgumentException("Supervisor De Vendas Não encontrado. Não é possivel criar o próximo passo de Tarefa!");
}
}
}
Guid idTask = RepositoryService.Tarefa.Create(task);
if (idTask != Guid.Empty)
{
new Domain.Servicos.UtilService(RepositoryService.NomeDaOrganizacao, RepositoryService.IsOffline, RepositoryService.Provider).MudarProprietarioRegistro(tipoProprietario, idProprietario, "task", idTask);
}
return(true);
}
private void AtualizaDataLimiteAposCriacao(SolicitacaoBeneficioService ServiceSolicitacaoBeneficio, ref SolicitacaoBeneficio solicitacaoBeneficio, ref Entity e)
{
bool criadaNoPrazo = ServiceSolicitacaoBeneficio.CriadaAposDataLimite(solicitacaoBeneficio);
e.Attributes["itbc_criada_apos_data_limite"] = criadaNoPrazo;
solicitacaoBeneficio.CriadaAposDataLimite = criadaNoPrazo;
}
protected override void Execute(IPluginExecutionContext context, IOrganizationServiceFactory serviceFactory, IOrganizationService adminService, IOrganizationService userService)
{
var produtosdaSolicitacaoService = new ProdutosdaSolicitacaoService(context.OrganizationName, context.IsExecutingOffline, userService);
repoService = new RepositoryService(context.OrganizationName, context.IsExecutingOffline, userService);
switch (Util.Utilitario.ConverterEnum <Domain.Enum.Plugin.MessageName>(context.MessageName))
{
#region Create
case Domain.Enum.Plugin.MessageName.Create:
{
var targetCreate = (Entity)context.InputParameters["Target"];
AtualizarValorAprovado(ref targetCreate);
var produtosdaSolicitacaoCreate = targetCreate.Parse <ProdutosdaSolicitacao>(context.OrganizationName, context.IsExecutingOffline, userService);
produtosdaSolicitacaoService.ValidaCamposObrigatorios(produtosdaSolicitacaoCreate);
AtualizaEstabelecimento(produtosdaSolicitacaoService, ref produtosdaSolicitacaoCreate, ref targetCreate);
ValidarDuplicidade(produtosdaSolicitacaoService, produtosdaSolicitacaoCreate);
ProdutoPortfolio produtoPortfolio1;
produtosdaSolicitacaoService.ValidaIntegridadeDados(produtosdaSolicitacaoCreate, out produtoPortfolio1);
AtualizaValores(produtosdaSolicitacaoService, repoService, ref produtosdaSolicitacaoCreate, ref targetCreate);
break;
}
#endregion
#region Update
case Domain.Enum.Plugin.MessageName.Update:
var targetUpdate = context.GetContextEntity();
var preImageUpdate = context.PreEntityImages["imagem"];
var produtoSolicitacaoMergeUpdate = preImageUpdate.Parse <ProdutosdaSolicitacao>(context.OrganizationName, context.IsExecutingOffline, adminService);
SolicitacaoBeneficio solicBenef = repoService.SolicitacaoBeneficio.ObterPor(produtoSolicitacaoMergeUpdate.SolicitacaoBeneficio.Id, 0);
if (solicBenef.TipoPriceProtection != (int)Domain.Enum.SolicitacaoBeneficio.TipoPriceProtection.Autorizacao)
{
AtualizarValorAprovado(ref targetUpdate);
}
var produtoSolicitacaoTargetUpdate = targetUpdate.Parse <ProdutosdaSolicitacao>(context.OrganizationName, context.IsExecutingOffline, userService);
foreach (var item in targetUpdate.Attributes)
{
preImageUpdate.Attributes[item.Key] = item.Value;
}
if (produtoSolicitacaoMergeUpdate.State.HasValue && produtoSolicitacaoMergeUpdate.State.Value == (int)Domain.Enum.ProdutoSolicitacao.Status.Inativo)
{
break;
}
produtosdaSolicitacaoService.ValidaCamposObrigatorios(produtoSolicitacaoMergeUpdate);
ValidaAlteracaoProduto(produtoSolicitacaoTargetUpdate, produtoSolicitacaoMergeUpdate);
produtosdaSolicitacaoService.VerificaStatusDaSolicitacao(produtoSolicitacaoMergeUpdate, produtoSolicitacaoTargetUpdate.IntegradoDe);
AtualizaEstabelecimento(produtosdaSolicitacaoService, ref produtoSolicitacaoMergeUpdate, ref targetUpdate);
//ProdutoPortfolio produtoPortfolio;
//produtosdaSolicitacaoService.ValidaIntegridadeDados(produtoSolicitacaoMergeUpdate, out produtoPortfolio);
//AtualizaValores(produtosdaSolicitacaoService, repoService, ref produtoSolicitacaoMergeUpdate, ref targetUpdate);
solicBenef = repoService.SolicitacaoBeneficio.Retrieve(produtoSolicitacaoMergeUpdate.SolicitacaoBeneficio.Id);
ValidarDuplicidade(produtosdaSolicitacaoService, produtoSolicitacaoMergeUpdate);
break;
#endregion
#region Delete
case Domain.Enum.Plugin.MessageName.Delete:
var preImageDelete = context.PreEntityImages["imagem"];
var produtoSolicitacaoDelete = preImageDelete.Parse <ProdutosdaSolicitacao>(context.OrganizationName, context.IsExecutingOffline, adminService);
var ServiceProdutosSolicitacao = new ProdutosdaSolicitacaoService(context.OrganizationName, context.IsExecutingOffline, userService);
produtosdaSolicitacaoService.VerificaStatusDaSolicitacao(produtoSolicitacaoDelete, "");
break;
#endregion
}
}
private Intelbras.Message.Helper.MSG0155 DefinirPropriedadesPlugin(SolicitacaoBeneficio crm)
{
Intelbras.Message.Helper.MSG0155 objPollux = new Pollux.MSG0155(Domain.Enum.Sistemas.RetornaSistema(Domain.Enum.Sistemas.Sistema.CRM), crm.Nome.Truncate(40));
objPollux.CodigoSolicitacaoBeneficio = crm.ID.ToString();
objPollux.ValorAprovado = crm.ValorAprovado;
if (!String.IsNullOrEmpty(crm.Nome))
{
objPollux.NomeSolicitacaoBeneficio = crm.Nome;
}
else
{
throw new ArgumentException("(CRM) Nome SolicitacaoBeneficio não preenchido.");
}
if (crm.UnidadedeNegocio != null)
{
UnidadeNegocio unidadeNegocio = new Servicos.UnidadeNegocioService(this.Organizacao, this.IsOffline).BuscaUnidadeNegocio(crm.UnidadedeNegocio.Id);
if (unidadeNegocio != null)
{
objPollux.CodigoUnidadeNegocio = unidadeNegocio.ChaveIntegracao;
}
}
else
{
throw new ArgumentException("(CRM) UnidadedeNegocio não preenchida.");
}
if (!String.IsNullOrEmpty(crm.Nome))
{
objPollux.DescricaoSituacaoIrregular = crm.SituacaoIrregular;
}
if (crm.BeneficioCanal != null)
{
objPollux.CodigoBeneficioCanal = crm.BeneficioCanal.Id.ToString();
}
else
{
throw new ArgumentException("(CRM) BeneficioCanal não preenchido.");
}
if (crm.ValorSolicitado.HasValue)
{
objPollux.ValorSolicitado = crm.ValorSolicitado.Value;
}
objPollux.DescricaoSolicitacao = crm.Descricao;
if (crm.StatusSolicitacao.HasValue)
{
objPollux.SituacaoSolicitacaoBeneficio = crm.StatusSolicitacao.Value;
}
if (crm.State.HasValue)
{
objPollux.Situacao = crm.State.Value;
}
if (crm.Status.HasValue)
{
objPollux.RazaoStatusSolicitacaoBeneficio = crm.Status.Value;
}
if (crm.FormaPagamento != null)
{
objPollux.CodigoFormaPagamento = crm.FormaPagamento.Id.ToString();
}
else
{
throw new ArgumentException("(CRM) FormaPagamento não preenchida.");
}
if (crm.Canal != null)
{
objPollux.CodigoConta = crm.Canal.Id.ToString();
}
else
{
throw new ArgumentException("(CRM) Canal não preenchido.");
}
if (crm.BeneficioPrograma != null)
{
objPollux.CodigoBeneficio = crm.BeneficioPrograma.Id.ToString();
Beneficio benefProg = new Intelbras.CRM2013.Domain.Servicos.BeneficioService(this.Organizacao, this.IsOffline).ObterPor(crm.BeneficioPrograma.Id);
if (benefProg != null && benefProg.Codigo.HasValue)
{
objPollux.BeneficioCodigo = benefProg.Codigo.Value;
}
}
else
{
throw new ArgumentException("(CRM) BeneficioPrograma não preenchido.");
}
objPollux.Proprietario = "259A8E4F-15E9-E311-9420-00155D013D39";
objPollux.TipoProprietario = "systemuser";
if (crm.TipoSolicitacao != null)
{
objPollux.CodigoTipoSolicitacao = crm.TipoSolicitacao.Id.ToString();
}
else
{
throw new ArgumentException("(CRM) CodigoTipoSolicitacao não enviado.");
}
if (crm.SituacaoIrregularidades.HasValue)
{
objPollux.SolicitacaoIrregular = crm.SituacaoIrregularidades.Value;
}
objPollux.ProdutoSolicitacaoItens = this.RetornaListaItens(crm.ID.Value);
if (crm.AlteradaParaStockRotation.HasValue)
{
objPollux.AlteradaStockRotation = crm.AlteradaParaStockRotation.Value;
}
else
{
objPollux.AlteradaStockRotation = false;
}
if (crm.TipoPriceProtection.HasValue)
{
objPollux.TipoPriceProtection = crm.TipoPriceProtection.Value;
}
else
{
objPollux.TipoPriceProtection = (int)Enum.SolicitacaoBeneficio.TipoPriceProtection.Consumo;
}
//Novos Campos
if (crm.AjusteSaldo.HasValue)
{
objPollux.SolicitacaoAjuste = crm.AjusteSaldo.Value;
}
if (crm.StatusCalculoPriceProtection.HasValue)
{
objPollux.StatusCalculoPriceProtection = crm.StatusCalculoPriceProtection.Value;
}
if (crm.ValorAbater.HasValue)
{
objPollux.ValorAbater = crm.ValorAbater.Value;
}
else
{
objPollux.ValorAbater = new decimal(0);
}
Usuario assistente = new Servicos.UsuarioService(this.Organizacao, this.IsOffline).ObterPor(crm.Assistente.Id);
if (assistente != null)
{
objPollux.CodigoAssistente = assistente.CodigoAssistenteComercial.Value;
}
else
{
throw new ApplicationException("(CRM) Assistente não cadastrado / Obrigatório.");
}
Usuario supervisor = new Servicos.UsuarioService(this.Organizacao, this.IsOffline).ObterPor(crm.Supervisor.Id);
if (supervisor != null)
{
objPollux.CodigoSupervisorEMS = supervisor.CodigoSupervisorEMS;
}
else
{
throw new ApplicationException("(CRM) Supervisor não cadastrado / Obrigatório.");
}
if (crm.Filial != null)
{
objPollux.CodigoFilial = crm.Filial.Id.ToString();
}
if (crm.StatusPagamento.HasValue)
{
objPollux.StatusPagamento = crm.StatusPagamento;
}
if (crm.ValorPago.HasValue)
{
objPollux.ValorPago = crm.ValorPago.Value;
}
if (crm.ValorCancelado.HasValue)
{
objPollux.ValorCancelado = crm.ValorCancelado.Value;
}
if (crm.DataCriacao.HasValue)
{
objPollux.DataCriacao = crm.DataCriacao.Value.ToLocalTime();
}
else
{
throw new ArgumentException("(CRM) DataCriacao não cadastrada / Obrigatório.");
}
if (crm.DataValidade.HasValue)
{
objPollux.DataValidade = crm.DataValidade;
}
else
{
throw new ArgumentException("(CRM) DataValidade não cadastrada / Obrigatório.");
}
if (crm.CondicaoPagamento != null)
{
CondicaoPagamento condicaoPagamento = new Servicos.CondicaoPagamentoService(this.Organizacao, this.IsOffline).BuscaCondicaoPagamento(crm.CondicaoPagamento.Id);
if (condicaoPagamento != null)
{
if (condicaoPagamento.Codigo.HasValue)
{
objPollux.CodigoCondicaoPagamento = condicaoPagamento.Codigo.Value;
}
}
}
if (crm.DescartarVerba.HasValue)
{
objPollux.DescartarVerba = crm.DescartarVerba.Value;
}
if (!string.IsNullOrEmpty(crm.TrimestreCompetencia))
{
objPollux.TrimestreCompetencia = crm.TrimestreCompetencia;
}
else
{
throw new ArgumentException("(CRM) TrimestreCompetencia não cadastrada / Obrigatório.");
}
objPollux.FormaCancelamento = crm.FormaCancelamento;
return(objPollux);
}
public SolicitacaoBeneficio DefinirPropriedades(Intelbras.Message.Helper.MSG0147 xml)
{
SolicitacaoBeneficio retorno = new SolicitacaoBeneficio(Organizacao, IsOffline);
return(retorno);
}
private void AtualizaValores(SolicitacaoBeneficioService ServiceSolicitacaoBeneficio, ref SolicitacaoBeneficio solicitacaoBeneficio, ref Entity e)
{
decimal?valorAbater = ServiceSolicitacaoBeneficio.ObterValorAbater(solicitacaoBeneficio);
if (valorAbater.HasValue)
{
e.Attributes["itbc_valoraabater"] = new Money(valorAbater.Value);
solicitacaoBeneficio.ValorAbater = valorAbater;
}
var retornoValores = ServiceSolicitacaoBeneficio.RecalculaValoresNaAlteracaoDeStatus(solicitacaoBeneficio, solicitacaoBeneficio);
if (retornoValores.ValorAprovado.HasValue)
{
e.Attributes["itbc_valoraprovado"] = new Money(retornoValores.ValorAprovado.Value);
solicitacaoBeneficio.ValorAprovado = retornoValores.ValorAprovado;
}
}
private void ValidaValorAprovado(SolicitacaoBeneficioService ServiceSolicitacaoBeneficio, SolicitacaoBeneficio solicitacaoBeneficio)
{
ServiceSolicitacaoBeneficio.ValidaValorAprovado(solicitacaoBeneficio);
}
public void EnvioDeEvidenciaShowRoom(Tarefa Task)
{
SolicitacaoBeneficio solBen = RepositoryService.SolicitacaoBeneficio.Retrieve(Task.ReferenteA.Id);
CompromissosDoCanal compromissoCanal = RepositoryService.CompromissosDoCanal.ObterPorNome(Enum.CompromissoCanal.Compromisso.EnvioShowroom.ToString(), solBen.Canal.Id, solBen.UnidadedeNegocio.Id);
if (compromissoCanal != null)
{
if (compromissoCanal.Compromisso.Name == Enum.CompromissoCanal.Compromisso.EnvioShowroom)
{
if (!Task.ReferenteA.Type.ToLower().Equals(SDKore.Crm.Util.Utility.GetEntityName <SolicitacaoBeneficio>().ToLower()))
{
return;
}
compromissoCanal.StatusCompromisso = new Lookup(RepositoryService.StatusCompromissos.ObterPor(Domain.Enum.CompromissoCanal.StatusCompromisso.Cumprido).ID.Value, "");
RepositoryService.CompromissosDoCanal.Update(compromissoCanal);
SolicitacaoBeneficio mSolicitacaoBeneficio = RepositoryService.SolicitacaoBeneficio.Retrieve(Task.ReferenteA.Id);
if (mSolicitacaoBeneficio == null)
{
throw new ArgumentException("Solicitação de benefício no campo 'Referente a' não encontrada ou Desativada.");
}
ParametroGlobal parametroAtividadeQtdeEvidencia = RepositoryService.ParametroGlobal.ObterPor((int)Enum.TipoParametroGlobal.QuatidadeEvidenciaShowRoom, mSolicitacaoBeneficio.UnidadedeNegocio.Id, null, null, null, compromissoCanal.Compromisso.Id, null, null);
if (parametroAtividadeQtdeEvidencia == null)
{
throw new ArgumentException("(CRM) Parâmetro Global Quantidade de Evidências Show Room não encontrado para o Compromisso Envio de evidências de Showroom e Unidade de Negócio [" + mSolicitacaoBeneficio.UnidadedeNegocio.Name + "].");
}
ParametroGlobal parametroAtividadeChacklist = RepositoryService.ParametroGlobal.ObterPor((int)Enum.TipoParametroGlobal.AtividadesChecklist, mSolicitacaoBeneficio.UnidadedeNegocio.Id, null, null, null, compromissoCanal.Compromisso.Id, null, null);
if (parametroAtividadeChacklist == null)
{
throw new ArgumentException("(CRM) Parâmetro Global Atividade de Checklist não encontrado para o Compromisso Envio de evidências de Showroom e Unidade de Negócio [" + mSolicitacaoBeneficio.UnidadedeNegocio.Name + "].");
}
ParametroGlobal parametroFrequenciaChecklist = RepositoryService.ParametroGlobal.ObterPor((int)Enum.TipoParametroGlobal.FrequenciaChecklist, mSolicitacaoBeneficio.UnidadedeNegocio.Id, null, null, null, compromissoCanal.Compromisso.Id, null, null);
if (parametroFrequenciaChecklist == null)
{
throw new ArgumentException("(CRM) Parâmetro Global Frequencia de Checklist não encontrado para o Compromisso Envio de evidências de Showroom e Unidade de Negócio [" + mSolicitacaoBeneficio.UnidadedeNegocio.Name + "].");
}
Tarefa task = new Tarefa(RepositoryService.NomeDaOrganizacao, RepositoryService.IsOffline);
task.ReferenteA = new Lookup(compromissoCanal.ID.Value, SDKore.Crm.Util.Utility.GetEntityName <CompromissosDoPrograma>());
task.Assunto = parametroAtividadeChacklist.GetValue <string>();
task.Ordem = Task.Ordem + 1;
task.Conclusao = DateTime.Now.AddDays(parametroFrequenciaChecklist.GetValue <int>());
var tipoTarefa = new TarefaService(RepositoryService.NomeDaOrganizacao, RepositoryService.IsOffline).BuscarTipoTarefa("Checklist");
if (tipoTarefa != null)
{
task.TipoDeAtividade = new Lookup(tipoTarefa.ID.Value, SDKore.Crm.Util.Utility.GetEntityName(tipoTarefa));
}
Conta canal = RepositoryService.Conta.Retrieve(mSolicitacaoBeneficio.Canal.Id, "ownerid");
Guid idTarefa = RepositoryService.Tarefa.Create(task);
if (idTarefa != Guid.Empty)
{
if (canal != null)
{
Domain.Model.Usuario proprietario = new Domain.Servicos.UsuarioService(RepositoryService.NomeDaOrganizacao, RepositoryService.IsOffline).BuscarProprietario("account", "accountid", canal.Id);
if (proprietario != null)
{
new Domain.Servicos.UtilService(RepositoryService.NomeDaOrganizacao, RepositoryService.IsOffline).MudarProprietarioRegistro("systemuser", proprietario.ID.Value, "task", idTarefa);
}
}
}
}
}
}
/*
* Removido do código. Essa verificação será feita futuramente
* private void AtualizaSituacaoInrregular(SolicitacaoBeneficioService ServiceSolicitacaoBeneficio, SolicitacaoBeneficio solicitacaoBeneficio, ref Entity e)
* {
* bool situacaoInregular = ServiceSolicitacaoBeneficio.TemSituacaoInregularVMC(solicitacaoBeneficio);
* e["itbc_solicitacao_irregularidades"] = situacaoInregular;
*
*
* if (situacaoInregular)
* {
* e["itbc_situacao_irregular"] = "Solicitação de VMC acima do percentual determinado pela Intelbras.";
* }
*
* }
*/
private void AtualizaTrimestreCompetencia(SolicitacaoBeneficioService ServiceSolicitacaoBeneficio, SolicitacaoBeneficio solicitacaoBeneficio, ref Entity e)
{
if (!e.Contains("itbc_trimestrecompetencia"))
{
e.Attributes["itbc_trimestrecompetencia"] = ServiceSolicitacaoBeneficio.ObterTrimestreCompetencia();
}
}
private void AtualizaCodicaoPagamento(SolicitacaoBeneficioService ServiceSolicitacaoBeneficio, SolicitacaoBeneficio solicitacaoBeneficio, ref Entity e)
{
if (e.Attributes.Contains("itbc_formapagamentoid"))
{
var condicaoPagamento = ServiceSolicitacaoBeneficio.ObterCondicaoDePagamento(solicitacaoBeneficio);
if (condicaoPagamento != null)
{
e.Attributes["itbc_condicaopagamentoid"] = new EntityReference()
{
Id = condicaoPagamento.ID.Value,
LogicalName = SDKore.Crm.Util.Utility.GetEntityName(condicaoPagamento),
Name = condicaoPagamento.Nome
};
}
}
}
private void AtualizaInformacoesPortfolio(SolicitacaoBeneficioService ServiceSolicitacaoBeneficio, SolicitacaoBeneficio solicitacaoBeneficio, ref Entity e)
{
var portfolioRepresentante = ServiceSolicitacaoBeneficio.ObterPortfolioRepresentante(solicitacaoBeneficio);
if (portfolioRepresentante != null)
{
e.Attributes["itbc_assistadmvendasid"] = new EntityReference()
{
Id = portfolioRepresentante.AssistentedeAdministracaodeVendas.Id,
LogicalName = SDKore.Crm.Util.Utility.GetEntityName <Usuario>(),
Name = portfolioRepresentante.AssistentedeAdministracaodeVendas.Name
};
e.Attributes["itbc_supervisorid"] = new EntityReference()
{
Id = portfolioRepresentante.SupervisordeVendas.Id,
LogicalName = SDKore.Crm.Util.Utility.GetEntityName <Usuario>(),
Name = portfolioRepresentante.SupervisordeVendas.Name
};
e.Attributes["itbc_karepresentanteresponsvel"] = new EntityReference()
{
Id = portfolioRepresentante.KeyAccountRepresentante.Id,
LogicalName = SDKore.Crm.Util.Utility.GetEntityName <Contato>(),
Name = portfolioRepresentante.KeyAccountRepresentante.Name
};
}
}
public string Enviar(SolicitacaoBeneficio objModel)
{
string resposta = string.Empty;
return(resposta);
}
public List <ValorProdutoICMSViewModel> Enviar(List <Product> objModel, List <ProdutosdaSolicitacao> prodSolicLst, List <PrecoProduto> precoProdutoLst, SolicitacaoBeneficio solicBenef)
{
List <ValorProdutoICMSViewModel> valProdICMSLst = null;
string retMsg = String.Empty;
Intelbras.Message.Helper.MSG0138 mensagem = this.DefinirPropriedades(objModel, prodSolicLst, precoProdutoLst, solicBenef);
Domain.Servicos.Integracao integracao = new Servicos.Integracao(this.Organizacao, this.IsOffline);
if (integracao.EnviarMensagemBarramento(mensagem.GenerateMessage(true), "1", "1", out retMsg))
{
Intelbras.Message.Helper.MSG0138R1 retorno = CarregarMensagem <Pollux.MSG0138R1>(retMsg);
if (!retorno.Resultado.Sucesso)
{
throw new Exception(retorno.Resultado.Mensagem);
}
else
{
valProdICMSLst = new List <ValorProdutoICMSViewModel>();
foreach (var retornoObj in retorno.ProdutosItens)
{
var valProd = new ValorProdutoICMSViewModel();
valProd.AliquotaICMS = retornoObj.AliquotaICMS;
valProd.PrecoLiquido = retornoObj.PrecoLiquido;
valProd.CodigoProduto = retornoObj.CodigoProduto;
valProdICMSLst.Add(valProd);
}
}
}
else
{
Intelbras.Message.Helper.ERR0001 erro001 = CarregarMensagem <Pollux.ERR0001>(retMsg);
throw new Exception(erro001.GenerateMessage(false));
}
return(valProdICMSLst);
}
public void ConcluirTarefaSolicitacaoBeneficio(Tarefa Task, Guid UsuarioId)
{
if (Task.State.Value != (int)Enum.Tarefa.StateCode.Cancelada)
{
SolicitacaoBeneficio solicitacaoBeneficio = RepositoryService.SolicitacaoBeneficio.Retrieve(Task.ReferenteA.Id);
if (solicitacaoBeneficio == null)
{
throw new ArgumentException("(CRM) Solicitação de benefício no campo 'Referente a' não encontrada ou Desativada.");
}
#region Bloco para ajuste manual
Guid tipoAtividadeExecucao;
if (!Guid.TryParse(ConfigurationManager.GetSettingValue("TipoAtividadeExecucao"), out tipoAtividadeExecucao))
{
throw new ArgumentException("(CRM) Faltando parâmetro TipoAtividadeExecucao no SDKore");
}
if (solicitacaoBeneficio.StatusSolicitacao.Value == (int)Enum.SolicitacaoBeneficio.StatusSolicitacaoBeneficio.PagamentoEfetuado)
{
Task.Resultado = (int)Enum.Tarefa.Resultado.PagamentoEfetuadoPedidoGerado;
}
if (!Task.Resultado.HasValue && solicitacaoBeneficio.TipoSolicitacao != null &&
solicitacaoBeneficio.AjusteSaldo.Value &&
Task.TipoDeAtividade != null &&
Task.TipoDeAtividade.Id == tipoAtividadeExecucao)
{
Task.Resultado = (int)Enum.Tarefa.Resultado.PagamentoEfetuadoPedidoGerado;
}
#endregion
solicitacaoBeneficio.IntegrarNoPlugin = false;
switch ((Enum.Tarefa.Resultado)Task.Resultado.Value)
{
case Domain.Enum.Tarefa.Resultado.Reprovada:
solicitacaoBeneficio.StatusSolicitacao = (int)Enum.SolicitacaoBeneficio.StatusSolicitacaoBeneficio.Cancelada;
solicitacaoBeneficio.Status = (int)Enum.SolicitacaoBeneficio.RazaoStatusAtivo.NaoAprovada;
RepositoryService.SolicitacaoBeneficio.Update(solicitacaoBeneficio);
RepositoryService.SolicitacaoBeneficio.AlterarStatus(solicitacaoBeneficio.ID.Value, solicitacaoBeneficio.State.Value, solicitacaoBeneficio.Status.Value);
return;
case Enum.Tarefa.Resultado.Aprovada:
//Após análise com o José Luiz, foi identificado que essa rotina não faz sentido - 13/09/2016 - Robson Bertolli
//EnvioDeEvidenciaShowRoom(Task);
var solicitacaoAprovada = new SolicitacaoBeneficio(solicitacaoBeneficio.OrganizationName, solicitacaoBeneficio.IsOffline)
{
ID = solicitacaoBeneficio.ID,
StatusSolicitacao = (int)Enum.SolicitacaoBeneficio.StatusSolicitacaoBeneficio.Aprovada,
Status = (int)Enum.SolicitacaoBeneficio.RazaoStatusAtivo.AprovadaParaReembolso,
DataAprovacao = DateTime.Now,
IntegrarNoPlugin = false
};
RepositoryService.SolicitacaoBeneficio.Update(solicitacaoAprovada);
break;
case Enum.Tarefa.Resultado.ComprovantesValidados:
solicitacaoBeneficio.StatusSolicitacao = (int)Enum.SolicitacaoBeneficio.StatusSolicitacaoBeneficio.AguardandoRetornoFinanceiro;
solicitacaoBeneficio.Status = (int)Enum.SolicitacaoBeneficio.RazaoStatusAtivo.AprovadaParaReembolso;
solicitacaoBeneficio.State = (int)Enum.SolicitacaoBeneficio.State.Ativo;
RepositoryService.SolicitacaoBeneficio.Update(solicitacaoBeneficio);
RepositoryService.SolicitacaoBeneficio.AlterarStatus(solicitacaoBeneficio.ID.Value, solicitacaoBeneficio.State.Value, solicitacaoBeneficio.Status.Value);
break;
case Enum.Tarefa.Resultado.RetornoFinanceiroValidado:
solicitacaoBeneficio.StatusSolicitacao = (int)Enum.SolicitacaoBeneficio.StatusSolicitacaoBeneficio.RetornoFinanceiroValidado;
solicitacaoBeneficio.Status = (int)Enum.SolicitacaoBeneficio.RazaoStatusAtivo.AprovadaParaReembolso;
solicitacaoBeneficio.State = (int)Enum.SolicitacaoBeneficio.State.Ativo;
RepositoryService.SolicitacaoBeneficio.Update(solicitacaoBeneficio);
RepositoryService.SolicitacaoBeneficio.AlterarStatus(solicitacaoBeneficio.ID.Value, solicitacaoBeneficio.State.Value, solicitacaoBeneficio.Status.Value);
break;
case Enum.Tarefa.Resultado.PagamentoAutorizado:
var solicitacaoPagamentoAutorizado = new SolicitacaoBeneficio(solicitacaoBeneficio.OrganizationName, solicitacaoBeneficio.IsOffline)
{
ID = solicitacaoBeneficio.ID,
StatusSolicitacao = (int)Enum.SolicitacaoBeneficio.StatusSolicitacaoBeneficio.PagamentoPendente,
Status = (int)Enum.SolicitacaoBeneficio.RazaoStatusAtivo.ReembolsoPendente,
IntegrarNoPlugin = false
};
RepositoryService.SolicitacaoBeneficio.Update(solicitacaoPagamentoAutorizado);
break;
case Enum.Tarefa.Resultado.PagamentoEfetuadoPedidoGerado:
if (solicitacaoBeneficio.StatusSolicitacao != (int)Enum.SolicitacaoBeneficio.StatusSolicitacaoBeneficio.PagamentoEfetuado)
{
var solicitacaoPagamentoEfetuado = new SolicitacaoBeneficio(solicitacaoBeneficio.OrganizationName, solicitacaoBeneficio.IsOffline)
{
ID = solicitacaoBeneficio.ID,
StatusSolicitacao = (int)Enum.SolicitacaoBeneficio.StatusSolicitacaoBeneficio.PagamentoEfetuado,
Status = (int)Enum.SolicitacaoBeneficio.RazaoStatusAtivo.Reembolsado,
IntegrarNoPlugin = true
};
RepositoryService.SolicitacaoBeneficio.Update(solicitacaoPagamentoEfetuado);
}
break;
case Enum.Tarefa.Resultado.PagamentoNaoAutorizado:
solicitacaoBeneficio.StatusSolicitacao = (int)Enum.SolicitacaoBeneficio.StatusSolicitacaoBeneficio.Cancelada;
solicitacaoBeneficio.Status = (int)Enum.SolicitacaoBeneficio.RazaoStatusAtivo.NaoAprovada;
solicitacaoBeneficio.State = (int)Enum.SolicitacaoBeneficio.State.Ativo;
RepositoryService.SolicitacaoBeneficio.Update(solicitacaoBeneficio);
RepositoryService.SolicitacaoBeneficio.AlterarStatus(solicitacaoBeneficio.ID.Value, solicitacaoBeneficio.State.Value, solicitacaoBeneficio.Status.Value);
return;
case Enum.Tarefa.Resultado.Favoravel:
var solicitacaoBeneficioFavoravel = new SolicitacaoBeneficio(solicitacaoBeneficio.OrganizationName, solicitacaoBeneficio.IsOffline)
{
ID = solicitacaoBeneficio.ID,
StatusSolicitacao = (int)Enum.SolicitacaoBeneficio.StatusSolicitacaoBeneficio.EmAnalise,
Status = (int)Enum.SolicitacaoBeneficio.RazaoStatusAtivo.EmAnalise
};
RepositoryService.SolicitacaoBeneficio.Update(solicitacaoBeneficioFavoravel);
break;
}
CriarTarefasSolicitacaoBeneficio(solicitacaoBeneficio, UsuarioId, Task.Ordem.Value + 1);
}
}
public SolicitacaoBeneficio DefinirPropriedades(Pollux.MSG0155 xml)
{
var crm = new SolicitacaoBeneficio(this.Organizacao, this.IsOffline);
#region Propriedades Crm->Xml
crm.IntegrarNoPlugin = true;
crm.ValorAprovado = xml.ValorAprovado;
if (!string.IsNullOrEmpty(xml.CodigoSolicitacaoBeneficio))
{
if (xml.CodigoSolicitacaoBeneficio.Length == 36)
{
crm.ID = new Guid(xml.CodigoSolicitacaoBeneficio);
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "CodigoSolicitacaoBeneficio fora do padrão (Guid)!";
return(crm);
}
}
string NomeUnidadeNegocio = String.Empty;
if (!string.IsNullOrEmpty(xml.CodigoUnidadeNegocio))
{
UnidadeNegocio unidadeNegocio = new Servicos.UnidadeNegocioService(this.Organizacao, this.IsOffline).BuscaUnidadeNegocioPorChaveIntegracao(xml.CodigoUnidadeNegocio);
if (unidadeNegocio == null)
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "UnidadeNegocio: " + xml.CodigoUnidadeNegocio + " não encontrado no Crm.";
return(crm);
}
else
{
crm.UnidadedeNegocio = new Lookup(unidadeNegocio.ID.Value, "");
NomeUnidadeNegocio = unidadeNegocio.Nome;
}
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "CodigoUnidadeNegocio não enviado!";
return(crm);
}
crm.Nome = xml.NomeSolicitacaoBeneficio;
crm.TipoPriceProtection = xml.TipoPriceProtection;
if (!String.IsNullOrEmpty(xml.DescricaoSituacaoIrregular))
{
crm.SituacaoIrregular = xml.DescricaoSituacaoIrregular;
}
else
{
crm.AddNullProperty("SituacaoIrregular");
}
if (!String.IsNullOrEmpty(xml.CodigoBeneficioCanal) && xml.CodigoBeneficioCanal.Length == 36)
{
BeneficioDoCanal beneficioCanal = new Servicos.BeneficioDoCanalService(this.Organizacao, this.IsOffline).ObterPor(new Guid(xml.CodigoBeneficioCanal));
if (beneficioCanal != null)
{
crm.BeneficioCanal = new Lookup(beneficioCanal.ID.Value, "");
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "CodigoBeneficioCanal : " + xml.CodigoBeneficioCanal + " - não cadastrado no Crm.";
return(crm);
}
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "CodigoBeneficioCanal não Enviado ou fora do padrão(Guid).";
return(crm);
}
crm.ValorSolicitado = xml.ValorSolicitado;
if (!string.IsNullOrEmpty(xml.DescricaoSolicitacao))
{
crm.Descricao = xml.DescricaoSolicitacao;
}
else
{
crm.AddNullProperty("Descricao");
}
if (System.Enum.IsDefined(typeof(Enum.SolicitacaoBeneficio.StatusSolicitacaoBeneficio), xml.SituacaoSolicitacaoBeneficio))
{
crm.StatusSolicitacao = xml.SituacaoSolicitacaoBeneficio;
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "SituacaoSolicitacaoBeneficio não cadastrado no Crm(PickList).";
return(crm);
}
if (xml.Situacao == 0 || xml.Situacao == 1)
{
crm.State = xml.Situacao;
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "Situacao fora do padrão(0 ou 1).";
return(crm);
}
if (crm.State.Value.Equals((int)Enum.SolicitacaoBeneficio.State.Ativo))
{
if (System.Enum.IsDefined(typeof(Enum.SolicitacaoBeneficio.RazaoStatusAtivo), xml.RazaoStatusSolicitacaoBeneficio))
{
crm.Status = xml.RazaoStatusSolicitacaoBeneficio;
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "RazaoStatusSolicitacaoBeneficio não cadastrado para Situação Ativo.";
return(crm);
}
}
else if (crm.State.Value.Equals((int)Enum.SolicitacaoBeneficio.State.Inativo))
{
if (System.Enum.IsDefined(typeof(Enum.SolicitacaoBeneficio.RazaoStatusInativo), xml.RazaoStatusSolicitacaoBeneficio))
{
crm.Status = xml.RazaoStatusSolicitacaoBeneficio;
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "RazaoStatusSolicitacaoBeneficio não cadastrado para Situação Inativo.";
return(crm);
}
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "Situacao fora do padrão.";
return(crm);
}
if (!String.IsNullOrEmpty(xml.CodigoFormaPagamento) && xml.CodigoFormaPagamento.Length == 36)
{
FormaPagamento formaPagamento = new Servicos.FormaPagamentoService(this.Organizacao, this.IsOffline).ObterPorGuid(new Guid(xml.CodigoFormaPagamento));
if (formaPagamento != null)
{
crm.FormaPagamento = new Lookup(formaPagamento.ID.Value, "");
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "CodigoFormaPagamento : " + xml.CodigoFormaPagamento + " - não cadastrado no Crm.";
return(crm);
}
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "CodigoFormaPagamento não Enviado ou fora do padrão(Guid).";
return(crm);
}
if (!String.IsNullOrEmpty(xml.CodigoConta) && xml.CodigoConta.Length == 36)
{
Conta conta = new Servicos.ContaService(this.Organizacao, this.IsOffline).BuscaConta(new Guid(xml.CodigoConta));
if (conta != null)
{
crm.Canal = new Lookup(conta.ID.Value, "");
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "CodigoConta : " + xml.CodigoConta + " - não cadastrado no Crm.";
return(crm);
}
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "CodigoConta não Enviado ou fora do padrão(Guid).";
return(crm);
}
if (!String.IsNullOrEmpty(xml.CodigoBeneficio) && xml.CodigoBeneficio.Length == 36)
{
Beneficio beneficio = new Servicos.BeneficioService(this.Organizacao, this.IsOffline).ObterPor(new Guid(xml.CodigoBeneficio));
if (beneficio != null)
{
crm.BeneficioPrograma = new Lookup(beneficio.ID.Value, "");
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "CodigoBeneficio : " + xml.CodigoBeneficio + " - não cadastrado no Crm.";
return(crm);
}
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "CodigoBeneficio não Enviado ou fora do padrão(Guid).";
return(crm);
}
crm.AlteradaParaStockRotation = xml.AlteradaStockRotation;
crm.SituacaoIrregularidades = xml.SolicitacaoIrregular;
if (!String.IsNullOrEmpty(xml.CodigoTipoSolicitacao) && xml.CodigoTipoSolicitacao.Length == 36)
{
crm.TipoSolicitacao = new Lookup(new Guid(xml.CodigoTipoSolicitacao), "");
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "CodigoTipoSolicitacao não Enviado ou fora do padrão(Guid).";
return(crm);
}
//Novos campos - 1409
crm.AjusteSaldo = xml.SolicitacaoAjuste;
crm.ValorAbater = xml.ValorAbater;
Usuario objAssitente = new Servicos.UsuarioService(this.Organizacao, this.IsOffline).BuscaPorCodigoAssistente(xml.CodigoAssistente.Value);
if (objAssitente != null)
{
crm.Assistente = new Lookup(objAssitente.ID.Value, "");
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "Assistente não cadastrado no Crm.";
return(crm);
}
Usuario supervisorEms = new Servicos.UsuarioService(this.Organizacao, this.IsOffline).BuscaPorCodigoSupervisorEMS(xml.CodigoSupervisorEMS);
if (supervisorEms != null)
{
crm.Supervisor = new Lookup(supervisorEms.ID.Value, "");
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "Supervisor não cadastrado no Crm.";
return(crm);
}
if (!String.IsNullOrEmpty(xml.CodigoFilial))
{
crm.Filial = new Lookup(new Guid(xml.CodigoFilial), "");
}
else
{
crm.AddNullProperty("Filial");
}
if (xml.StatusPagamento.HasValue)
{
crm.StatusPagamento = xml.StatusPagamento;
}
else
{
crm.AddNullProperty("StatusPagamento");
}
if (xml.ValorPago.HasValue)
{
crm.ValorPago = xml.ValorPago.Value;
}
if (xml.ValorCancelado.HasValue)
{
crm.ValorCancelado = xml.ValorCancelado.Value;
}
if (xml.StatusCalculoPriceProtection.HasValue)
{
crm.StatusCalculoPriceProtection = xml.StatusCalculoPriceProtection.Value;
}
if (xml.DataValidade.HasValue)
{
crm.DataValidade = xml.DataValidade.Value;
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "DataValidade não informado favor verificar integração.";
return(crm);
}
if (xml.CodigoCondicaoPagamento.HasValue)
{
CondicaoPagamento condicaoPagamento = new Servicos.CondicaoPagamentoService(this.Organizacao, this.IsOffline).BuscaCondicaoPagamentoPorCodigo(xml.CodigoCondicaoPagamento.Value);
if (condicaoPagamento != null)
{
crm.CondicaoPagamento = new Lookup(condicaoPagamento.ID.Value, "");
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "CodigoCondicaoPagamento informado não registrado no CRM, favor verificar.";
return(crm);
}
}
crm.DescartarVerba = xml.DescartarVerba;
if (!string.IsNullOrEmpty(xml.TrimestreCompetencia))
{
crm.TrimestreCompetencia = xml.TrimestreCompetencia;
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "TrimestreCompetencia não informado favor verificar integração.";
return(crm);
}
crm.FormaCancelamento = xml.FormaCancelamento;
if (xml.CodigoSolicitacaoPrincipal != null)
{
crm.SolicitacaoBeneficioPrincipal = new Lookup(new Guid(xml.CodigoSolicitacaoPrincipal), "");
}
#endregion
crm.IntegradoEm = DateTime.Now;
crm.IntegradoPor = usuarioIntegracao.NomeCompleto;
crm.UsuarioIntegracao = xml.LoginUsuario;
return(crm);
}
private void AtualizaNome(SolicitacaoBeneficioService ServiceSolicitacaoBeneficio, ref SolicitacaoBeneficio solicitacaoBeneficio, ref Entity e)
{
if (!e.Attributes.Contains("itbc_name") || solicitacaoBeneficio.TipoPriceProtection.HasValue)
{
string nome = ServiceSolicitacaoBeneficio.ObterNome(solicitacaoBeneficio);
e.Attributes["itbc_name"] = nome;
solicitacaoBeneficio.Nome = nome;
}
}
private void AtualizaDataValidade(SolicitacaoBeneficioService ServiceSolicitacaoBeneficio, SolicitacaoBeneficio solicitacaoBeneficio, ref Entity e)
{
DateTime dataValidade = ServiceSolicitacaoBeneficio.ObterDataValidadeCriacao(solicitacaoBeneficio);
if (dataValidade != DateTime.MinValue)
{
e.Attributes["itbc_datavalidade"] = dataValidade;
}
}
public void CriarEmail(Lookup referenteA, ParticipantesDoProcesso PartProcesso)
{
Guid fromUserId;
if (!Guid.TryParse(SDKore.Configuration.ConfigurationManager.GetSettingValue("Intelbras.Usuario.EnvioEmail", true), out fromUserId))
{
throw new ApplicationException("O parâmetro 'Intelbras.Usuario.EnvioEmail' não foi possível converte em GUID.");
}
SolicitacaoBeneficio Solicitacao = RepositoryService.SolicitacaoBeneficio.Retrieve(referenteA.Id);
String msg = string.Empty;
var email = new Domain.Model.Email(NomeDaOrganizacao, _isOffline);
email.Assunto = Solicitacao.Canal.Name + " - " + Solicitacao.Nome + " - " + Solicitacao.TipoSolicitacao.Name + " - " + Solicitacao.DataCriacao.Value;
msg = "Canal: " + Solicitacao.Canal.Name;
msg += "</br>Nome da Solicitação: " + Solicitacao.Nome;
msg += "</brTipo da Solicitação: " + Solicitacao.TipoSolicitacao.Name;
msg += "</brValor: " + Solicitacao.ValorSolicitado.Value;
msg += "</brDescrição: " + Solicitacao.Descricao;
msg += "</brStatus da Solicitação : " + Solicitacao.StatusSolicitacao.Value;
email.Mensagem = msg;
email.De = new Lookup[1];
email.De[0] = new Lookup {
Id = fromUserId, Type = SDKore.Crm.Util.Utility.GetEntityName <Domain.Model.Usuario>()
};
email.ReferenteA = new Lookup {
Id = referenteA.Id, Type = referenteA.Type
};
if (PartProcesso.Equipe != null)
{
List <TeamMembership> lstTeam = RepositoryService.TeamMembership.ListarPor(PartProcesso.Equipe.Id);
email.Para = new Lookup[lstTeam.Count()];
int i = 0;
foreach (TeamMembership team in lstTeam)
{
email.Para[i] = new Lookup {
Id = team.Usuario, Type = SDKore.Crm.Util.Utility.GetEntityName <Domain.Model.Usuario>()
};
i++;
}
}
if (PartProcesso.Usuario != null)
{
email.Para = new Lookup[1];
email.Para[0] = new Lookup {
Id = PartProcesso.Usuario.Id, Type = PartProcesso.Usuario.Type
};
}
if (PartProcesso.Contato != null)
{
email.Para = new Lookup[1];
email.Para[0] = new Lookup {
Id = PartProcesso.Contato.Id, Type = PartProcesso.Contato.Type
};
}
email.Direcao = false;
email.ID = RepositoryService.Email.Create(email);
RepositoryService.Email.EnviarEmail(email.ID.Value);
}
