Пример #1
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
        }
Пример #2
0
        public void CriarParecerParaSolicitacao(Tarefa mTarefa)
        {
            if (mTarefa.TipoDeAtividade != null && mTarefa.TipoDeAtividade.Name.Contains("Parecer"))
            {
                if (mTarefa.ReferenteA == null)
                {
                    throw new ArgumentException("(CRM) Campo 'Referente a' obrigatório. Operação cancelada.");
                }

                //Só executa se referenteA for solicitacao Cadastro
                if (mTarefa.ReferenteA.Type.ToLower().Equals(SDKore.Crm.Util.Utility.GetEntityName <SolicitacaoCadastro>().ToLower()))
                {
                    if (!mTarefa.Ordem.HasValue)
                    {
                        throw new ArgumentException("(CRM) Campo 'Ordem' obrigatório.Operação cancelada.");
                    }

                    Domain.Model.SolicitacaoCadastro solicCadastro = new Intelbras.CRM2013.Domain.Servicos.SolicitacaoCadastroService(RepositoryService.NomeDaOrganizacao, RepositoryService.IsOffline, RepositoryService.Provider).ObterPor(mTarefa.ReferenteA.Id);

                    if (solicCadastro == null)
                    {
                        throw new ArgumentException("(CRM) Solicitação de Cadastro não encontrada.Operação cancelada.");
                    }

                    if (solicCadastro.Canal == null)
                    {
                        throw new ArgumentException("(CRM) Canal da Solicitação de Cadastro não informado.Operação cancelada.");
                    }

                    if (solicCadastro.Representante == null)
                    {
                        throw new ArgumentException("(CRM) Key Account/Representante não informado.Operação cancelada.");
                    }

                    if (solicCadastro.TipoDeSolicitacao == null)
                    {
                        throw new ArgumentException("(CRM) Tipo de Solicitação da solicitação de Cadastro relacionada não preenchido.Operação cancelada.");
                    }

                    ParticipantesDoProcesso partProc = new Intelbras.CRM2013.Domain.Servicos.ProcessoDeSolicitacoesService(RepositoryService).BuscarParticipanteProcesso(mTarefa.Ordem.Value, solicCadastro.TipoDeSolicitacao.Id);

                    if (partProc == null)
                    {
                        throw new ArgumentException("(CRM) Participante do Processo não encontrado.Operação cancelada.");
                    }

                    if (!partProc.TipoDoParecer.HasValue)
                    {
                        throw new ArgumentException("(CRM) Tipo do Parecer do Participante do processo não preenchido.Operação cancelada.");
                    }

                    Domain.Model.Parecer mParecer = new Parecer(RepositoryService.NomeDaOrganizacao, RepositoryService.IsOffline, RepositoryService.Provider);
                    mParecer.Tarefa = new Lookup(mTarefa.ID.Value, "");
                    mParecer.Canal  = solicCadastro.Canal;
                    mParecer.KeyAccountouRepresentante = solicCadastro.Representante;
                    mParecer.TipodoParecer             = partProc.TipoDoParecer;

                    mParecer = new Intelbras.CRM2013.Domain.Servicos.ParecerService(RepositoryService).Persistir(mParecer);

                    if (!mParecer.ID.HasValue)
                    {
                        throw new ArgumentException("(CRM) Não foi possível criar o parecer para esta atividade.Operação cancelada.");
                    }
                }
            }
        }
Пример #3
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
        }