Exemple #1
0
        public Pollux.MSG0287 DefinirPropriedades(ProdutoCondicaoPagamento crm)
        {
            var condPagamento = new Servicos.CondicaoPagamentoService(this.Organizacao, this.IsOffline).BuscaCondicaoPagamento(crm.CondicaoPagamento.Id);

            if (condPagamento == null)
            {
                throw new ArgumentException("(CRM) Condição de Pagamento Não Localizada");
            }

            var produto = new Servicos.ProdutoService(this.Organizacao, this.IsOffline).ObterPor(crm.Produto.Id);

            if (produto == null)
            {
                throw new ArgumentException("(CRM) Produto Não Localizada");
            }

            Pollux.MSG0287 retMsg = new Pollux.MSG0287(Domain.Enum.Sistemas.RetornaSistema(Domain.Enum.Sistemas.Sistema.CRM), condPagamento.Codigo.ToString() + "+" + produto.Codigo.ToString());
            retMsg.CodigoCondicaoPagamento = condPagamento.Codigo;
            retMsg.CodigoProduto           = produto.Codigo;
            retMsg.Situacao = crm.Status;

            return(retMsg);
        }
Exemple #2
0
        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);
        }
Exemple #3
0
        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);
        }
Exemple #4
0
        public Pollux.MSG0183R1 DefinirPropriedades(Conta objModel)
        {
            #region Propriedades Crm->Xml
            Pollux.MSG0183R1 msg0183R1;
            if (objModel.RazaoSocial != null && objModel.RazaoSocial.Length > 0)
            {
                msg0183R1 = new Pollux.MSG0183R1(itb.RetornaSistema(itb.Sistema.CRM), Helper.Truncate(objModel.RazaoSocial, 40));
            }
            else
            {
                msg0183R1 = new Pollux.MSG0183R1(itb.RetornaSistema(itb.Sistema.CRM), Helper.Truncate(objModel.ID.Value.ToString(), 40));
            }

            msg0183R1.CodigoConta = objModel.ID.Value.ToString();

            if (!String.IsNullOrEmpty(objModel.CodigoMatriz))
            {
                msg0183R1.CodigoCliente = Convert.ToInt32(objModel.CodigoMatriz);
            }
            msg0183R1.NomeRazaoSocial = objModel.RazaoSocial;
            msg0183R1.NomeFantasia    = objModel.NomeFantasia;
            msg0183R1.NomeAbreviado   = objModel.NomeAbreviado;
            msg0183R1.DescricaoConta  = objModel.Descricao;
            if (objModel.TipoRelacao.HasValue)
            {
                msg0183R1.TipoRelacao = objModel.TipoRelacao.Value;
            }
            msg0183R1.NumeroBanco = objModel.Banco;

            if (objModel.ContaPrimaria != null)
            {
                msg0183R1.ContaPrimaria = objModel.ContaPrimaria.Id.ToString();
            }
            if (objModel.ContatoPrimario != null)
            {
                msg0183R1.ContatoPrincipal = objModel.ContatoPrimario.Id.ToString();
            }
            if (objModel.Regiao != null)
            {
                msg0183R1.Regiao = objModel.Regiao.Name;
            }

            msg0183R1.NumeroAgencia       = objModel.Agencia;
            msg0183R1.NumeroContaCorrente = objModel.ContaCorrente;
            msg0183R1.EmiteBloqueto       = objModel.EmiteBloqueto;
            msg0183R1.GeraAvisoCredito    = objModel.GeraAvisoCredito;
            msg0183R1.CalculaMulta        = objModel.CalculaMulta;
            msg0183R1.RecebeInformacaoSCI = objModel.RecebeInformacaoSCI;
            msg0183R1.Telefone            = objModel.Telefone;
            msg0183R1.Ramal = objModel.RamalTelefonePrincipal;
            if (objModel.TelefoneAlternativo != null && !String.IsNullOrEmpty(objModel.TelefoneAlternativo))
            {
                msg0183R1.TelefoneAlternativo = objModel.TelefoneAlternativo;
            }
            if (objModel.RamalOutroTelefone != null && !String.IsNullOrEmpty(objModel.RamalOutroTelefone))
            {
                msg0183R1.RamalTelefoneAlternativo = objModel.RamalOutroTelefone;
            }
            msg0183R1.Fax      = objModel.Fax;
            msg0183R1.RamalFax = objModel.RamalFax;
            msg0183R1.Email    = objModel.Email;
            msg0183R1.Site     = objModel.Site;
            if (objModel.Natureza.HasValue)
            {
                msg0183R1.Natureza = objModel.Natureza.Value;
            }

            string cnpjCpfObj = objModel.CpfCnpj.Replace("-", "").Replace(".", "").Replace("/", "").Trim();

            if (objModel.TipoConstituicao.HasValue)
            {
                switch (objModel.TipoConstituicao)
                {
                case (int)Domain.Enum.Conta.TipoConstituicao.Cnpj:
                    msg0183R1.CNPJ = cnpjCpfObj;
                    break;

                case (int)Domain.Enum.Conta.TipoConstituicao.Cpf:
                    msg0183R1.CPF = cnpjCpfObj;
                    break;

                case (int)Domain.Enum.Conta.TipoConstituicao.Estrangeiro:
                    msg0183R1.CodigoEstrangeiro = objModel.CpfCnpj;
                    break;
                }
            }

            if (objModel.InscricaoEstadual != null)
            {
                if (objModel.InscricaoEstadual.Length < 2)
                {
                    msg0183R1.InscricaoEstadual = null;
                }
                else
                {
                    msg0183R1.InscricaoEstadual = objModel.InscricaoEstadual.Replace(".", "").Trim();
                }
            }
            else
            {
                msg0183R1.InscricaoEstadual = null;
            }

            msg0183R1.InscricaoMunicipal = objModel.InscricaoMunicipal;
            msg0183R1.SuspensaoCredito   = objModel.SuspensaoCredito;
            msg0183R1.LimiteCredito      = objModel.LimiteCredito;
            msg0183R1.DataLimiteCredito  = objModel.DataLimiteCredito;
            msg0183R1.SaldoCredito       = objModel.SaldoCredito;
            msg0183R1.ModalidadeCobranca = objModel.Modalidade;
            msg0183R1.ContribuinteICMS   = objModel.ContribuinteICMS;
            msg0183R1.CodigoSUFRAMA      = objModel.CodigoSuframa;
            msg0183R1.InscricaoSubstituicaoTributaria = objModel.SubstituicaoTributaria;
            msg0183R1.OptanteSuspensaoIPI             = objModel.OptanteSuspensaoIPI;
            msg0183R1.AgenteRetencao             = objModel.AgenteRetencao;
            msg0183R1.PisCofinsUnidade           = objModel.PISCOFINSPorUnidade;
            msg0183R1.RecebeNotaFiscalEletronica = objModel.RecebeNFE;
            msg0183R1.FormaTributacao            = objModel.FormaTributacao;
            msg0183R1.ObservacaoPedido           = objModel.ObservacoesPedido;
            msg0183R1.TipoEmbalagem   = objModel.TipoEmbalagem;
            msg0183R1.CodigoIncoterm  = objModel.Incoterm;
            msg0183R1.LocalEmbarque   = objModel.LocalEmbarque;
            msg0183R1.ViaEmbarque     = objModel.EmbarqueVia;
            msg0183R1.DataImplantacao = objModel.DataImplantacao;
            if (!String.IsNullOrEmpty(objModel.DocIdentidade))
            {
                msg0183R1.RG = objModel.DocIdentidade;
            }
            if (!String.IsNullOrEmpty(objModel.EmissorIdentidade))
            {
                msg0183R1.OrgaoExpeditor = objModel.EmissorIdentidade;
            }
            msg0183R1.DataVencimentoConcessao       = objModel.DataVenctoConcessao;
            msg0183R1.DescontoAssistenciaTecnica    = objModel.DescontoCAT;
            msg0183R1.CoberturaGeografica           = objModel.CoberturaGeografica;
            msg0183R1.DataConstituicao              = objModel.DataConstituicao;
            msg0183R1.DistribuicaoUnicaFonteReceita = objModel.DistribuicaoFonteReceita;
            msg0183R1.QualificadoTreinamento        = objModel.EspacoFisicoQualificado;
            if (objModel.Exclusividade.HasValue)
            {
                msg0183R1.Exclusividade = objModel.Exclusividade.Value;
            }
            msg0183R1.Historico                      = objModel.Historico;
            msg0183R1.IntencaoApoio                  = objModel.IntencaoApoio;
            msg0183R1.MetodoComercializacao          = objModel.MetodoComercializacaoProduto;
            msg0183R1.ModeloOperacao                 = objModel.ModeloOperacaoFiliais;
            msg0183R1.NumeroFuncionarios             = objModel.NumeroFuncionarios;
            msg0183R1.NumeroColaboradoresAreaTecnica = objModel.NumeroColaboradores;
            msg0183R1.NumeroRevendasAtivas           = objModel.NumeroRevendasAtivas;
            msg0183R1.NumeroRevendasInativas         = objModel.NumeroRevendasInativas;
            msg0183R1.NumeroTecnicosSuporte          = objModel.NumeroTecnicosSuporte;
            msg0183R1.NumeroVendedores               = objModel.NumeroVendedores;
            msg0183R1.OutraFonteReceita              = objModel.OutraFonteReceita;
            if (objModel.ParticipantePrograma.HasValue)
            {
                msg0183R1.ParticipaProgramaCanais = objModel.ParticipantePrograma.Value;
            }

            #region Asistencia Tecnica
            if (objModel.AssistenciaTecnica.HasValue)
            {
                msg0183R1.AssistenciaTecnica = objModel.AssistenciaTecnica.Value;
            }

            if (objModel.PossuiEstruturaCompleta.HasValue)
            {
                msg0183R1.PossuiEstruturaCompleta = objModel.PossuiEstruturaCompleta;
            }

            if (objModel.PerfilAssistenciaTecnica.HasValue)
            {
                msg0183R1.PerfilAssistenciaTecnica = objModel.PerfilAssistenciaTecnica;
            }

            if (objModel.TabelaPrecoAstec.HasValue)
            {
                msg0183R1.TabelaPrecoAssistenciaTecnica = objModel.TabelaPrecoAstec;
            }

            if (objModel.NomeAbreviadoMatrizEconomica != null)
            {
                msg0183R1.NomeAbreviadoMatrizEconomica = objModel.NomeAbreviadoMatrizEconomica;
            }
            #endregion

            msg0183R1.PerfilRevendasDistribuidor = objModel.PerfilRevendaDistribuidor;
            msg0183R1.PossuiEstruturaCompleta    = objModel.PossuiEstruturaCompleta;
            msg0183R1.PossuiFiliais     = objModel.PossuiFiliais;
            msg0183R1.QuantidadeFiliais = objModel.QuantasFiliais;
            if (objModel.PrazoMedioCompras.HasValue)
            {
                msg0183R1.PrazoMedioCompra = (decimal)objModel.PrazoMedioCompras.Value;
            }
            if (objModel.PrazoMedioVendas.HasValue)
            {
                msg0183R1.PrazoMedioVenda = (decimal)objModel.PrazoMedioVendas.Value;
            }
            if (objModel.Setor.HasValue)
            {
                msg0183R1.Setor = objModel.Setor;
            }
            msg0183R1.ValorMedioCompra     = objModel.ValorMedioComprasMensais;
            msg0183R1.ValorMedioVenda      = objModel.ValorMedioVendasMensais;
            msg0183R1.VendeAtacadista      = objModel.VendasParaAtacadistaVarejista;
            msg0183R1.ObservacaoNotaFiscal = objModel.ObservacoesNF;
            msg0183R1.EstruturaPropriedade = objModel.Propriedade;
            msg0183R1.ReceitaAnual         = objModel.ReceitaAnual;

            if (objModel.Status.HasValue)
            {
                msg0183R1.Situacao = objModel.Status.Value;
            }

            if (objModel.Classificacao != null)
            {
                msg0183R1.Classificacao = objModel.Classificacao.Id.ToString();
            }

            if (objModel.Subclassificacao == null)
            {
                throw new ArgumentException("campo Subclassificação obrigatório");
            }

            msg0183R1.SubClassificacao = objModel.Subclassificacao.Id.ToString();

            msg0183R1.CodigoCRM4 = objModel.GUIDCRM40;

            if (objModel.Portador != null)
            {
                Domain.Model.Portador portador = new Intelbras.CRM2013.Domain.Servicos.PortadorService(this.Organizacao, this.IsOffline)
                                                 .BuscaPorCodigo(objModel.Portador.Id);

                if (portador == null || !portador.CodigoPortador.HasValue)
                {
                    throw new ArgumentException("(CRM) Portador não localizado. (ID: " + objModel.Portador.Id + ")");
                }

                msg0183R1.Portador = portador.CodigoPortador;
            }

            if (objModel.NivelPosVendas == null)
            {
                throw new ArgumentException("Campo nivel pós venda obrigatório");
            }

            msg0183R1.NivelPosVenda = objModel.NivelPosVendas.Id.ToString();

            if (objModel.ClientePotencialOriginador != null)
            {
                msg0183R1.ClientePotencialOriginador = objModel.ClientePotencialOriginador.Id.ToString();
            }
            if (objModel.CondicaoPagamento != null)
            {
                CondicaoPagamento codPagto = new Servicos.CondicaoPagamentoService(this.Organizacao, this.IsOffline).BuscaCondicaoPagamento(objModel.CondicaoPagamento.Id);
                if (codPagto != null && codPagto.Codigo.HasValue)
                {
                    msg0183R1.CondicaoPagamento = codPagto.Codigo;
                }
            }

            Domain.Model.Usuario proprietario = new Domain.Servicos.UsuarioService(this.Organizacao, this.IsOffline).BuscarProprietario("account", "accountid", objModel.ID.Value);
            if (proprietario != null)
            {
                msg0183R1.Proprietario     = proprietario.Id.ToString();
                msg0183R1.TipoProprietario = "systemuser";
            }

            if (objModel.Transportadora != null)
            {
                Transportadora transp = new Servicos.TransportadoraService(this.Organizacao, this.IsOffline).ObterPor(objModel.Transportadora.Id);
                if (transp != null && transp.Codigo.HasValue)
                {
                    msg0183R1.Transportadora = transp.Codigo.Value;
                }
            }
            if (objModel.TransportadoraRedespacho != null)
            {
                Transportadora transpRed = new Servicos.TransportadoraService(this.Organizacao, this.IsOffline).ObterPor(objModel.TransportadoraRedespacho.Id);
                if (transpRed != null && transpRed.Codigo.HasValue)
                {
                    msg0183R1.TransportadoraRedespacho = transpRed.Codigo.Value;
                }
            }

            if (objModel.TipoConta.HasValue)
            {
                msg0183R1.TipoConta = objModel.TipoConta.Value;
            }
            msg0183R1.ApuracaoBeneficio = objModel.ApuracaoBeneficiosCompromissos;

            if (objModel.DataAdesao.HasValue)
            {
                msg0183R1.DataAdesao = objModel.DataAdesao.Value.ToLocalTime();
            }


            if (objModel.DiasAtraso.HasValue)
            {
                msg0183R1.NumeroDiasAtraso = (int)objModel.DiasAtraso;
            }

            if (objModel.ReceitaPadrao != null)
            {
                ReceitaPadrao receitaPadrao = new Servicos.ReceitaPadraoService(this.Organizacao, this.IsOffline).BuscaPorCodigo(objModel.ReceitaPadrao.Id);
                if (receitaPadrao != null)
                {
                    msg0183R1.ReceitaPadrao = receitaPadrao.CodReceitaPadrao;
                }
            }
            if (objModel.Portador != null)
            {
                Portador mPortador = new Servicos.PortadorService(this.Organizacao, this.IsOffline).BuscaPorCodigo(objModel.Portador.Id);
                if (mPortador != null)
                {
                    msg0183R1.Portador = mPortador.CodigoPortador;
                }
            }

            msg0183R1.SistemaGestao                 = objModel.SoftwareNegocios;
            msg0183R1.DataImplantacao               = objModel.DataImplantacao;
            msg0183R1.DataUltimoSellOut             = objModel.DataUltimoSelloutRevenda;
            msg0183R1.EscolheuDistrForaSellOut      = objModel.EscolheuDistribuidorSemSellout;
            msg0183R1.AdesaoPciRealizadaPor         = objModel.AdesaoAoPCIRealizadaPor;
            msg0183R1.ParticipaProgramaCanaisMotivo = objModel.MotivoParticipantePrograma;
            msg0183R1.FiguraNoSite           = objModel.FiguraNoSite;
            msg0183R1.CNAE                   = objModel.CNAE;
            msg0183R1.RamoAtividadeEconomica = objModel.RamoAtividadeEconomica;

            if (objModel.CnaeId != null)
            {
                msg0183R1.CodigoRamoAtividadeEconomica = objModel.CnaeId.Id.ToString();
            }
            if (objModel.ListaPreco != null)
            {
                msg0183R1.ListaPreco = objModel.ListaPreco.Name;
            }
            if (objModel.TipoConstituicao.HasValue)
            {
                msg0183R1.TipoConstituicao = objModel.TipoConstituicao.Value;
            }

            //Atualizacao Konviva
            if (objModel.TipoConstituicao.HasValue && objModel.TipoConstituicao.Value == (int)Domain.Enum.Conta.TipoConstituicao.Estrangeiro)
            {
                msg0183R1.CodigoEstrangeiro = objModel.CpfCnpj;
            }

            if (objModel.OrigemConta.HasValue)
            {
                msg0183R1.OrigemConta = objModel.OrigemConta;
            }

            if (!String.IsNullOrEmpty(objModel.NumeroPassaporte))
            {
                msg0183R1.NumeroPassaporte = objModel.NumeroPassaporte;
            }

            if (objModel.StatusIntegracaoSefaz.HasValue)
            {
                msg0183R1.StatusIntegracaoSefaz = objModel.StatusIntegracaoSefaz;
            }

            if (objModel.DataHoraIntegracaoSefaz.HasValue)
            {
                msg0183R1.DataHoraIntegracaoSefaz = objModel.DataHoraIntegracaoSefaz;
            }

            if (!String.IsNullOrEmpty(objModel.RegimeApuracao))
            {
                msg0183R1.RegimeApuracao = objModel.RegimeApuracao;
            }

            if (objModel.DataBaixaContribuinte.HasValue)
            {
                msg0183R1.DataBaixaContribuinte = objModel.DataBaixaContribuinte;
            }

            #region Segmentos do Canal
            msg0183R1.SegmentosCanal = new List <Message.Helper.Entities.Segmento>();

            List <Segmento> lstSegmentos = new RepositoryService(this.Organizacao, this.IsOffline).Segmento.ListarPorContaSegmento((Guid)objModel.ID.Value);

            if (lstSegmentos.Count > 0)
            {
                foreach (Segmento segmentoItem in lstSegmentos)
                {
                    Message.Helper.Entities.Segmento segmento = new Message.Helper.Entities.Segmento();

                    segmento.CodigoSegmento = segmentoItem.CodigoSegmento;
                    segmento.NomeSegmento   = segmentoItem.Nome;

                    UnidadeNegocio unidadeNegocio = new UnidadeNegocioService(this.Organizacao, this.IsOffline).BuscaUnidadeNegocio(segmentoItem.UnidadeNegocios.Id);
                    if (unidadeNegocio != null)
                    {
                        segmento.CodigoUnidadeNegocio = unidadeNegocio.ChaveIntegracao;
                    }

                    msg0183R1.SegmentosCanal.Add(segmento);
                }
            }
            #endregion

            #region Endereço
            //Bloco Endereço

            //Principal
            Pollux.Entities.Endereco endPrincipal = new Pollux.Entities.Endereco();
            endPrincipal.Bairro = objModel.Endereco1Bairro;
            endPrincipal.Numero = objModel.Endereco1Numero;
            if (!String.IsNullOrEmpty(objModel.Endereco1CEP))
            {
                endPrincipal.CEP = objModel.Endereco1CEP.Replace("-", "").PadLeft(8, '0');
            }
            ;
            if (objModel.Endereco1Municipioid != null)
            {
                Municipio municipio = new Servicos.MunicipioServices(this.Organizacao, this.IsOffline).ObterPor(objModel.Endereco1Municipioid.Id);
                endPrincipal.Cidade     = municipio.ChaveIntegracao;
                endPrincipal.NomeCidade = municipio.Nome;
            }
            endPrincipal.Complemento = objModel.Endereco1Complemento;
            if (objModel.Endereco1Estadoid != null)
            {
                Estado estado = new Servicos.EstadoServices(this.Organizacao, this.IsOffline).BuscaEstadoPorId(objModel.Endereco1Estadoid.Id);
                if (estado != null)
                {
                    endPrincipal.Estado = estado.ChaveIntegracao;
                    endPrincipal.UF     = estado.SiglaUF;
                }
            }
            endPrincipal.Logradouro   = objModel.Endereco1Rua;
            endPrincipal.NomeEndereco = objModel.Endereco1Nome;
            if (objModel.Endereco1Pais != null)
            {
                Pais pais = new Servicos.PaisServices(this.Organizacao, this.IsOffline).BuscaPais(objModel.Endereco1Pais.Id);
                if (pais != null)
                {
                    endPrincipal.NomePais = pais.Nome;
                    endPrincipal.Pais     = pais.Nome;
                }
            }
            endPrincipal.TipoEndereco = objModel.TipoEndereco;
            if (!String.IsNullOrEmpty(objModel.Endereco1CaixaPostal))
            {
                endPrincipal.CaixaPostal = objModel.Endereco1CaixaPostal;
            }
            msg0183R1.EnderecoPrincipal = endPrincipal;

            msg0183R1.Resultado.Sucesso  = true;
            msg0183R1.Resultado.Mensagem = "Integração ocorrida com sucesso.";

            return(msg0183R1);


            #endregion

            #endregion
        }
Exemple #5
0
        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);
        }
Exemple #6
0
        public Pollux.Entities.SolicitacaoBeneficioR1 DefinirRetorno(Model.SolicitacaoBeneficio itemCrm)
        {
            Pollux.Entities.SolicitacaoBeneficioR1 solBeneficioPollux = new Pollux.Entities.SolicitacaoBeneficioR1();

            #region Propriedades Crm->Xml

            if (!string.IsNullOrEmpty(itemCrm.Nome))
            {
                solBeneficioPollux.NomeSolicitacaoBeneficio = itemCrm.Nome;
            }
            else
            {
                solBeneficioPollux.NomeSolicitacaoBeneficio = "N/A";
            }

            if (itemCrm.UnidadedeNegocio != null)
            {
                UnidadeNegocio unidadeNeg = new UnidadeNegocioService(Organizacao, IsOffline).BuscaUnidadeNegocio(itemCrm.UnidadedeNegocio.Id);

                if (unidadeNeg != null)
                {
                    if (!String.IsNullOrEmpty(unidadeNeg.ChaveIntegracao))
                    {
                        solBeneficioPollux.CodigoUnidadeNegocio = unidadeNeg.ChaveIntegracao;
                    }
                    else
                    {
                        solBeneficioPollux.CodigoUnidadeNegocio = "N/A";
                    }
                    if (!String.IsNullOrEmpty(unidadeNeg.Nome))
                    {
                        solBeneficioPollux.NomeUnidadeNegocio = unidadeNeg.Nome;
                    }
                    else
                    {
                        solBeneficioPollux.NomeUnidadeNegocio = "N/A";
                    }
                }
                else
                {
                    solBeneficioPollux.CodigoUnidadeNegocio = "N/A";
                    solBeneficioPollux.NomeUnidadeNegocio   = "N/A";
                }
            }
            else
            {
                solBeneficioPollux.CodigoUnidadeNegocio = "N/A";
                solBeneficioPollux.NomeUnidadeNegocio   = "N/A";
            }
            if (itemCrm.ValorAcao.HasValue)
            {
                solBeneficioPollux.ValorAcao = itemCrm.ValorAcao.Value;
            }
            else
            {
                solBeneficioPollux.ValorAcao = 0;
            }

            if (!string.IsNullOrEmpty(itemCrm.SituacaoIrregular))
            {
                solBeneficioPollux.DescricaoSituacaoIrregular = itemCrm.SituacaoIrregular;
            }
            if (itemCrm.AcaoSubsidiadaVmc != null)
            {
                solBeneficioPollux.CodigoAcaoSubsidiadaVMC = itemCrm.AcaoSubsidiadaVmc.Id.ToString();
                solBeneficioPollux.NomeAcaoSubsidiadaVMC   = itemCrm.AcaoSubsidiadaVmc.Name;
            }

            if (itemCrm.ValorSolicitado.HasValue)
            {
                solBeneficioPollux.ValorSolicitado = itemCrm.ValorSolicitado.Value;
            }
            else
            {
                solBeneficioPollux.ValorSolicitado = 0;
            }

            if (itemCrm.StatusSolicitacao.HasValue)
            {
                solBeneficioPollux.SituacaoSolicitacaoBeneficio = itemCrm.StatusSolicitacao.Value;
                solBeneficioPollux.NomeSituacaoSolicitacao      = Helper.GetDescription(((Domain.Enum.SolicitacaoBeneficio.StatusSolicitacaoBeneficio)itemCrm.StatusSolicitacao));
            }
            else
            {
                solBeneficioPollux.SituacaoSolicitacaoBeneficio = 0;
                solBeneficioPollux.NomeSituacaoSolicitacao      = "N/A";
            }
            if (itemCrm.FormaPagamento != null)
            {
                solBeneficioPollux.CodigoFormaPagamento = itemCrm.FormaPagamento.Id.ToString();
                solBeneficioPollux.NomeFormaPagamento   = itemCrm.FormaPagamento.Name;
            }
            else
            {
                solBeneficioPollux.CodigoFormaPagamento = Guid.Empty.ToString();
                solBeneficioPollux.NomeFormaPagamento   = "N/A";
            }

            if (itemCrm.ValorAprovado.HasValue)
            {
                solBeneficioPollux.ValorAprovado = itemCrm.ValorAprovado.Value;
            }

            if (itemCrm.DataIniAcao.HasValue)
            {
                solBeneficioPollux.DataInicioAcao = itemCrm.DataIniAcao.Value;
            }

            if (itemCrm.DataFimAcao.HasValue)
            {
                solBeneficioPollux.DataPrevistaRetornoAcao = itemCrm.DataFimAcao.Value;
            }

            if (itemCrm.ValorPago.HasValue)
            {
                solBeneficioPollux.ValorPago = itemCrm.ValorPago.Value;
            }

            if (itemCrm.BeneficioCanal != null)
            {
                BeneficioDoCanal benefCanal = new Servicos.BeneficioDoCanalService(this.Organizacao, this.IsOffline).ObterPor(itemCrm.BeneficioCanal.Id);
                if (benefCanal != null)
                {
                    solBeneficioPollux.CodigoBeneficioCanal = benefCanal.ID.Value.ToString();
                    solBeneficioPollux.NomeBeneficioCanal   = benefCanal.Nome;

                    if (benefCanal.StatusBeneficio != null)
                    {
                        solBeneficioPollux.CodigoStatusBeneficio = benefCanal.StatusBeneficio.Id.ToString();
                        solBeneficioPollux.NomeStatusBeneficio   = benefCanal.StatusBeneficio.Name;
                    }
                    else
                    {
                        solBeneficioPollux.CodigoStatusBeneficio = Guid.Empty.ToString();
                        solBeneficioPollux.NomeStatusBeneficio   = "N/A";
                    }
                }
                else
                {
                    solBeneficioPollux.CodigoBeneficioCanal  = Guid.Empty.ToString();
                    solBeneficioPollux.NomeBeneficioCanal    = "N/A";
                    solBeneficioPollux.CodigoStatusBeneficio = Guid.Empty.ToString();
                    solBeneficioPollux.NomeStatusBeneficio   = "N/A";
                }
            }
            else
            {
                solBeneficioPollux.CodigoBeneficioCanal  = Guid.Empty.ToString();
                solBeneficioPollux.NomeBeneficioCanal    = "N/A";
                solBeneficioPollux.CodigoStatusBeneficio = Guid.Empty.ToString();
                solBeneficioPollux.NomeStatusBeneficio   = "N/A";
            }


            if (itemCrm.BeneficioPrograma != null)
            {
                Beneficio beneficio = new Servicos.BeneficioService(this.Organizacao, this.IsOffline).ObterPor(itemCrm.BeneficioPrograma.Id);
                if (beneficio != null)
                {
                    solBeneficioPollux.CodigoBeneficio = beneficio.ID.Value.ToString();
                    solBeneficioPollux.NomeBeneficio   = beneficio.Nome;

                    if (beneficio.Codigo.HasValue)
                    {
                        solBeneficioPollux.BeneficioCodigo = beneficio.Codigo.Value;
                    }
                    else
                    {
                        solBeneficioPollux.BeneficioCodigo = (int)this.PreencherAtributoVazio("int");
                    }
                }
                else
                {
                    solBeneficioPollux.CodigoBeneficio = Guid.Empty.ToString();
                    solBeneficioPollux.NomeBeneficio   = "N/A";
                    solBeneficioPollux.BeneficioCodigo = (int)this.PreencherAtributoVazio("int");
                }
            }
            else
            {
                solBeneficioPollux.CodigoBeneficioCanal = Guid.Empty.ToString();
                solBeneficioPollux.NomeBeneficioCanal   = "N/A";
            }
            if (itemCrm.AlteradaParaStockRotation.HasValue)
            {
                solBeneficioPollux.AlteradaStockRotation = itemCrm.AlteradaParaStockRotation.Value;
            }
            else
            {
                solBeneficioPollux.AlteradaStockRotation = false;
            }
            if (itemCrm.SituacaoIrregularidades.HasValue)
            {
                solBeneficioPollux.SolicitacaoIrregular = itemCrm.SituacaoIrregularidades.Value;
            }
            else
            {
                solBeneficioPollux.SolicitacaoIrregular = false;
            }
            if (itemCrm.Canal != null)
            {
                solBeneficioPollux.CodigoConta = itemCrm.Canal.Id.ToString();
                solBeneficioPollux.NomeConta   = itemCrm.Canal.Name;
            }
            else
            {
                solBeneficioPollux.CodigoConta = Guid.Empty.ToString();
                solBeneficioPollux.NomeConta   = "N/A";
            }

            if (itemCrm.AjusteSaldo.HasValue)
            {
                solBeneficioPollux.SolicitacaoAjuste = itemCrm.AjusteSaldo.Value;
            }

            if (itemCrm.StatusCalculoPriceProtection.HasValue)
            {
                solBeneficioPollux.StatusCalculoPriceProtection = itemCrm.StatusCalculoPriceProtection.Value;
            }

            if (itemCrm.ResultadoPrevisto.HasValue)
            {
                solBeneficioPollux.ResultadoPrevisto = itemCrm.ResultadoPrevisto.Value;
            }

            if (itemCrm.ResultadoAlcancado.HasValue)
            {
                solBeneficioPollux.ResultadoAlcancado = itemCrm.ResultadoAlcancado.Value;
            }

            if (itemCrm.ValorAbater.HasValue)
            {
                solBeneficioPollux.ValorAbater = itemCrm.ValorAbater.Value;
            }
            else
            {
                solBeneficioPollux.ValorAbater = 0;
            }

            solBeneficioPollux.CodigoSolicitacaoBeneficio = itemCrm.ID.ToString();

            if (itemCrm.TipoSolicitacao != null)
            {
                solBeneficioPollux.CodigoTipoSolicitacao = itemCrm.TipoSolicitacao.Id.ToString();
                solBeneficioPollux.NomeTipoSolicitacao   = itemCrm.TipoSolicitacao.Name;
            }
            else
            {
                solBeneficioPollux.CodigoTipoSolicitacao = Guid.Empty.ToString();
                solBeneficioPollux.NomeTipoSolicitacao   = "N/A";
            }

            if (itemCrm.TipoPriceProtection.HasValue)
            {
                solBeneficioPollux.TipoPriceProtection = itemCrm.TipoPriceProtection;
                if (itemCrm.TipoSolicitacao != null)
                {
                    solBeneficioPollux.NomeTipoPriceProtection = itemCrm.TipoSolicitacao.Name;
                }
            }


            if (!String.IsNullOrEmpty(itemCrm.Descricao))
            {
                solBeneficioPollux.DescricaoSolicitacao = itemCrm.Descricao;
            }

            solBeneficioPollux.Situacao     = itemCrm.State.Value;
            solBeneficioPollux.NomeSituacao = Helper.GetDescription((Domain.Enum.SolicitacaoBeneficio.State)(itemCrm.State.Value));
            solBeneficioPollux.RazaoStatusSolicitacaoBeneficio = itemCrm.Status.Value;
            if (itemCrm.State.Value == (int)(Domain.Enum.SolicitacaoBeneficio.State.Ativo))
            {
                solBeneficioPollux.NomeRazaoStatusSolicitacao = Helper.GetDescription((Domain.Enum.SolicitacaoBeneficio.RazaoStatusAtivo)(itemCrm.Status.Value));
            }
            else
            {
                solBeneficioPollux.NomeRazaoStatusSolicitacao = Helper.GetDescription((Domain.Enum.SolicitacaoBeneficio.RazaoStatusInativo)(itemCrm.Status.Value));
            }

            solBeneficioPollux.DataCriacaoSolicitacao = itemCrm.DataCriacao.Value;
            solBeneficioPollux.Proprietario           = usuarioIntegracao.ID.Value.ToString();
            solBeneficioPollux.NomeProprietario       = usuarioIntegracao.Nome;
            solBeneficioPollux.TipoProprietario       = "systemuser";


            if (itemCrm.Assistente != null)
            {
                Usuario assistente = new Servicos.UsuarioService(this.Organizacao, this.IsOffline).ObterPor(itemCrm.Assistente.Id);
                if (assistente != null && assistente.CodigoAssistenteComercial.HasValue)
                {
                    solBeneficioPollux.CodigoAssistente = assistente.CodigoAssistenteComercial.Value;
                    solBeneficioPollux.NomeAssistente   = assistente.Nome;
                }
                else
                {
                    solBeneficioPollux.CodigoAssistente = 0;
                    solBeneficioPollux.NomeAssistente   = "N/A";
                }
            }
            else
            {
                solBeneficioPollux.CodigoAssistente = 0;
                solBeneficioPollux.NomeAssistente   = "N/A";
            }


            if (itemCrm.Supervisor != null)
            {
                Usuario supervisor = new Servicos.UsuarioService(this.Organizacao, this.IsOffline).ObterPor(itemCrm.Supervisor.Id);
                if (supervisor != null && !String.IsNullOrEmpty(supervisor.CodigoSupervisorEMS))
                {
                    solBeneficioPollux.CodigoSupervisorEMS = supervisor.CodigoSupervisorEMS;
                    solBeneficioPollux.NomeSupervisor      = supervisor.Nome;
                }
                else
                {
                    solBeneficioPollux.CodigoSupervisorEMS = "N/A";
                    solBeneficioPollux.NomeSupervisor      = "N/A";
                }
            }
            else
            {
                solBeneficioPollux.CodigoSupervisorEMS = "N/A";;
                solBeneficioPollux.NomeSupervisor      = "N/A";
            }

            if (itemCrm.Filial != null)
            {
                solBeneficioPollux.CodigoFilial = itemCrm.Filial.Id.ToString();
                solBeneficioPollux.NomeFilial   = itemCrm.Filial.Name;
            }

            if (itemCrm.StatusPagamento.HasValue)
            {
                solBeneficioPollux.StatusPagamento     = itemCrm.StatusPagamento;
                solBeneficioPollux.NomeStatusPagamento = Helper.GetDescription((Domain.Enum.SolicitacaoBeneficio.StatusPagamento)(itemCrm.StatusPagamento.Value));
            }

            if (itemCrm.SolicitacaoBeneficioPrincipal != null)
            {
                solBeneficioPollux.CodigoSolicitacaoPrincipal = itemCrm.SolicitacaoBeneficioPrincipal.Id.ToString();
                solBeneficioPollux.NomeSolicitacaoPrincipal   = itemCrm.SolicitacaoBeneficioPrincipal.Name;
            }

            if (itemCrm.ValorCancelado.HasValue)
            {
                solBeneficioPollux.ValorCancelado = itemCrm.ValorCancelado.Value;
            }

            if (itemCrm.DataValidade.HasValue)
            {
                solBeneficioPollux.DataValidade = itemCrm.DataValidade.Value;
            }
            else
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "DataValidade obrigatória, favor verificar registro no CRM.";
                return(solBeneficioPollux);
            }

            if (itemCrm.CondicaoPagamento != null)
            {
                CondicaoPagamento condicaoPagamento = new Servicos.CondicaoPagamentoService(this.Organizacao, this.IsOffline).BuscaCondicaoPagamento(itemCrm.CondicaoPagamento.Id);

                if (condicaoPagamento.Codigo.HasValue)
                {
                    solBeneficioPollux.CodigoCondicaoPagamento = condicaoPagamento.Codigo.Value;
                }

                if (!string.IsNullOrEmpty(condicaoPagamento.Nome))
                {
                    solBeneficioPollux.NomeCondicaoPagamento = condicaoPagamento.Nome;
                }
            }

            if (itemCrm.DescartarVerba.HasValue)
            {
                solBeneficioPollux.DescartarVerba = itemCrm.DescartarVerba.Value;
            }

            if (!string.IsNullOrEmpty(itemCrm.TrimestreCompetencia))
            {
                solBeneficioPollux.TrimestreCompetencia = itemCrm.TrimestreCompetencia;
            }
            else
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "TrimestreCompetencia obrigatório, favor verificar registro no CRM.";
                return(solBeneficioPollux);
            }

            if (itemCrm.FormaCancelamento.HasValue)
            {
                solBeneficioPollux.FormaCancelamento = itemCrm.FormaCancelamento.Value;
            }

            solBeneficioPollux.ObterSolicitacaoItens = this.RetornaSolicitacaoItens(itemCrm);


            //Busca as unidades de negócio relacionadas ao Benefício do canal
            List <SolicitacaoXUnidades> lstUnidadesBenef = new Servicos.SolicitacaoXUnidadesService(this.Organizacao, this.IsOffline).ListarPor(itemCrm.ID.Value);
            solBeneficioPollux.UnidadesRelacionadas = this.ConverteLista(lstUnidadesBenef);


            #endregion

            return(solBeneficioPollux);
        }