Example #1
0
        public Denuncia DefinirPropriedades(Intelbras.Message.Helper.MSG0107 xml)
        {
            var crm = new Denuncia(this.Organizacao, this.IsOffline);

            #region Propriedades Crm->Xml


            if (!String.IsNullOrEmpty(xml.CodigoDenuncia))
            {
                if (xml.CodigoDenuncia.Length == 36)
                    crm.ID = new Guid(xml.CodigoDenuncia);
                else
                {
                    resultadoPersistencia.Sucesso = false;
                    resultadoPersistencia.Mensagem = "CodigoDenuncia enviado está fora do padrão(Guid).";
                    return crm;
                }
            }
            if (!String.IsNullOrEmpty(xml.Descricao))
                crm.Descricao = xml.Descricao;
            else
            {
                resultadoPersistencia.Sucesso = false;
                resultadoPersistencia.Mensagem = "Descrição não enviada.";
                return crm;
            }

            if (!String.IsNullOrEmpty(xml.CodigoTipoDenuncia) && xml.CodigoTipoDenuncia.Length == 36)
            {
                TipoDeDenuncia tipoDenuncia = new Servicos.DenunciaService(this.Organizacao, this.IsOffline).ObterTipoDenuncia(new Guid(xml.CodigoTipoDenuncia));
                if (tipoDenuncia != null)
                {
                    crm.Nome = "Denúncia de : " + tipoDenuncia.Nome;
                    crm.TipoDenuncia = new Lookup(tipoDenuncia.ID.Value, "");
                }
                else
                {
                    resultadoPersistencia.Sucesso = false;
                    resultadoPersistencia.Mensagem = "Tipo de Denuncia não cadastrado no Crm.";
                    return crm;
                }

            }
            else
            {
                resultadoPersistencia.Sucesso = false;
                resultadoPersistencia.Mensagem = "CodigoTipoDenuncia fora do padrão(Guid) ou não enviado.";
                return crm;
            }
            if (!String.IsNullOrEmpty(xml.Justificativa))
            {
                crm.Justificativa = xml.Justificativa;
            }
            else
            {
                resultadoPersistencia.Sucesso = false;
                resultadoPersistencia.Mensagem = "Justificativa não enviada.";
                return crm;
            }

            if (!String.IsNullOrEmpty(xml.CodigoCanalDenunciado) && xml.CodigoCanalDenunciado.Length == 36)
            {
                crm.Denunciado = new Lookup(new Guid(xml.CodigoCanalDenunciado), "");
            }
            else
            {
                resultadoPersistencia.Sucesso = false;
                resultadoPersistencia.Mensagem = "Codigo Canal Denunciado não enviado ou fora do padrão(Guid).";
                return crm;
            }
            //Status 
            if (xml.Situacao == 1 || xml.Situacao == 0)
                crm.Status = xml.Situacao;
            else
            {
                resultadoPersistencia.Sucesso = false;
                resultadoPersistencia.Mensagem = "Status não encontrado!";
                return crm;
            }

            if (System.Enum.IsDefined(typeof(Intelbras.CRM2013.Domain.Enum.Denuncia.StatusDenuncia), xml.SituacaoDenuncia))
                crm.RazaoStatus = xml.SituacaoDenuncia;
            else
            {
                resultadoPersistencia.Sucesso = false;
                resultadoPersistencia.Mensagem = "SituacaoDenuncia não encontrada!";
                return crm;
            }
            if (System.Enum.IsDefined(typeof(Intelbras.CRM2013.Domain.Enum.Denuncia.TipoDenunciante), xml.TipoDenunciante))
                crm.TipoDenunciante = xml.TipoDenunciante;
            else
            {
                resultadoPersistencia.Sucesso = false;
                resultadoPersistencia.Mensagem = "SituacaoDenuncia não encontrada!";
                return crm;
            }

            if (xml.CodigoRepresentante.HasValue)
            {

                Contato contato = new Contato(this.Organizacao, this.IsOffline);
                contato = new Intelbras.CRM2013.Domain.Servicos.ContatoService(this.Organizacao, this.IsOffline).BuscaContatoPorCodigoRepresentante(xml.CodigoRepresentante.Value.ToString());

                if (contato != null)
                    crm.Representante = new Lookup(contato.ID.Value, "");
                else
                {
                    resultadoPersistencia.Sucesso = false;
                    resultadoPersistencia.Mensagem = "Representante não encontrado.";
                    return crm;
                }
            }
            else
            {
                crm.AddNullProperty("Representante");
            }

            if (!String.IsNullOrEmpty(xml.CodigoColaboradorIntelbras))
            {
                if (xml.CodigoColaboradorIntelbras.Length == 36)
                    crm.ColaboradorIntebras = new Lookup(new Guid(xml.CodigoColaboradorIntelbras), "");
                else
                {
                    resultadoPersistencia.Sucesso = false;
                    resultadoPersistencia.Mensagem = "CodigoColaboradorIntelbras fora do padrão(Guid).";
                    return crm;
                }
            }
            else
            {
                crm.AddNullProperty("ColaboradorIntebras");
            }

            if (!String.IsNullOrEmpty(xml.CodigoCanalDenunciante))
            {
                if (xml.CodigoCanalDenunciante.Length == 36)
                    crm.CanalDenunciante = new Lookup(new Guid(xml.CodigoCanalDenunciante), "");
                else
                {
                    resultadoPersistencia.Sucesso = false;
                    resultadoPersistencia.Mensagem = "CodigoCanalDenunciante fora do padrão(Guid).";
                    return crm;
                }
            }
            else
            {
                crm.AddNullProperty("CanalDenunciante");
            }

            if (!String.IsNullOrEmpty(xml.CodigoColaboradorCanal))
            {
                if (xml.CodigoColaboradorCanal.Length == 36)
                    crm.ColaboradorCanal = new Lookup(new Guid(xml.CodigoColaboradorCanal), "");
                else
                {
                    resultadoPersistencia.Sucesso = false;
                    resultadoPersistencia.Mensagem = "CodigoColaboradorCanal fora do padrão(Guid).";
                    return crm;
                }
            }
            else
            {
                crm.AddNullProperty("ColaboradorCanal");
            }

            if (!String.IsNullOrEmpty(xml.NomeDenunciante))
            {
                crm.Denunciante = xml.NomeDenunciante;
            }
            else
            {
                resultadoPersistencia.Sucesso = false;
                resultadoPersistencia.Mensagem = "Nome do Denunciante não Enviado.";
                return crm;
            }




            string tipoProprietario;

            if (xml.TipoProprietario == "team" || xml.TipoProprietario == "systemuser")
                tipoProprietario = xml.TipoProprietario;
            else
            {
                resultadoPersistencia.Sucesso = false;
                resultadoPersistencia.Mensagem = "Tipo Proprietário não Enviado.";
                return crm;
            }

            #endregion

            return crm;
        }
Example #2
0
        public Parecer DefinirPropriedades(Intelbras.Message.Helper.MSG0149 xml)
        {
            var crm = new Parecer(this.Organizacao, this.IsOffline);

            #region Propriedades Crm->Xml

            if (!string.IsNullOrEmpty(xml.CodigoParecer))
            {
                crm.ID = new Guid(xml.CodigoParecer);
            }

            if (xml.PossuiSuporteTecnico.HasValue)
            {
                if (System.Enum.IsDefined(typeof(Intelbras.CRM2013.Domain.Enum.Parecer.DispoeSuporteTecnico), xml.PossuiSuporteTecnico))
                {
                    crm.DispoedeSuporteTecnico = xml.PossuiSuporteTecnico;
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Indentificador do Possui Suporte Técnico não encontrado.";
                    return(crm);
                }
            }
            else
            {
                crm.AddNullProperty("DispoedeSuporteTecnico");
            }

            if (!string.IsNullOrEmpty(xml.Distribuidores))
            {
                crm.Distribuidores = xml.Distribuidores;
            }
            else
            {
                crm.AddNullProperty("Distribuidores");
            }

            Contato objContato = new Intelbras.CRM2013.Domain.Servicos.ContatoService(this.Organizacao, this.IsOffline).BuscaContatoPorCodigoRepresentante(xml.CodigoRepresentante.ToString());
            if (objContato != null)
            {
                crm.KeyAccountouRepresentante = new Lookup(objContato.ID.Value, "");
            }
            else
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "Indentificador do Key Account Representante não encontrado.";
                return(crm);
            }

            if (!string.IsNullOrEmpty(xml.NomeParecer))
            {
                crm.Nome = xml.NomeParecer;
            }
            else
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "Campo Nome obrigatório.";
                return(crm);
            }

            if (xml.AprovadoRedir.HasValue)
            {
                if (System.Enum.IsDefined(typeof(Intelbras.CRM2013.Domain.Enum.Parecer.AprovadoRedir), xml.AprovadoRedir))
                {
                    crm.AprovadopeloREDIR = xml.AprovadoRedir;
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Indentificador do Aprovado Redir não encontrado.";
                    return(crm);
                }
            }
            else
            {
                crm.AddNullProperty("AprovadopeloREDIR");
            }

            if (xml.VendeClienteFinal.HasValue)
            {
                if (System.Enum.IsDefined(typeof(Intelbras.CRM2013.Domain.Enum.Parecer.AtuaVendasClientesFinais), xml.VendeClienteFinal))
                {
                    crm.AtuacomVendaparaClientesFinais = xml.VendeClienteFinal;
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Indentificador do 'Atua com Venda Para Clientes Finais' não encontrado.";
                    return(crm);
                }
            }
            else
            {
                crm.AddNullProperty("AtuacomVendaparaClientesFinais");
            }

            if (xml.PossuiCompetenciaTecnica.HasValue)
            {
                if (System.Enum.IsDefined(typeof(Intelbras.CRM2013.Domain.Enum.Parecer.CompetenciaTecnica), xml.PossuiCompetenciaTecnica))
                {
                    crm.DispoeCompetenciaTecnicaeComercial = xml.PossuiCompetenciaTecnica;
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Indentificador do 'Possui Competência Técnica' não encontrado.";
                    return(crm);
                }
            }
            else
            {
                crm.AddNullProperty("DispoeCompetenciaTecnicaeComercial");
            }

            if (xml.AceitouEnviarSellout.HasValue)
            {
                if (System.Enum.IsDefined(typeof(Intelbras.CRM2013.Domain.Enum.Parecer.EnviaSellOut), xml.AceitouEnviarSellout))
                {
                    crm.AceitouEnviarInformacoesdeSellouteEstoque = xml.AceitouEnviarSellout;
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Indentificador do 'Aceitou Enviar Sell Out' não encontrado.";
                    return(crm);
                }
            }
            else
            {
                crm.AddNullProperty("AceitouEnviarInformacoesdeSellouteEstoque");
            }

            if (xml.ValorCapitalProprio.HasValue)
            {
                crm.CapitalProprio = xml.ValorCapitalProprio;
            }
            else
            {
                crm.AddNullProperty("CapitalProprio");
            }

            if (xml.PorcentagemCapitalProprio.HasValue)
            {
                crm.CapitalProprioPct = xml.PorcentagemCapitalProprio.Value;
            }
            else
            {
                crm.AddNullProperty("CapitalProprioPct");
            }

            if (xml.VolumeAnual.HasValue)
            {
                crm.VolumeTotalAnual = xml.VolumeAnual;
            }
            else
            {
                crm.AddNullProperty("VolumeTotalAnual");
            }

            crm.Status = xml.Situacao;

            if (xml.ValorCapitalTerceiro.HasValue)
            {
                crm.CapitaldeTerceiros = xml.ValorCapitalTerceiro.Value;
            }
            else
            {
                crm.AddNullProperty("CapitaldeTerceiros");
            }

            if (!String.IsNullOrEmpty(xml.DescricaoImpactoAbertura))
            {
                crm.QuaisosImpactosdeAberturadoDistribuidor = xml.DescricaoImpactoAbertura;
            }
            else
            {
                crm.AddNullProperty("QuaisosImpactosdeAberturadoDistribuidor");
            }

            if (xml.AtendeCondicaoMinima.HasValue)
            {
                crm.Condicoesatendempadraominimo = xml.AtendeCondicaoMinima;
            }
            else
            {
                crm.AddNullProperty("Condicoesatendempadraominimo");
            }

            if (!string.IsNullOrEmpty(xml.CodigoConta) && xml.CodigoConta.Length == 36)
            {
                crm.Canal = new Lookup(new Guid(xml.CodigoConta), "");
            }
            else
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "Indentificador do 'Canal' não encontrado.";
                return(crm);
            }

            if (!string.IsNullOrEmpty(xml.DescricaoDemandaProduto))
            {
                crm.HademandaporLinhasdeProdutosnosMunicipios = xml.DescricaoDemandaProduto;
            }
            else
            {
                crm.AddNullProperty("HademandaporLinhasdeProdutosnosMunicipios");
            }

            if (xml.PossuiSistemaGestao.HasValue)
            {
                crm.DispoedeSistemadeGestaoAdmeFinanceira = xml.PossuiSistemaGestao;
            }
            else
            {
                crm.AddNullProperty("DispoedeSistemadeGestaoAdmeFinanceira");
            }

            if (!string.IsNullOrEmpty(xml.ObservacaoGerente))
            {
                crm.ObservacoesdoGerenteNacional = xml.ObservacaoGerente;
            }
            else
            {
                crm.AddNullProperty("ObservacoesdoGerenteNacional");
            }

            if (xml.EnvioDocumentacao.HasValue)
            {
                crm.Envioudocumentacaocompleta = xml.EnvioDocumentacao;
            }
            else
            {
                crm.AddNullProperty("Envioudocumentacaocompleta");
            }

            if (!string.IsNullOrEmpty(xml.DefesaAbertura))
            {
                crm.PorqueDefendeAberturadesseDistribuidor = xml.DefesaAbertura;
            }
            else
            {
                crm.AddNullProperty("PorqueDefendeAberturadesseDistribuidor");
            }

            if (!String.IsNullOrEmpty(xml.CodigoTarefa) && xml.CodigoTarefa.Length == 36)
            {
                crm.Tarefa = new Lookup(new Guid(xml.CodigoTarefa), "");
            }
            else
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "Campo 'Código Tarefa' obrigatório.";
                return(crm);
            }

            if (xml.PorcentagemCapitalTerceiro.HasValue)
            {
                crm.CapitaldeTerceirosPct = xml.PorcentagemCapitalTerceiro.Value;
            }
            else
            {
                crm.AddNullProperty("CapitaldeTerceirosPct");
            }

            if (!String.IsNullOrEmpty(xml.FundamentacaoAdequacao))
            {
                crm.FundamentacaoDistribuidorAprovado = xml.FundamentacaoAdequacao;
            }
            else
            {
                crm.AddNullProperty("FundamentacaoDistribuidorAprovado");
            }

            if (!String.IsNullOrEmpty(xml.FundamentacaoAprovacao))
            {
                crm.Fundamentacao = xml.FundamentacaoAprovacao;
            }
            else
            {
                crm.AddNullProperty("Fundamentacao");
            }

            if (xml.ValorPotencialRegiao.HasValue)
            {
                crm.PotencialdaRegiao = xml.ValorPotencialRegiao;
            }
            else
            {
                crm.AddNullProperty("PotencialdaRegiao");
            }

            if (xml.ExclusivoIntelbras.HasValue)
            {
                crm.IraatuarsomentecomprodutosIntelbras = xml.ExclusivoIntelbras;
            }
            else
            {
                crm.AddNullProperty("IraatuarsomentecomprodutosIntelbras");
            }

            if (xml.PossuiParecerRepresentante.HasValue)
            {
                if (System.Enum.IsDefined(typeof(Intelbras.CRM2013.Domain.Enum.Parecer.ParecerKARepresentante), xml.PossuiParecerRepresentante))
                {
                    crm.ParecerKeyAccountRepresentante = xml.PossuiParecerRepresentante;
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Indentificador do 'Parecer Key Account Representante' não encontrado.";
                    return(crm);
                }
            }
            else
            {
                crm.AddNullProperty("ParecerKeyAccountRepresentante");
            }

            if (xml.AprovadoPeloComite.HasValue)
            {
                if (System.Enum.IsDefined(typeof(Intelbras.CRM2013.Domain.Enum.Parecer.AprovadoComite), xml.AprovadoPeloComite))
                {
                    crm.AprovadoPeloComite = xml.AprovadoPeloComite;
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Indentificador do 'Aprovado pelo Comitê' não encontrado.";
                    return(crm);
                }
            }
            else
            {
                crm.AddNullProperty("AprovadoPeloComite");
            }

            if (xml.ValorFaturamentoRegiao.HasValue)
            {
                crm.FaturamentoDiretoparaaRegiao = xml.ValorFaturamentoRegiao;
            }
            else
            {
                crm.AddNullProperty("FaturamentoDiretoparaaRegiao");
            }

            if (xml.EnviouFichaCadastral.HasValue)
            {
                if (System.Enum.IsDefined(typeof(Intelbras.CRM2013.Domain.Enum.Parecer.FichaAvalicaoDistribuidor), xml.EnviouFichaCadastral))
                {
                    crm.FichadeAvaliacaodoDistribuidor = xml.EnviouFichaCadastral;
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Indentificador do 'Ficha Avaliação Distribuidor' não encontrado.";
                    return(crm);
                }
            }
            else
            {
                crm.AddNullProperty("FichadeAvaliacaodoDistribuidor");
            }

            if (!String.IsNullOrEmpty(xml.MotivoAberturaDistribuidor))
            {
                crm.MotivosprincipaisdeaberturadoDistribuidor = xml.MotivoAberturaDistribuidor;
            }
            else
            {
                crm.AddNullProperty("MotivosprincipaisdeaberturadoDistribuidor");
            }

            if (xml.AceitaNovasPraticas.HasValue)
            {
                if (System.Enum.IsDefined(typeof(Intelbras.CRM2013.Domain.Enum.Parecer.DispostoAtuarNovasPraticas), xml.AceitaNovasPraticas))
                {
                    crm.DispostoaAtuarDentrodasNovasPraticas = xml.AceitaNovasPraticas;
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Indentificador do 'Disposto Atuar Novas Práticas' não encontrado.";
                    return(crm);
                }
            }
            else
            {
                crm.AddNullProperty("DispostoaAtuarDentrodasNovasPraticas");
            }

            if (!String.IsNullOrEmpty(xml.PrevisaoLinhaCorte))
            {
                crm.PrevisaoLinhadeCorteMinima = xml.PrevisaoLinhaCorte;
            }
            else
            {
                crm.AddNullProperty("PrevisaoLinhadeCorteMinima");
            }

            if (xml.PossuiParecerSetorFinanceiro.HasValue)
            {
                if (System.Enum.IsDefined(typeof(Intelbras.CRM2013.Domain.Enum.Parecer.ParecerSetorFinanc), xml.PossuiParecerSetorFinanceiro))
                {
                    crm.ParecerSetorFinanceiro = xml.PossuiParecerSetorFinanceiro;
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Indentificador do 'Parecer Setor Financeiro' não encontrado.";
                    return(crm);
                }
            }
            else
            {
                crm.AddNullProperty("ParecerSetorFinanceiro");
            }

            if (!String.IsNullOrEmpty(xml.ConflitoDistribuidores))
            {
                crm.TeremosConflitoscomosDistribuidores = xml.ConflitoDistribuidores;
            }
            else
            {
                crm.AddNullProperty("TeremosConflitoscomosDistribuidores");
            }

            if (!String.IsNullOrEmpty(xml.ObservacaoRepresentante))
            {
                crm.ObservacoesKeyAccountRepres = xml.ObservacaoRepresentante;
            }
            else
            {
                crm.AddNullProperty("ObservacoesKeyAccountRepres");
            }

            if (xml.LimiteCreditoLiberado.HasValue)
            {
                crm.QualLimitedeCreditoLiberado = xml.LimiteCreditoLiberado;
            }
            else
            {
                crm.AddNullProperty("QualLimitedeCreditoLiberado");
            }

            if (xml.PossuiParecerGerente.HasValue)
            {
                if (System.Enum.IsDefined(typeof(Intelbras.CRM2013.Domain.Enum.Parecer.ParecerGerenteNacVendas), xml.PossuiParecerGerente))
                {
                    crm.ParecerdoGerenteNacionaldeVendas = xml.PossuiParecerGerente;
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Indentificador do 'Parecer Gerente Nacional de Vendas' não encontrado.";
                    return(crm);
                }
            }
            else
            {
                crm.AddNullProperty("ParecerdoGerenteNacionaldeVendas");
            }

            if (xml.PorcentagemRegiao.HasValue)
            {
                crm.FaturamentoPorcentagemRegiao = xml.PorcentagemRegiao.Value;
            }
            else
            {
                crm.AddNullProperty("FaturamentoPorcentagemRegiao");
            }

            if (xml.DistribuidorAprovado.HasValue)
            {
                if (System.Enum.IsDefined(typeof(Intelbras.CRM2013.Domain.Enum.Parecer.DistribuidorAprovado), xml.DistribuidorAprovado))
                {
                    crm.DistribuidorAprovado = xml.DistribuidorAprovado;
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Indentificador do 'Distribuidor Aprovado' não encontrado.";
                    return(crm);
                }
            }
            else
            {
                crm.AddNullProperty("DistribuidorAprovado");
            }

            if (xml.AtuaVendaSemNota.HasValue)
            {
                if (System.Enum.IsDefined(typeof(Intelbras.CRM2013.Domain.Enum.Parecer.VendaSemNotaFiscal), xml.AtuaVendaSemNota))
                {
                    crm.AtuacomVendasemNotaFiscal = xml.AtuaVendaSemNota;
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Indentificador do 'Atua Sem Nota Fiscal' não encontrado.";
                    return(crm);
                }
            }
            else
            {
                crm.AddNullProperty("AtuacomVendasemNotaFiscal");
            }

            if (!String.IsNullOrEmpty(xml.ObservacaoSetorFinaceiro))
            {
                crm.ObservacoesSetorFinanceiro = xml.ObservacaoSetorFinaceiro;
            }
            else
            {
                crm.AddNullProperty("ObservacoesSetorFinanceiro");
            }

            if (xml.DistribuidorAdequado.HasValue)
            {
                if (System.Enum.IsDefined(typeof(Intelbras.CRM2013.Domain.Enum.Parecer.DistribuidorAdequado), xml.DistribuidorAdequado))
                {
                    crm.DistribuidorAdequado = xml.DistribuidorAdequado;
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Indentificador do 'Distribuidor Adequado' não encontrado.";
                    return(crm);
                }
            }
            else
            {
                crm.AddNullProperty("DistribuidorAdequado");
            }

            if (xml.PorcentagemPotencialRegiao.HasValue)
            {
                crm.PotencialPorcentagem = xml.PorcentagemPotencialRegiao.Value;
            }
            else
            {
                crm.AddNullProperty("PotencialPorcentagem");
            }

            if (xml.PossuiExperiencia.HasValue)
            {
                if (System.Enum.IsDefined(typeof(Intelbras.CRM2013.Domain.Enum.Parecer.Experiencia5AnosDistri), xml.PossuiExperiencia))
                {
                    crm.PossuiExperienciade5anosemDistribuicao = xml.PossuiExperiencia;
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Indentificador do 'Possui Experiência de 5 anos em distribuição' não encontrado.";
                    return(crm);
                }
            }
            else
            {
                crm.AddNullProperty("PossuiExperienciade5anosemDistribuicao");
            }
            //
            if (xml.PorcentagemFaturamento.HasValue)
            {
                crm.PorcentagemFaturamento = xml.PorcentagemFaturamento.Value;
            }
            else
            {
                crm.AddNullProperty("PorcentagemFaturamento");
            }

            if (System.Enum.IsDefined(typeof(Intelbras.CRM2013.Domain.Enum.Parecer.TipoParecer), xml.TipoParecer))
            {
                crm.TipodoParecer = xml.TipoParecer;
            }
            else
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "Indentificador do 'Tipo do Parecer' não encontrado.";
                return(crm);
            }

            string tipoProprietario;

            if (xml.TipoProprietario == "team" || xml.TipoProprietario == "systemuser")
            {
                tipoProprietario = xml.TipoProprietario;
            }
            else
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "Tipo Proprietário não Enviado.";
                return(crm);
            }

            #endregion

            return(crm);
        }
Example #3
0
        public Postagem DefinirPropriedades(Intelbras.Message.Helper.MSG0270 xml)
        {
            var crm = new Model.Postagem(this.Organizacao, this.IsOffline);

            if (!String.IsNullOrEmpty(xml.NumeroProjeto))
            {
                ClientePotencial cliente = new Servicos.LeadService(this.Organizacao, this.IsOffline).ObterPorNumeroProjeto(xml.NumeroProjeto);
                if (cliente != null)
                {
                    Oportunidade oportunidade = new Servicos.RepositoryService().Oportunidade.BuscarPor(cliente);

                    if (xml.ClassificacaoProjeto.HasValue)
                    {
                        if (xml.ClassificacaoProjeto == 993520000) // Cliente Potencial
                        {
                            crm.CriadoEm         = xml.DataAtividade;
                            crm.UsuarioAtividade = new Lookup(usuarioIntegracao.Id, "");

                            Contato contato = new Intelbras.CRM2013.Domain.Servicos.ContatoService(this.Organizacao, this.IsOffline).BuscaContato(new Guid(xml.CodigoContato));
                            if (contato != null)
                            {
                                crm.Texto = "Mensagem postada por " + contato.Nome + ": " + xml.DescricaoAtividade;
                            }
                            else
                            {
                                resultadoPersistencia.Sucesso  = false;
                                resultadoPersistencia.Mensagem = "CodigoExecutivo não encontrado no Crm.";
                                return(crm);
                            }
                            crm.ReferenteA = new SDKore.DomainModel.Lookup(cliente.ID.Value, "lead");
                            crm.Source     = 2;
                        }
                        if (xml.ClassificacaoProjeto == 993520001)  // Oportunidade
                        {
                            if (oportunidade != null)
                            {
                                crm.CriadoEm         = xml.DataAtividade;
                                crm.UsuarioAtividade = new Lookup(usuarioIntegracao.Id, "");
                                Contato contato = new Intelbras.CRM2013.Domain.Servicos.ContatoService(this.Organizacao, this.IsOffline).BuscaContato(new Guid(xml.CodigoContato));
                                if (contato != null)
                                {
                                    crm.Texto = "Mensagem postada por " + contato.Nome + ": " + xml.DescricaoAtividade;
                                }
                                else
                                {
                                    resultadoPersistencia.Sucesso  = false;
                                    resultadoPersistencia.Mensagem = "CodigoExecutivo não encontrado no Crm.";
                                    return(crm);
                                }
                                crm.ReferenteA = new SDKore.DomainModel.Lookup(oportunidade.ID.Value, "opportunity");
                                crm.Source     = 2;
                            }
                        }
                    }
                    else
                    {
                        resultadoPersistencia.Sucesso  = false;
                        resultadoPersistencia.Mensagem = "ClassificacaoProjeto não informado, campo obrigatório.";
                        return(crm);
                    }
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "NumeroProjeto informado não existe para ser atualizado.";
                    return(crm);
                }
            }
            else
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "NumeroProjeto não informado, campo obrigatório.";
                return(crm);
            }

            return(crm);
        }
Example #4
0
        public List <Pollux.Entities.DenunciaItem> DefinirRetorno(Intelbras.Message.Helper.MSG0108 xml)
        {
            #region Propriedades Crm->Xml
            List <Denuncia> lstDenunciaCrm = new List <Denuncia>();
            List <Pollux.Entities.DenunciaItem> lstRetorno = new List <Pollux.Entities.DenunciaItem>();

            if (xml.SituacaoDenuncia != null)
            {
                if (!System.Enum.IsDefined(typeof(Intelbras.CRM2013.Domain.Enum.Denuncia.StatusDenuncia), xml.SituacaoDenuncia))
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "SituaçãoDenuncia não cadastrada no Crm.";
                    return(null);
                }
            }
            List <Guid> lstCanalDenunciantes = new List <Guid>();
            if (xml.CanaisDenunciantes != null && xml.CanaisDenunciantes.Count > 0)
            {
                foreach (var itemDenunciante in xml.CanaisDenunciantes)
                {
                    if (itemDenunciante.Length == 36)
                    {
                        var canalItemDenunciante = new Guid(itemDenunciante);
                        lstCanalDenunciantes.Add(canalItemDenunciante);
                    }
                    else
                    {
                        resultadoPersistencia.Sucesso  = false;
                        resultadoPersistencia.Mensagem = "Canal Denunciante fora do padrão(Guid)";
                        return(null);
                    }
                }
            }

            List <Guid> lstCanalDenunciado = new List <Guid>();
            if (xml.CanaisDenunciados != null && xml.CanaisDenunciados.Count > 0)
            {
                foreach (var itemDenunciado in xml.CanaisDenunciados)
                {
                    if (itemDenunciado.Length == 36)
                    {
                        var canalItem = new Guid(itemDenunciado);
                        lstCanalDenunciado.Add(canalItem);
                    }
                    else
                    {
                        resultadoPersistencia.Sucesso  = false;
                        resultadoPersistencia.Mensagem = "Canal Denunciado fora do padrão(Guid)";
                        return(null);
                    }
                }
            }
            Guid?representanteKeyAccountId = null;

            if (xml.CodigoRepresentante.HasValue)
            {
                Contato contato = new Contato(this.Organizacao, this.IsOffline);
                contato = new Intelbras.CRM2013.Domain.Servicos.ContatoService(this.Organizacao, this.IsOffline).BuscaContatoPorCodigoRepresentante(xml.CodigoRepresentante.Value.ToString());

                if (contato != null)
                {
                    representanteKeyAccountId = contato.ID.Value;
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Representante não encontrado.";
                    return(null);
                }
            }


            lstDenunciaCrm = new Servicos.DenunciaService(this.Organizacao, this.IsOffline).ListarDenuncias(xml.DataInicio, xml.DataFinal, lstCanalDenunciantes, lstCanalDenunciado, representanteKeyAccountId, xml.SituacaoDenuncia);
            //De -Para - Crm - pollux
            if (lstDenunciaCrm != null && lstDenunciaCrm.Count > 0)
            {
                foreach (var itemCrm in lstDenunciaCrm)
                {
                    Pollux.Entities.DenunciaItem denunciaItem = new Pollux.Entities.DenunciaItem();
                    if (itemCrm.Descricao != null && !String.IsNullOrEmpty(itemCrm.Descricao))
                    {
                        denunciaItem.Descricao = itemCrm.Descricao;
                    }
                    else
                    {
                        denunciaItem.Descricao = "N/A";
                    }
                    if (itemCrm.Nome != null && !String.IsNullOrEmpty(itemCrm.Nome))
                    {
                        denunciaItem.NomeDenuncia = itemCrm.Nome;
                    }
                    else
                    {
                        denunciaItem.NomeDenuncia = "N/A";
                    }

                    if (itemCrm.RazaoStatus.HasValue)
                    {
                        denunciaItem.SituacaoDenuncia = itemCrm.RazaoStatus.Value;
                    }
                    else
                    {
                        denunciaItem.SituacaoDenuncia = 0;
                    }

                    switch (itemCrm.RazaoStatus.Value)
                    {
                    case (int)Enum.Denuncia.StatusDenuncia.EmAnalise:
                        denunciaItem.NomeSituacaoDenuncia = "Em Análise";
                        break;

                    case (int)Enum.Denuncia.StatusDenuncia.AguardandoJustificativa:
                        denunciaItem.NomeSituacaoDenuncia = "Aguardando Justificativa";
                        break;

                    case (int)Enum.Denuncia.StatusDenuncia.JustificativaProvida:
                        denunciaItem.NomeSituacaoDenuncia = "Justificativa Provida";
                        break;

                    case (int)Enum.Denuncia.StatusDenuncia.AnaliseJustificativa:
                        denunciaItem.NomeSituacaoDenuncia = "Análise de Justificativa";
                        break;

                    case (int)Enum.Denuncia.StatusDenuncia.DenunciaProcedente:
                        denunciaItem.NomeSituacaoDenuncia = "Denúncia Procedente";
                        break;

                    case (int)Enum.Denuncia.StatusDenuncia.DenunciaImprocedente:
                        denunciaItem.NomeSituacaoDenuncia = "Denúncia Improcedente";
                        break;

                    default:
                        denunciaItem.NomeSituacaoDenuncia = "N/A";
                        break;
                    }

                    if (itemCrm.TipoDenuncia != null)
                    {
                        denunciaItem.NomeTipoDenuncia   = itemCrm.TipoDenuncia.Name;
                        denunciaItem.CodigoTipoDenuncia = itemCrm.TipoDenuncia.Id.ToString();
                    }
                    else
                    {
                        denunciaItem.NomeTipoDenuncia   = "N/A";
                        denunciaItem.CodigoTipoDenuncia = Guid.Empty.ToString();
                    }
                    if (!String.IsNullOrEmpty(itemCrm.Justificativa))
                    {
                        denunciaItem.Justificativa = itemCrm.Justificativa;
                    }

                    if (itemCrm.DataCriacao.HasValue)
                    {
                        denunciaItem.DataCriacao = itemCrm.DataCriacao.Value;
                    }
                    else
                    {
                        denunciaItem.DataCriacao = DateTime.MinValue;
                    }
                    denunciaItem.CodigoDenuncia = itemCrm.ID.Value.ToString();

                    lstRetorno.Add(denunciaItem);
                }
            }

            return(lstRetorno);

            #endregion
        }
Example #5
0
        private void DefinirPropriedadesProdutoFatura(Intelbras.Message.Helper.MSG0094 xml, Guid FaturaID)
        {
            ProdutoFatura crmProdFatura = null;

            foreach (Pollux.Entities.NotaFiscalItem item in xml.NotaFiscalItens)
            {
                crmProdFatura = new ProdutoFatura(this.Organizacao, this.IsOffline);

                crmProdFatura.ChaveIntegracao = item.ChaveIntegracao;
                crmProdFatura.Fatura          = new Lookup(FaturaID, "");

                if (!String.IsNullOrEmpty(item.CodigoProduto))
                {
                    Model.Product ObjProduto = new Product(this.Organizacao, this.IsOffline);
                    ObjProduto = new Intelbras.CRM2013.Domain.Servicos.ProdutoService(this.Organizacao, this.IsOffline).BuscaPorCodigo(item.CodigoProduto);

                    if (ObjProduto != null && ObjProduto.ID.HasValue)
                    {
                        crmProdFatura.ProdutoId = new Lookup(ObjProduto.ID.Value, "");
                    }
                    else
                    {
                        resultadoPersistencia.Sucesso  = false;
                        resultadoPersistencia.Mensagem = "Identificador do Produto não encontrado.";
                        return;
                    }
                }

                if (!String.IsNullOrEmpty(item.Descricao))
                {
                    crmProdFatura.Descricao = item.Descricao;
                }
                else
                {
                    crmProdFatura.AddNullProperty("Descricao");
                }

                crmProdFatura.PrecoOriginal           = item.PrecoOriginal;
                crmProdFatura.ValorLiquido            = item.PrecoUnitario;
                crmProdFatura.PrecoLiquido            = item.PrecoLiquido;
                crmProdFatura.ValorMercadoriaTabela   = item.ValorMercadoriaTabela;
                crmProdFatura.ValorMercadoriaOriginal = item.ValorMercadoriaOriginal;
                crmProdFatura.ValorMercadoriaLiquida  = item.ValorMercadoriaLiquido;
                crmProdFatura.Precificacao            = item.PermiteSubstituirPreco;

                //Service Natureza Operação
                NaturezaOperacao ObjNaturezaOperacao = new Intelbras.CRM2013.Domain.Servicos.NaturezaOperacaoService(this.Organizacao, this.IsOffline).BuscaNaturezaOperacaoPorCodigo(item.CodigoNaturezaOperacao);

                if (ObjNaturezaOperacao != null)
                {
                    crmProdFatura.NaturezaOperacao = new Lookup((Guid)ObjNaturezaOperacao.ID, "");
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Identificador da Natureza de Operação não encontrado.";
                    return;
                }

                crmProdFatura.SelecionarProduto = item.ProdutoForaCatalogo;

                if (!String.IsNullOrEmpty(item.DescricaoProdutoForaCatalogo))
                {
                    crmProdFatura.DescricaoProdutoSemCatalogo = item.DescricaoProdutoForaCatalogo;
                }
                else
                {
                    crmProdFatura.AddNullProperty("DescricaoProdutoSemCatalogo");
                }

                crmProdFatura.Precificacao = item.PermiteSubstituirPreco;

                //Service Unidade Medida
                Unidade ObjUnidadeMedida = new Intelbras.CRM2013.Domain.Servicos.UnidadeService(this.Organizacao, this.IsOffline).BuscaUnidadePorNome(item.UnidadeMedida);

                if (ObjUnidadeMedida != null)
                {
                    crmProdFatura.Unidade = new Lookup((Guid)ObjUnidadeMedida.ID, "");
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Identificador da Unidade de Medida não encontrado.";
                    return;
                }

                if (item.ValorBaseICMS.HasValue)
                {
                    crmProdFatura.ValorBaseICMS = item.ValorBaseICMS;
                }
                else
                {
                    crmProdFatura.AddNullProperty("ValorBaseICMS");
                }

                if (item.ValorBaseICMSSubstituicao.HasValue)
                {
                    crmProdFatura.ValorSubstTributaria = item.ValorBaseICMSSubstituicao;
                }
                else
                {
                    crmProdFatura.AddNullProperty("ValorSubstTributaria");
                }

                if (item.ValorICMS.HasValue)
                {
                    crmProdFatura.ValorICMSItem = item.ValorICMS;
                }
                else
                {
                    crmProdFatura.AddNullProperty("ValorICMSItem");
                }

                if (item.ValorICMSSubstituicao.HasValue)
                {
                    crmProdFatura.ValorICMSSubstTributaria = item.ValorICMSSubstituicao;
                }
                else
                {
                    crmProdFatura.AddNullProperty("ValorICMSSubstTributaria");
                }

                if (item.ValorICMSNaoTributado.HasValue)
                {
                    crmProdFatura.ValorICMSNaoTributado = item.ValorICMSNaoTributado;
                }
                else
                {
                    crmProdFatura.AddNullProperty("ValorICMSNaoTributado");
                }

                if (item.ValorICMSOutras.HasValue)
                {
                    crmProdFatura.ValorICMSOutras = item.ValorICMSOutras;
                }
                else
                {
                    crmProdFatura.AddNullProperty("ValorICMSOutras");
                }

                crmProdFatura.CodigoTributarioICMS = item.CodigoTributarioICMS;

                if (!String.IsNullOrEmpty(item.CodigoTributarioISS))
                {
                    crmProdFatura.CodigoTributarioISS = item.CodigoTributarioISS;
                }
                else
                {
                    crmProdFatura.AddNullProperty("CodigoTributarioISS");
                }

                crmProdFatura.CodigoTributarioIPI = item.CodigoTributarioIPI;

                if (item.ValorBaseIPI.HasValue)
                {
                    crmProdFatura.ValorBaseIPI = item.ValorBaseIPI;
                }
                else
                {
                    crmProdFatura.AddNullProperty("ValorBaseIPI");
                }

                if (item.AliquotaISS.HasValue)
                {
                    crmProdFatura.AliquotaISS = (double)item.AliquotaISS;
                }
                else
                {
                    crmProdFatura.AddNullProperty("AliquotaISS");
                }

                crmProdFatura.CodigoTributarioIPI  = item.CodigoTributarioIPI;
                crmProdFatura.ValorBaseISS         = item.ValorBaseISS;
                crmProdFatura.AliquotaIPI          = (double)item.AliquotaIPI;
                crmProdFatura.AliquotaICMS         = (double)item.AliquotaICMS;
                crmProdFatura.ValorISSItem         = item.ValorISS;
                crmProdFatura.ValorISSNaoTributado = item.ValorISSNaoTributado;
                crmProdFatura.ValorISSOutras       = item.ValorISSOutras;

                crmProdFatura.CalcularRebate = item.CalcularRebate;

                if (item.ValorIPI.HasValue)
                {
                    crmProdFatura.ValorIPIItem = item.ValorIPI;
                }
                else
                {
                    crmProdFatura.AddNullProperty("ValorIPIItem");
                }

                if (item.ValorIPINaoTributado.HasValue)
                {
                    crmProdFatura.ValorIPINaoTributado = item.ValorIPINaoTributado;
                }
                else
                {
                    crmProdFatura.AddNullProperty("ValorIPINaoTributado");
                }

                if (item.ValorIPIOutras.HasValue)
                {
                    crmProdFatura.ValorIPIOutras = item.ValorIPIOutras;
                }
                else
                {
                    crmProdFatura.AddNullProperty("ValorIPIOutras");
                }

                if (item.PrecoConsumidor.HasValue)
                {
                    crmProdFatura.PrecoConsumidor = item.PrecoConsumidor;
                }
                else
                {
                    crmProdFatura.AddNullProperty("PrecoConsumidor");
                }

                if (item.QuantidadeCancelada.HasValue)
                {
                    crmProdFatura.QtdeCancelada = item.QuantidadeCancelada;
                }
                else
                {
                    crmProdFatura.AddNullProperty("QtdeCancelada");
                }

                if (item.QuantidadePendente.HasValue)
                {
                    crmProdFatura.QtdePedidoPendente = item.QuantidadePendente;
                }
                else
                {
                    crmProdFatura.AddNullProperty("QtdePedidoPendente");
                }

                if (item.DataEntrega.HasValue)
                {
                    crmProdFatura.Entregueem = item.DataEntrega;
                }
                else
                {
                    crmProdFatura.AddNullProperty("Entregueem");
                }

                if (item.CondicaoFrete.HasValue)
                {
                    crmProdFatura.CondicoesFrete = item.CondicaoFrete;
                }
                else
                {
                    crmProdFatura.AddNullProperty("CondicoesFrete");
                }

                if (item.CalcularRebate.HasValue)
                {
                    //TODO: Registrar valor de CalcularRebate no Item da nota
                }

                if (item.ValorOriginal.HasValue)
                {
                    crmProdFatura.ValorOriginal = item.ValorOriginal;
                }
                else
                {
                    crmProdFatura.AddNullProperty("ValorOriginal");
                }

                crmProdFatura.TotalImpostos  = item.ValorTotalImposto;
                crmProdFatura.DescontoManual = item.ValorDescontoManual;
                crmProdFatura.Quantidade     = item.Quantidade;
                crmProdFatura.Remessa        = item.RetiraNoLocal;

                if (item.QuantidadeEntregue.HasValue)
                {
                    crmProdFatura.QtdeEntregue = item.QuantidadeEntregue;
                }
                else
                {
                    crmProdFatura.AddNullProperty("QtdeEntregue");
                }

                if (item.NumeroSequencia.HasValue)
                {
                    crmProdFatura.NumeroSequencia = item.NumeroSequencia;
                }
                else
                {
                    crmProdFatura.AddNullProperty("NumeroSequencia");
                }

                //Service Unidade Negócio
                UnidadeNegocio ObjUnidadeNegocio = new Intelbras.CRM2013.Domain.Servicos.UnidadeNegocioService(this.Organizacao, this.IsOffline).BuscaUnidadeNegocioPorChaveIntegracao(item.CodigoUnidadeNegocio);

                if (ObjUnidadeNegocio != null)
                {
                    crmProdFatura.UnidadeNegocio = new Lookup((Guid)ObjUnidadeNegocio.ID, "");
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Identificador da Unidade de Negócio não encontrado.";
                    return;
                }

                #region Representante

                crmProdFatura.IntegradoRepresentanteComErro = false;
                crmProdFatura.RepresentanteOriginal         = item.CodigoRepresentante.ToString();

                Contato ObjRepresentante = new Intelbras.CRM2013.Domain.Servicos.ContatoService(this.Organizacao, this.IsOffline)
                                           .BuscaContatoPorCodigoRepresentante(item.CodigoRepresentante.ToString());

                if (ObjRepresentante != null)
                {
                    crmProdFatura.Representante = new Lookup(ObjRepresentante.ID.Value, "");
                }
                else
                {
                    crmProdFatura.IntegradoRepresentanteComErro = true;
                    crmProdFatura.Representante = new Lookup(ObterRepresentatePadrao(), string.Empty);
                }

                #endregion

                //Service Moeda
                Moeda ObjMoeda = new Intelbras.CRM2013.Domain.Servicos.MoedaService(this.Organizacao, this.IsOffline).BuscaMoedaPorCodigo(xml.Moeda);

                if (ObjMoeda != null)
                {
                    crmProdFatura.Moeda = new Lookup((Guid)ObjMoeda.ID, "");
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Identificador da Moeda não encontrado.";
                    return;
                }

                crmProdFatura.RazaoStatus = 1;

                string acaoItemFatura = item.Acao;

                if (!string.IsNullOrEmpty(item.EnderecoEntrega.NomeEndereco))
                {
                    crmProdFatura.NomeEntrega = item.EnderecoEntrega.NomeEndereco;
                }
                else
                {
                    crmProdFatura.AddNullProperty("NomeEntrega");
                }

                crmProdFatura.CEPEntrega  = item.EnderecoEntrega.CEP;
                crmProdFatura.Rua1Entrega = item.EnderecoEntrega.Logradouro;

                if (!string.IsNullOrEmpty(item.EnderecoEntrega.Complemento))
                {
                    crmProdFatura.Rua2Entrega = item.EnderecoEntrega.Complemento;
                }
                else
                {
                    crmProdFatura.AddNullProperty("Rua2Entrega");
                }

                crmProdFatura.Rua3Entrega   = item.EnderecoEntrega.Bairro;
                crmProdFatura.CidadeEntrega = item.EnderecoEntrega.NomeCidade;

                if (!String.IsNullOrEmpty(item.EnderecoEntrega.Estado))
                {
                    crmProdFatura.EstadoEntrega = item.EnderecoEntrega.Estado;
                }

                if (!String.IsNullOrEmpty(item.EnderecoEntrega.Pais))
                {
                    crmProdFatura.PaisEntrega = item.EnderecoEntrega.Pais;
                }

                if (!String.IsNullOrEmpty(item.EnderecoEntrega.Telefone))
                {
                    crmProdFatura.TelefoneEntrega = item.EnderecoEntrega.Telefone;
                }
                else
                {
                    crmProdFatura.AddNullProperty("TelefoneEntrega");
                }

                if (!String.IsNullOrEmpty(item.EnderecoEntrega.Fax))
                {
                    crmProdFatura.FAXEntrega = item.EnderecoEntrega.Fax;
                }
                else
                {
                    crmProdFatura.AddNullProperty("FAXEntrega");
                }

                if (acaoItemFatura == "A" || acaoItemFatura == "I")
                {
                    lstProdutoFaturaUpdate.Add(crmProdFatura);
                }
                if (acaoItemFatura == "E")
                {
                    lstProdutoFaturaDelete.Add(crmProdFatura);
                }
            }
        }
Example #6
0
        public Fatura DefinirPropriedades(Intelbras.Message.Helper.MSG0094 xml)
        {
            Fatura crm = new Fatura(this.Organizacao, this.IsOffline);

            if (!String.IsNullOrEmpty(xml.NumeroNotaFiscal))
            {
                crm.NumeroNF = xml.NumeroNotaFiscal;
            }
            else
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "NumeroNotaFiscal não enviado.";
                return(crm);
            }

            crm.Serie     = xml.NumeroSerie;
            crm.ClienteId = new Lookup(new Guid(xml.CodigoClienteCRM), xml.TipoObjetoCliente);


            crm.ChaveIntegracao = xml.ChaveIntegracao; //NumeroPedido.ToString();

            if (xml.NumeroPedido != null)
            {
                Pedido pedido = new Servicos.PedidoService(this.Organizacao, this.IsOffline).BuscaPedidoEMS(xml.NumeroPedido.ToString());
                if (pedido != null)
                {
                    crm.PedidoCRM = new Lookup(pedido.ID.Value, "");

                    Fatura fatura = new Servicos.FaturaService(this.Organizacao, this.IsOffline).ObterFaturaPorPedidoEMS(xml.NumeroPedido.ToString());
                    if (fatura != null)
                    {
                        crm.ID = fatura.ID.Value;
                    }
                }
            }

            if (!String.IsNullOrEmpty(xml.NumeroPedidoCliente))
            {
                crm.PedidoCliente = xml.NumeroPedidoCliente;
            }
            else
            {
                crm.AddNullProperty("PedidoCliente");
            }

            if (!String.IsNullOrEmpty(xml.Descricao))
            {
                crm.Descricao = xml.Descricao;
            }
            else
            {
                crm.AddNullProperty("Descricao");
            }

            //Service Estabelecimento
            Estabelecimento ObjEstabelecimento = new Intelbras.CRM2013.Domain.Servicos.EstabelecimentoService(this.Organizacao, this.IsOffline).BuscaEstabelecimentoPorCodigo(xml.Estabelecimento.Value);

            if (ObjEstabelecimento != null)
            {
                crm.Estabelecimento = new Lookup((Guid)ObjEstabelecimento.ID, "");
            }
            else
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "Identificador do Estabelecimento não encontrado.";
                return(crm);
            }

            //Service Condição Pagamento
            CondicaoPagamento ObjCondicaoPagamento = null;

            if (xml.CondicaoPagamento.HasValue)
            {
                ObjCondicaoPagamento = new Intelbras.CRM2013.Domain.Servicos.CondicaoPagamentoService(this.Organizacao, this.IsOffline).BuscaCondicaoPagamentoPorCodigo(xml.CondicaoPagamento.Value);

                if (ObjCondicaoPagamento != null)
                {
                    crm.CondicaoPagamento = new Lookup((Guid)ObjCondicaoPagamento.ID, "");
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Identificador da Condição de Pagamento não encontrado.";
                    return(crm);
                }
            }
            else
            {
                crm.AddNullProperty("CondicaoPagamento");
            }

            crm.NomeAbreviado = xml.NomeAbreviadoCliente;

            //Service Natureza Operação
            NaturezaOperacao ObjNaturezaOperacao = new Intelbras.CRM2013.Domain.Servicos.NaturezaOperacaoService(this.Organizacao, this.IsOffline).BuscaNaturezaOperacaoPorCodigo(xml.NaturezaOperacao);

            if (ObjNaturezaOperacao != null)
            {
                crm.NaturezaOperacao = new Lookup((Guid)ObjNaturezaOperacao.ID, "");
            }
            else
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "Identificador da Natureza de Operação não encontrado.";
                return(crm);
            }

            //Service Moeda
            Moeda ObjMoeda = new Intelbras.CRM2013.Domain.Servicos.MoedaService(this.Organizacao, this.IsOffline).BuscaMoedaPorCodigo(xml.Moeda);

            if (ObjMoeda != null)
            {
                crm.Moeda = new Lookup((Guid)ObjMoeda.ID, "");
            }
            else
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "Identificador da Moeda não encontrado.";
                return(crm);
            }

            //Service para resolver o status
            if (System.Enum.IsDefined(typeof(Enum.Fatura.Status), xml.SituacaoNota))
            {
                crm.Status = xml.SituacaoNota;
            }
            else
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "Identificador da Situação da nota não encontrado.";
                return(crm);
            }

            if (System.Enum.IsDefined(typeof(Enum.Fatura.RazaoStatus), xml.SituacaoEntrega))
            {
                crm.RazaoStatus = xml.SituacaoEntrega;
            }

            crm.DataEmissao = xml.DataEmissao;

            if (xml.DataSaida.HasValue)
            {
                crm.DataSaida = xml.DataSaida;
            }
            else
            {
                crm.AddNullProperty("DataSaida");
            }

            if (xml.DataEntrega.HasValue)
            {
                crm.DataEntrega = xml.DataEntrega;
            }
            else
            {
                crm.AddNullProperty("DataEntrega");
            }

            if (xml.DataConfirmacao != null)
            {
                crm.DataConfirmacao = xml.DataConfirmacao;
            }
            else
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "DataConfirmacao não enviada.";
                return(crm);
            }

            if (xml.DataCancelamento.HasValue)
            {
                crm.DataCancelamento = xml.DataCancelamento;
            }
            else
            {
                crm.AddNullProperty("DataCancelamento");
            }

            if (xml.DataConclusao.HasValue)
            {
                crm.DataConclusao = xml.DataConclusao;
            }
            else
            {
                crm.AddNullProperty("DataConclusao");
            }

            crm.ValorFrete = xml.ValorFrete;

            crm.PesoLiquido = xml.PesoLiquido;

            crm.PesoBruto = xml.PesoBruto;

            if (!String.IsNullOrEmpty(xml.Observacao))
            {
                crm.Observacao = xml.Observacao;
            }
            else
            {
                crm.AddNullProperty("Observacao");
            }

            crm.Volume = xml.Volume.ToString();

            crm.BaseICMS            = xml.ValorBaseICMS;
            crm.ValorICMS           = xml.ValorICMS;
            crm.ValorIPI            = xml.ValorIPI;
            crm.BaseSubstTributaria = xml.ValorBaseSubstituicaoTributaria;
            crm.ValorSubstituicao   = xml.ValorSubstituicaoTributaria;
            crm.ClienteRetira       = xml.RetiraNoLocal;

            if (xml.MetodoEntrega.HasValue)
            {
                crm.MetodoEntrega = xml.MetodoEntrega;
            }
            else
            {
                crm.AddNullProperty("MetodoEntrega");
            }

            //Service Transportadora
            Transportadora ObjTransportadora = new Intelbras.CRM2013.Domain.Servicos.TransportadoraService(this.Organizacao, this.IsOffline).ObterPorCodigoTransportadora(xml.Transportadora.Value);

            if (ObjTransportadora != null)
            {
                crm.Transportadora = new Lookup((Guid)ObjTransportadora.ID, "");
            }
            else
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "Identificador da Transportadora não encontrado.";
                return(crm);
            }

            crm.Frete = xml.Frete;

            //crm.CondicoesFrete = xml.tipo;

            if (!String.IsNullOrEmpty(xml.TelefoneCobranca))
            {
                crm.TelefoneCobranca = xml.TelefoneCobranca;
            }
            else
            {
                crm.AddNullProperty("TelefoneCobranca");
            }

            if (!String.IsNullOrEmpty(xml.FaxCobranca))
            {
                crm.FaxCobranca = xml.FaxCobranca;
            }
            else
            {
                crm.AddNullProperty("FaxCobranca");
            }

            //Removido essa validação para que as NF de clientes estrangeiros sejam integrados no CRM
            //if (!String.IsNullOrEmpty(xml.CNPJ))
            //    crm.CpfCnpj = Intelbras.CRM2013.Domain.Servicos.Helper.FormatarCnpj(xml.CNPJ);
            //else if (!String.IsNullOrEmpty(xml.CPF))
            //    crm.CpfCnpj = Intelbras.CRM2013.Domain.Servicos.Helper.FormatarCpf(xml.CPF);
            //else
            //{
            //    resultadoPersistencia.Sucesso = false;
            //    resultadoPersistencia.Mensagem = "CNPJ/CPF não enviado.";
            //    return crm;
            //}

            if (!String.IsNullOrEmpty(xml.InscricaoEstadual))
            {
                crm.InscricaoEstadual = xml.InscricaoEstadual;
            }
            else
            {
                crm.AddNullProperty("InscricaoEstadual");
            }

            if (!string.IsNullOrEmpty(xml.Oportunidade))
            {
                crm.Oportunidade = new Lookup(new Guid(xml.Oportunidade), "");
            }

            xml.PrecoBloqueado = xml.PrecoBloqueado;

            if (xml.ValorDesconto.HasValue)
            {
                crm.ValorDescontoFatura = xml.ValorDesconto;
            }
            else
            {
                crm.AddNullProperty("ValorDescontoFatura");
            }

            if (xml.PercentualDesconto.HasValue)
            {
                crm.DescontoGlobalTotal = xml.PercentualDesconto;
            }
            else
            {
                crm.AddNullProperty("DescontoGlobalTotal");
            }

            //Service Lista Preço
            ListaPreco ObjListaPreco = new Intelbras.CRM2013.Domain.Servicos.ListaPrecoService(this.Organizacao, this.IsOffline).BuscaListaPreco(xml.ListaPreco);

            if (ObjListaPreco != null)
            {
                crm.ListaPrecos = new Lookup((Guid)ObjListaPreco.ID, "");
            }
            else
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "Identificador da Lista de Preço não encontrado.";
                return(crm);
            }

            crm.Prioridade = xml.Prioridade;

            if (xml.ValorTotal.HasValue)
            {
                crm.ValorTotal = xml.ValorTotal;
            }
            else
            {
                crm.AddNullProperty("ValorTotal");
            }

            if (xml.ValorTotalImpostos.HasValue)
            {
                crm.TotalImpostos = xml.ValorTotalImpostos;
            }
            else
            {
                crm.AddNullProperty("TotalImpostos");
            }

            //if (xml.ValorTotalProdutosSemImposto.HasValue)
            //    crm.ValorTotalProdutosSemIPIST = xml.ValorTotalProdutosSemImposto;

            if (xml.ValorTotalSemFrete.HasValue)
            {
                crm.ValorTotalSemFrete = xml.ValorTotalSemFrete;
            }
            else
            {
                crm.AddNullProperty("ValorTotalSemFrete");
            }

            if (xml.ValorTotalDesconto.HasValue)
            {
                crm.DescontoTotal = xml.ValorTotalDesconto;
            }
            else
            {
                crm.AddNullProperty("DescontoTotal");
            }

            if (xml.ValorTotalProdutos.HasValue)
            {
                crm.TotalProdutosComIPIST = xml.ValorTotalProdutos;
            }
            else
            {
                crm.AddNullProperty("TotalProdutosComIPIST");
            }

            if (xml.ValorTotalProdutosSemImposto.HasValue)
            {
                crm.ValorTotalProdutosSemIPIST = xml.ValorTotalProdutosSemImposto;
            }
            else
            {
                crm.AddNullProperty("ValorTotalProdutosSemIPIST");
            }

            //Service Endereco Entrega

            if (!string.IsNullOrEmpty(xml.EnderecoEntrega.CaixaPostal))
            {
                crm.EnderecoEntregaCaixaPostal = xml.EnderecoEntrega.CaixaPostal;
            }
            else
            {
                crm.AddNullProperty("EnderecoEntregaCaixaPostal");
            }

            if (!string.IsNullOrEmpty(xml.EnderecoEntrega.NomeEndereco))
            {
                crm.NomeEntrega = xml.EnderecoEntrega.NomeEndereco;
            }
            else
            {
                crm.AddNullProperty("NomeEntrega");
            }

            crm.CEPEntrega            = xml.EnderecoEntrega.CEP;
            crm.EnderecoEntregaRua    = xml.EnderecoEntrega.Logradouro;
            crm.EnderecoEntregaNumero = xml.EnderecoEntrega.Numero;
            crm.BairroEntrega         = xml.EnderecoEntrega.Bairro;
            crm.ComplementoEntrega    = xml.EnderecoEntrega.Complemento;
            crm.TipoNotaFiscal        = xml.TipoNotaFiscal;
            crm.NotaDevolucao         = xml.NotaDevolucao;
            crm.IdentificadorUnicoNfe = xml.IdentificadorUnicoNFE;

            if (!string.IsNullOrEmpty(xml.EnderecoEntrega.Complemento))
            {
                crm.ComplementoEntrega = xml.EnderecoEntrega.Complemento;
            }
            else
            {
                crm.AddNullProperty("ComplementoEntrega");
            }


            if (!String.IsNullOrEmpty(xml.EnderecoEntrega.Cidade))
            {
                Model.Municipio cidade = new Model.Municipio(this.Organizacao, this.IsOffline);
                cidade = new Intelbras.CRM2013.Domain.Servicos.EnderecoServices(this.Organizacao, this.IsOffline).BuscaMunicipio(xml.EnderecoEntrega.Cidade);

                if (cidade != null && cidade.ID.HasValue)
                {
                    crm.EnderecoEntregaCidade = new Lookup(cidade.ID.Value, "");
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Identificador da Cidade não encontrado!";
                    return(crm);
                }
            }

            if (!String.IsNullOrEmpty(xml.EnderecoEntrega.Estado))
            {
                Model.Estado estado = new Model.Estado(this.Organizacao, this.IsOffline);
                estado = new Intelbras.CRM2013.Domain.Servicos.EnderecoServices(this.Organizacao, this.IsOffline).BuscaEstado(xml.EnderecoEntrega.Estado);

                if (estado != null && estado.ID.HasValue)
                {
                    crm.EnderecoEntregaEstado = new Lookup(estado.ID.Value, "");
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Identificador do Estado não encontrado!";
                    return(crm);
                }
            }

            ///Service Pais
            if (!String.IsNullOrEmpty(xml.EnderecoEntrega.Pais))
            {
                Model.Pais pais = new Model.Pais(this.Organizacao, this.IsOffline);
                pais = new Intelbras.CRM2013.Domain.Servicos.EnderecoServices(this.Organizacao, this.IsOffline).BuscaPais(xml.EnderecoEntrega.Pais);

                if (pais != null && pais.ID.HasValue)
                {
                    crm.EnderecoEntregaPais = new Lookup(pais.ID.Value, "");
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Identificador do País não encontrado.";
                    return(crm);
                }
            }

            if (!String.IsNullOrEmpty(xml.EnderecoEntrega.NomeContato))
            {
                crm.NomeEntrega = xml.EnderecoEntrega.NomeContato;
            }
            else
            {
                crm.AddNullProperty("NomeEntrega");
            }


            if (!String.IsNullOrEmpty(xml.EnderecoEntrega.Telefone))
            {
                crm.TelefoneEntrega = xml.EnderecoEntrega.Telefone;
            }
            else
            {
                crm.AddNullProperty("TelefoneEntrega");
            }


            if (!String.IsNullOrEmpty(xml.EnderecoEntrega.Fax))
            {
                crm.FaxEntrega = xml.EnderecoEntrega.Fax;
            }
            else
            {
                crm.AddNullProperty("FaxEntrega");
            }


            #region Representante

            crm.IntegradoRepresentanteComErro = false;
            crm.IntegradoComErros             = false;
            crm.RepresentanteOriginal         = xml.Representante.ToString();

            Contato ObjRepresentante = new Intelbras.CRM2013.Domain.Servicos.ContatoService(this.Organizacao, this.IsOffline)
                                       .BuscaContatoPorCodigoRepresentante(xml.Representante.ToString());

            if (ObjRepresentante != null)
            {
                crm.KARepresentante = new Lookup(ObjRepresentante.ID.Value, "");
            }
            else
            {
                crm.IntegradoRepresentanteComErro = true;
                crm.IntegradoComErros             = true;
                crm.KARepresentante = new Lookup(ObterRepresentatePadrao(), "");
            }

            #endregion

            return(crm);
        }
Example #7
0
        public List <Pollux.Entities.Parecer> DefinirRetorno(Intelbras.Message.Helper.MSG0150 xml)
        {
            #region Propriedades Crm->Xml
            List <Pollux.Entities.Parecer> lstRetorno = new List <Pollux.Entities.Parecer>();

            if (!string.IsNullOrEmpty(xml.CodigoTarefa))
            {
                List <Parecer> lstParecer = new Intelbras.CRM2013.Domain.Servicos.ParecerService(this.Organizacao, this.IsOffline).ListarPor(new Guid(xml.CodigoTarefa));
                if (lstParecer.Count > 0)
                {
                    foreach (Parecer registro in lstParecer)
                    {
                        Pollux.Entities.Parecer tmpParecer = new Pollux.Entities.Parecer();

                        tmpParecer.CodigoParecer = registro.ID.Value.ToString();

                        if (String.IsNullOrEmpty(registro.Nome))
                        {
                            tmpParecer.NomeParecer = (String)this.PreencherAtributoVazio("string");
                        }
                        else
                        {
                            tmpParecer.NomeParecer = registro.Nome;
                        }

                        if (registro.TipodoParecer.HasValue)
                        {
                            tmpParecer.TipoParecer     = registro.TipodoParecer.Value;
                            tmpParecer.NomeTipoParecer = new Intelbras.CRM2013.Domain.Enum.Parecer().TipoParecerNome(registro.TipodoParecer.Value);
                        }
                        else
                        {
                            tmpParecer.TipoParecer     = (int)this.PreencherAtributoVazio("int");
                            tmpParecer.NomeTipoParecer = (string)this.PreencherAtributoVazio("string");
                        }


                        if (registro.KeyAccountouRepresentante != null)
                        {
                            Contato objContato = new Intelbras.CRM2013.Domain.Servicos.ContatoService(this.Organizacao, this.IsOffline).BuscaContato(registro.KeyAccountouRepresentante.Id);
                            if (objContato != null)
                            {
                                tmpParecer.CodigoRepresentante = Convert.ToInt32(objContato.CodigoRepresentante);
                                tmpParecer.NomeRepresentante   = registro.KeyAccountouRepresentante.Name;
                            }
                        }
                        else
                        {
                            tmpParecer.CodigoRepresentante = (int)this.PreencherAtributoVazio("int");
                            tmpParecer.NomeRepresentante   = (String)this.PreencherAtributoVazio("string");
                        }

                        if (registro.Canal != null)
                        {
                            tmpParecer.CodigoConta = registro.Canal.Id.ToString();
                            tmpParecer.NomeConta   = registro.Canal.Name;
                        }
                        else
                        {
                            tmpParecer.CodigoConta = (string)this.PreencherAtributoVazio("string");
                            tmpParecer.NomeConta   = (String)this.PreencherAtributoVazio("string");
                        }

                        if (registro.Status.HasValue)
                        {
                            tmpParecer.Situacao = registro.Status.Value;
                            switch (registro.Status.Value)
                            {
                            case 0:
                                tmpParecer.NomeSituacao = "Ativo";
                                break;

                            case 1:
                                tmpParecer.NomeSituacao = "Inativo";
                                break;
                            }
                        }
                        else
                        {
                            tmpParecer.NomeSituacao = (String)this.PreencherAtributoVazio("string");
                            tmpParecer.Situacao     = (Int32)this.PreencherAtributoVazio("int");
                        }

                        lstRetorno.Add(tmpParecer);
                    }

                    return(lstRetorno);
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Valor do parâmetro 'Código Tarefa' não existe";
                    return(lstRetorno);
                }
            }
            else
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "Valor do parâmetro 'Código Tarefa' é obrigatório";
                return(lstRetorno);
            }
            #endregion
        }
Example #8
0
        public Pollux.Entities.ObterParecer DefinirRetorno(Intelbras.Message.Helper.MSG0151 xml)
        {
            #region Propriedades Crm->Xml
            Pollux.Entities.ObterParecer retornoParecer = new Pollux.Entities.ObterParecer();

            if (string.IsNullOrEmpty(xml.CodigoParecer))
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "Valor do parâmetro 'Código Parecer' é obrigatório";
                return(retornoParecer);
            }

            Parecer objeto = new Intelbras.CRM2013.Domain.Servicos.ParecerService(this.Organizacao, this.IsOffline).ObterPor(new Guid(xml.CodigoParecer));
            if (objeto == null)
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "Valor do parâmetro 'Código Parecer' não existe";
                return(retornoParecer);
            }

            if (objeto.DispoedeSuporteTecnico.HasValue)
            {
                retornoParecer.PossuiSuporteTecnico     = objeto.DispoedeSuporteTecnico.Value;
                retornoParecer.NomePossuiSuporteTecnico = new Intelbras.CRM2013.Domain.Enum.Parecer().pegarNomeEnum(objeto.DispoedeSuporteTecnico.Value);
            }

            if (!string.IsNullOrEmpty(objeto.Distribuidores))
            {
                retornoParecer.Distribuidores = objeto.Distribuidores;
            }

            if (objeto.KeyAccountouRepresentante != null)
            {
                Contato contatoObjeto = new Intelbras.CRM2013.Domain.Servicos.ContatoService(this.Organizacao, this.IsOffline).BuscaContato(objeto.KeyAccountouRepresentante.Id);
                if (contatoObjeto != null)
                {
                    retornoParecer.CodigoRepresentante = Convert.ToInt32(contatoObjeto.CodigoRepresentante);
                    if (contatoObjeto.PrimeiroNome == null)
                    {
                        retornoParecer.NomeRepresentante = (string)this.PreencherAtributoVazio("string");
                    }
                    else
                    {
                        retornoParecer.NomeRepresentante = contatoObjeto.PrimeiroNome;
                    }
                }
                else
                {
                    retornoParecer.NomeRepresentante   = (string)this.PreencherAtributoVazio("string");
                    retornoParecer.CodigoRepresentante = (int)this.PreencherAtributoVazio("int");
                }
            }
            else
            {
                retornoParecer.NomeRepresentante   = (string)this.PreencherAtributoVazio("string");
                retornoParecer.CodigoRepresentante = (int)this.PreencherAtributoVazio("int");
            }

            if (!string.IsNullOrEmpty(objeto.Nome))
            {
                retornoParecer.NomeParecer = objeto.Nome;
            }
            else
            {
                retornoParecer.NomeParecer = (string)this.PreencherAtributoVazio("string");
            }

            if (objeto.AprovadopeloREDIR.HasValue)
            {
                retornoParecer.AprovadoRedir     = objeto.AprovadopeloREDIR.Value;
                retornoParecer.NomeAprovadoRedir = new Intelbras.CRM2013.Domain.Enum.Parecer().pegarNomeEnum(objeto.AprovadopeloREDIR.Value);
            }

            if (objeto.AtuacomVendaparaClientesFinais.HasValue)
            {
                retornoParecer.VendeClienteFinal     = objeto.AtuacomVendaparaClientesFinais.Value;
                retornoParecer.NomeVendeClienteFinal = new Intelbras.CRM2013.Domain.Enum.Parecer().pegarNomeEnum(objeto.AtuacomVendaparaClientesFinais.Value);
            }

            if (objeto.DispoeCompetenciaTecnicaeComercial.HasValue)
            {
                retornoParecer.PossuiCompetenciaTecnica     = objeto.DispoeCompetenciaTecnicaeComercial.Value;
                retornoParecer.NomePossuiCompetenciaTecnica = new Intelbras.CRM2013.Domain.Enum.Parecer().pegarNomeEnum(objeto.DispoeCompetenciaTecnicaeComercial.Value);
            }

            if (objeto.AceitouEnviarInformacoesdeSellouteEstoque.HasValue)
            {
                retornoParecer.AceitouEnviarSellout     = objeto.AceitouEnviarInformacoesdeSellouteEstoque.Value;
                retornoParecer.NomeAceitouEnviarSellout = new Intelbras.CRM2013.Domain.Enum.Parecer().pegarNomeEnum(objeto.AceitouEnviarInformacoesdeSellouteEstoque.Value);
            }

            if (objeto.CapitalProprio.HasValue)
            {
                retornoParecer.ValorCapitalProprio = objeto.CapitalProprio.Value;
            }

            if (!String.IsNullOrEmpty(objeto.FundamentacaoDistribuidorAprovado))
            {
                retornoParecer.FundamentacaoAprovacao = objeto.FundamentacaoDistribuidorAprovado;
            }

            retornoParecer.PorcentagemCapitalProprio = objeto.CapitalProprioPct;

            if (objeto.VolumeTotalAnual.HasValue)
            {
                retornoParecer.VolumeAnual = objeto.VolumeTotalAnual;
            }


            if (objeto.Status == null)
            {
                retornoParecer.Situacao     = (int)this.PreencherAtributoVazio("int");
                retornoParecer.NomeSituacao = (string)this.PreencherAtributoVazio("string");
            }
            else
            {
                retornoParecer.Situacao = objeto.Status.Value;
                if (objeto.Status.Value == 0)
                {
                    retornoParecer.NomeSituacao = "Ativo";
                }
                else
                {
                    retornoParecer.NomeSituacao = "Inativo";
                }
            }

            if (objeto.CapitaldeTerceiros.HasValue)
            {
                retornoParecer.ValorCapitalTerceiro = objeto.CapitaldeTerceiros;
            }

            if (!String.IsNullOrEmpty(objeto.QuaisosImpactosdeAberturadoDistribuidor))
            {
                retornoParecer.DescricaoImpactoAbertura = objeto.QuaisosImpactosdeAberturadoDistribuidor;
            }

            if (objeto.Condicoesatendempadraominimo.HasValue)
            {
                retornoParecer.AtendeCondicaoMinima     = objeto.Condicoesatendempadraominimo;
                retornoParecer.NomeAtendeCondicaoMinima = new Intelbras.CRM2013.Domain.Enum.Parecer().pegarNomeEnum(objeto.Condicoesatendempadraominimo.Value);
            }

            if (objeto.Canal != null)
            {
                retornoParecer.CodigoConta = objeto.Canal.Id.ToString();
                retornoParecer.NomeConta   = objeto.Canal.Name;
            }
            else
            {
                retornoParecer.CodigoConta = this.PreencherAtributoVazio("Guid").ToString();
                retornoParecer.NomeConta   = (string)this.PreencherAtributoVazio("string");
            }

            if (!String.IsNullOrEmpty(objeto.HademandaporLinhasdeProdutosnosMunicipios))
            {
                retornoParecer.DescricaoDemandaProduto = objeto.HademandaporLinhasdeProdutosnosMunicipios;
            }

            if (objeto.DispoedeSistemadeGestaoAdmeFinanceira.HasValue)
            {
                retornoParecer.PossuiSistemaGestao     = objeto.DispoedeSistemadeGestaoAdmeFinanceira;
                retornoParecer.NomePossuiSistemaGestao = new Intelbras.CRM2013.Domain.Enum.Parecer().pegarNomeEnum(objeto.DispoedeSistemadeGestaoAdmeFinanceira.Value);
            }

            if (!String.IsNullOrEmpty(objeto.ObservacoesdoGerenteNacional))
            {
                retornoParecer.ObservacaoGerente = objeto.ObservacoesdoGerenteNacional;
            }

            if (objeto.Envioudocumentacaocompleta.HasValue)
            {
                retornoParecer.EnvioDocumentacao     = objeto.Envioudocumentacaocompleta;
                retornoParecer.NomeEnvioDocumentacao = new Intelbras.CRM2013.Domain.Enum.Parecer().pegarNomeEnum(objeto.Envioudocumentacaocompleta.Value);
            }

            if (!String.IsNullOrEmpty(objeto.PorqueDefendeAberturadesseDistribuidor))
            {
                retornoParecer.DefesaAbertura = objeto.PorqueDefendeAberturadesseDistribuidor;
            }


            if (objeto.Tarefa != null)
            {
                retornoParecer.CodigoTarefa = objeto.Tarefa.Id.ToString();
                retornoParecer.NomeTarefa   = objeto.Tarefa.Name;
            }
            else
            {
                retornoParecer.CodigoTarefa = this.PreencherAtributoVazio("Guid").ToString();
                retornoParecer.NomeTarefa   = (string)this.PreencherAtributoVazio("string");
            }

            retornoParecer.PorcentagemCapitalTerceiro = objeto.CapitaldeTerceirosPct;

            if (!String.IsNullOrEmpty(objeto.Fundamentacao))
            {
                retornoParecer.FundamentacaoAdequacao = objeto.Fundamentacao;
            }

            if (objeto.PotencialdaRegiao.HasValue)
            {
                retornoParecer.ValorPotencialRegiao = objeto.PotencialdaRegiao.Value;
            }

            if (usuarioIntegracao != null)
            {
                retornoParecer.Proprietario     = usuarioIntegracao.ID.Value.ToString();
                retornoParecer.NomeProprietario = usuarioIntegracao.Nome;
                retornoParecer.TipoProprietario = "systemuser";
            }
            else
            {
                retornoParecer.Proprietario     = (string)this.PreencherAtributoVazio("guid").ToString();
                retornoParecer.NomeProprietario = (string)this.PreencherAtributoVazio("string");
                retornoParecer.TipoProprietario = (string)this.PreencherAtributoVazio("string");
            }

            if (objeto.IraatuarsomentecomprodutosIntelbras.HasValue)
            {
                retornoParecer.ExclusivoIntelbras     = objeto.IraatuarsomentecomprodutosIntelbras;
                retornoParecer.NomeExclusivoIntelbras = new Intelbras.CRM2013.Domain.Enum.Parecer().pegarNomeEnum(objeto.IraatuarsomentecomprodutosIntelbras.Value);
            }

            if (objeto.ParecerKeyAccountRepresentante.HasValue)
            {
                retornoParecer.PossuiParecerRepresentante     = objeto.ParecerKeyAccountRepresentante;
                retornoParecer.NomePossuiParecerRepresentante = new Intelbras.CRM2013.Domain.Enum.Parecer().pegarNomeEnum(objeto.ParecerKeyAccountRepresentante.Value);
            }

            if (objeto.AprovadoPeloComite.HasValue)
            {
                retornoParecer.AprovadoPeloComite     = objeto.AprovadoPeloComite;
                retornoParecer.NomeAprovadoPeloComite = new Intelbras.CRM2013.Domain.Enum.Parecer().pegarNomeEnum(objeto.AprovadoPeloComite.Value);
            }

            if (objeto.FaturamentoDiretoparaaRegiao.HasValue)
            {
                retornoParecer.ValorFaturamentoRegiao = objeto.FaturamentoDiretoparaaRegiao;
            }

            if (objeto.FichadeAvaliacaodoDistribuidor.HasValue)
            {
                retornoParecer.EnviouFichaCadastral     = objeto.FichadeAvaliacaodoDistribuidor;
                retornoParecer.NomeEnviouFichaCadastral = new Intelbras.CRM2013.Domain.Enum.Parecer().pegarNomeEnum(objeto.FichadeAvaliacaodoDistribuidor.Value);
            }

            if (!String.IsNullOrEmpty(objeto.MotivosprincipaisdeaberturadoDistribuidor))
            {
                retornoParecer.MotivoAberturaDistribuidor = objeto.MotivosprincipaisdeaberturadoDistribuidor;
            }

            if (objeto.DispostoaAtuarDentrodasNovasPraticas.HasValue)
            {
                retornoParecer.AceitaNovasPraticas     = objeto.DispostoaAtuarDentrodasNovasPraticas;
                retornoParecer.NomeAceitaNovasPraticas = new Intelbras.CRM2013.Domain.Enum.Parecer().pegarNomeEnum(objeto.DispostoaAtuarDentrodasNovasPraticas.Value);
            }

            if (!String.IsNullOrEmpty(objeto.PrevisaoLinhadeCorteMinima))
            {
                retornoParecer.PrevisaoLinhaCorte = objeto.PrevisaoLinhadeCorteMinima;
            }

            if (objeto.ParecerSetorFinanceiro.HasValue)
            {
                retornoParecer.PossuiParecerSetorFinanceiro     = objeto.ParecerSetorFinanceiro;
                retornoParecer.NomePossuiParecerSetorFinanceiro = new Intelbras.CRM2013.Domain.Enum.Parecer().pegarNomeEnum(objeto.ParecerSetorFinanceiro.Value);
            }

            if (!String.IsNullOrEmpty(objeto.TeremosConflitoscomosDistribuidores))
            {
                retornoParecer.ConflitoDistribuidores = objeto.TeremosConflitoscomosDistribuidores;
            }

            if (!String.IsNullOrEmpty(objeto.ObservacoesKeyAccountRepres))
            {
                retornoParecer.ObservacaoRepresentante = objeto.ObservacoesKeyAccountRepres;
            }

            if (objeto.QualLimitedeCreditoLiberado.HasValue)
            {
                retornoParecer.LimiteCreditoLiberado = objeto.QualLimitedeCreditoLiberado;
            }

            if (objeto.ParecerdoGerenteNacionaldeVendas.HasValue)
            {
                retornoParecer.PossuiParecerGerente     = objeto.ParecerdoGerenteNacionaldeVendas;
                retornoParecer.NomePossuiParecerGerente = new Intelbras.CRM2013.Domain.Enum.Parecer().pegarNomeEnum(objeto.ParecerdoGerenteNacionaldeVendas.Value);
            }
            // no crm nao estava campo obrigatorio
            retornoParecer.PorcentagemRegiao = objeto.FaturamentoPorcentagemRegiao;

            if (objeto.DistribuidorAprovado.HasValue)
            {
                retornoParecer.DistribuidorAprovado     = objeto.DistribuidorAprovado;
                retornoParecer.NomeDistribuidorAprovado = new Intelbras.CRM2013.Domain.Enum.Parecer().pegarNomeEnum(objeto.DistribuidorAprovado.Value);
            }

            if (objeto.AtuacomVendasemNotaFiscal.HasValue)
            {
                retornoParecer.AtuaVendaSemNota     = objeto.AtuacomVendasemNotaFiscal;
                retornoParecer.NomeAtuaVendaSemNota = new Intelbras.CRM2013.Domain.Enum.Parecer().pegarNomeEnum(objeto.AtuacomVendasemNotaFiscal.Value);
            }

            if (!String.IsNullOrEmpty(objeto.ObservacoesSetorFinanceiro))
            {
                retornoParecer.ObservacaoSetorFinaceiro = objeto.ObservacoesSetorFinanceiro;
            }

            if (objeto.DistribuidorAdequado.HasValue)
            {
                retornoParecer.DistribuidorAdequado     = objeto.DistribuidorAdequado;
                retornoParecer.NomeDistribuidorAdequado = new Intelbras.CRM2013.Domain.Enum.Parecer().pegarNomeEnum(objeto.DistribuidorAdequado.Value);
            }

            retornoParecer.PorcentagemPotencialRegiao = objeto.PotencialPorcentagem;

            if (objeto.PossuiExperienciade5anosemDistribuicao.HasValue)
            {
                retornoParecer.PossuiExperiencia     = objeto.PossuiExperienciade5anosemDistribuicao;
                retornoParecer.NomePossuiExperiencia = new Intelbras.CRM2013.Domain.Enum.Parecer().pegarNomeEnum(objeto.PossuiExperienciade5anosemDistribuicao.Value);
            }

            retornoParecer.PorcentagemFaturamento = objeto.PorcentagemFaturamento;

            if (objeto.TipodoParecer.HasValue)
            {
                retornoParecer.TipoParecer     = objeto.TipodoParecer.Value;
                retornoParecer.NomeTipoParecer = new Intelbras.CRM2013.Domain.Enum.Parecer().TipoParecerNome(objeto.TipodoParecer.Value);
            }
            else
            {
                retornoParecer.TipoParecer     = (int)this.PreencherAtributoVazio("int");
                retornoParecer.NomeTipoParecer = this.PreencherAtributoVazio("string").ToString();
            }

            return(retornoParecer);



            #endregion
        }
Example #9
0
        public Ocorrencia DefinirPropriedades(Intelbras.Message.Helper.MSG0277 xml)
        {
            var crm = new Model.Ocorrencia(this.Organizacao, this.IsOffline);

            #region Propriedades Crm->Xml

            if (!String.IsNullOrEmpty(xml.CodigoOcorrencia))
            {
                Ocorrencia ocorrencia = new Servicos.OcorrenciaService(this.Organizacao, this.IsOffline).BuscaOcorrencia(new Guid(xml.CodigoOcorrencia));
                if (ocorrencia != null)
                {
                    crm.Id = new Guid(xml.CodigoOcorrencia);
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "CodigoOcorrencia informado não existe para ser atualizado.";
                    return(crm);
                }
                if (ocorrencia.RazaoStatus == (int)Domain.Enum.StatusDaOcorrencia.Cancelada)
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Ocorrência " + ocorrencia.Numero + " está cancelada.";
                    return(crm);
                }
            }

            if (xml.StatusOcorrencia.HasValue)
            {
                crm.RazaoStatus = xml.StatusOcorrencia;
            }

            if (xml.PrioridadeOcorrencia.HasValue)
            {
                crm.PrioridadeValue = xml.PrioridadeOcorrencia;
            }

            if (xml.TipoOcorrencia.HasValue)
            {
                crm.TipoDeOcorrencia = xml.TipoOcorrencia;
            }

            if (!string.IsNullOrEmpty(xml.DefeitoAlegado))
            {
                crm.DefeitoAlegado = xml.DefeitoAlegado;
            }

            if (!string.IsNullOrEmpty(xml.AtividadeExecutada))
            {
                crm.AtividadeExecutada = xml.AtividadeExecutada;
            }

            if (!string.IsNullOrEmpty(xml.Observacao))
            {
                crm.Anexo = xml.Observacao;
            }

            if (xml.DataHoraPrevistaVisita.HasValue)
            {
                crm.DataPrevistaParaVisita = xml.DataHoraPrevistaVisita;
            }

            if (xml.DataHoraChegadaTecnico.HasValue)
            {
                crm.DataInicioTecnico = xml.DataHoraChegadaTecnico;
            }

            if (xml.DataHoraSaidaTecnico.HasValue)
            {
                crm.DataSaidaTecnico = xml.DataHoraSaidaTecnico;
            }

            if (xml.DataHoraConclusao.HasValue)
            {
                crm.DataDeConclusao = xml.DataHoraConclusao;
            }

            if (xml.DataHoraEscalacao.HasValue)
            {
                crm.DataEscalacao = xml.DataHoraEscalacao;
            }

            if (xml.TempoSLA.HasValue)
            {
                crm.DataSLA = xml.TempoSLA;
            }

            if (!string.IsNullOrEmpty(xml.OrdemServicoCliente))
            {
                crm.OsCliente = xml.OrdemServicoCliente;
            }

            if (!string.IsNullOrEmpty(xml.CodigoContato))
            {
                Contato contato = new Intelbras.CRM2013.Domain.Servicos.ContatoService(this.Organizacao, this.IsOffline).BuscaContato(new Guid(xml.CodigoContato));
                if (contato != null)
                {
                    crm.SolicitanteId = new Lookup(contato.ID.Value, "contact");
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "CodigoContato não encontrado no Crm.";
                    return(crm);
                }
            }

            if (!string.IsNullOrEmpty(xml.CodigoConta))
            {
                Conta cliente = new Intelbras.CRM2013.Domain.Servicos.ContaService(this.Organizacao, this.IsOffline).BuscaConta(new Guid(xml.CodigoConta));
                if (cliente != null)
                {
                    crm.ClienteId = new Lookup(cliente.ID.Value, "account");
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "CodigoConta não encontrado no Crm.";
                    return(crm);
                }
            }

            if (!string.IsNullOrEmpty(xml.CodigoEmpresaExecutante))
            {
                Conta empresaexecutante = new Intelbras.CRM2013.Domain.Servicos.ContaService(this.Organizacao, this.IsOffline).BuscaConta(new Guid(xml.CodigoEmpresaExecutante));
                if (empresaexecutante != null)
                {
                    crm.EmpresaExecutanteId = new Lookup(empresaexecutante.ID.Value, "");
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "CodigoEmpresaExecutante não encontrado no Crm.";
                    return(crm);
                }
            }

            if (!string.IsNullOrEmpty(xml.TecnicoResponsavel))
            {
                Contato tecnicoresponsavel = new Intelbras.CRM2013.Domain.Servicos.ContatoService(this.Organizacao, this.IsOffline).BuscaContato(new Guid(xml.TecnicoResponsavel));
                if (tecnicoresponsavel != null)
                {
                    //crm.TecnicoResponsavelId = new Lookup(tecnicoresponsavel.ID.Value, ""); Trocado para Técnico da Visita, por solicitação da Silvana - Chamado 133127
                    crm.TecnicoDaVisitaId = new Lookup(tecnicoresponsavel.ID.Value, "");
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "TecnicoResponsavel não encontrado no Crm.";
                    return(crm);
                }
            }

            if (!string.IsNullOrEmpty(xml.Logradouro))
            {
                crm.Rua = xml.Logradouro;
            }

            if (!string.IsNullOrEmpty(xml.Bairro))
            {
                crm.Bairro = xml.Bairro;
            }

            if (!string.IsNullOrEmpty(xml.NomeCidade))
            {
                crm.Cidade = xml.NomeCidade;
            }

            if (!string.IsNullOrEmpty(xml.UF))
            {
                crm.Estado = xml.UF;
            }

            if (!string.IsNullOrEmpty(xml.DescricaoFCA))
            {
                crm.DescricaoDaMensagemDeIntegracao = xml.DescricaoFCA;
            }

            if (!string.IsNullOrEmpty(xml.ResumoOcorrencia))
            {
                crm.ResumoDaOcorrencia = xml.ResumoOcorrencia;
            }

            if (!string.IsNullOrEmpty(xml.CausaFinal))
            {
                Causa causa = new Intelbras.CRM2013.Domain.Servicos.CausaService(this.Organizacao, this.IsOffline).ObterPor(new Guid(xml.CausaFinal));
                if (causa != null)
                {
                    crm.CausaFinal = new Lookup(causa.Id, "");
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "CausaFinal não encontrada no Crm.";
                    return(crm);
                }
            }

            if (!string.IsNullOrEmpty(xml.AcaoFinal))
            {
                Acao acao = new Intelbras.CRM2013.Domain.Servicos.AcaoService(this.Organizacao, this.IsOffline).ObterPor(new Guid(xml.AcaoFinal));
                if (acao != null)
                {
                    crm.AcaoFinal = new Lookup(acao.Id, "");
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "AcaoFinal não encontrada no Crm.";
                    return(crm);
                }
            }

            if (xml.StatusOcorrencia == 993520004) // Atendimento Rejeitado
            {
                Conta      conta         = new Intelbras.CRM2013.Domain.Servicos.ContaService(this.Organizacao, this.IsOffline).BuscaConta(new Guid(xml.CodigoEmpresaExecutante));
                Ocorrencia ocorrencia    = new Intelbras.CRM2013.Domain.Servicos.OcorrenciaService(this.Organizacao, this.IsOffline).BuscaOcorrencia(new Guid(xml.CodigoOcorrencia));
                string     justificativa = "";
                if (ocorrencia.EmpresaAtendimentoRejeitado == null)
                {
                    if (!string.IsNullOrEmpty(xml.Justificativa))
                    {
                        justificativa = xml.Justificativa;
                    }
                    crm.EmpresaAtendimentoRejeitado = conta.RazaoSocial + " - " + justificativa + " - " + DateTime.Now;
                }
                else
                {
                    if (!string.IsNullOrEmpty(xml.Justificativa))
                    {
                        justificativa = xml.Justificativa;
                    }
                    crm.EmpresaAtendimentoRejeitado += "\r\n" + (conta.RazaoSocial + " - " + justificativa + " - " + DateTime.Now);
                }
                crm.AddNullProperty("EmpresaExecutanteId");
            }

            #endregion

            return(crm);
        }