Exemple #1
0
        public async Task Add_Contato_Database()
        {
            var mockRepository = new Mock <IContatoRepository>();
            var options        = new DbContextOptionsBuilder <AgendaContext>()
                                 .UseInMemoryDatabase(databaseName: "agendadb_test")
                                 .Options;

            using (var context = new AgendaContext(options))
            {
                var service = new ContatoService(mockRepository.Object);
                _ = await service.Create(new ContatoCreateOrUpdateDto
                {
                    Canal       = "telefone",
                    Nome        = "Fulano",
                    Observacoes = "Teste",
                    Valor       = "21979075829"
                });
            }

            using (var context = new AgendaContext(options))
            {
                Assert.Equal(1, await context.Contatos.CountAsync());
                Assert.Equal("telefone", context.Contatos.SingleAsync().Result.Canal);
            }
        }
Exemple #2
0
        public string Executar(string mensagem, string numeroMensagem, Domain.Model.Usuario usuario)
        {
            usuarioIntegracao = usuario;
            var objeto = this.DefinirPropriedades(this.CarregarMensagem <Pollux.MSG0192>(mensagem));

            if (!resultadoPersistencia.Sucesso)
            {
                retorno.Add("Resultado", resultadoPersistencia);
                return(CriarMensagemRetorno <Pollux.MSG0192R1>(numeroMensagem, retorno));
            }

            objeto = new ContatoService(this.Organizacao, this.IsOffline).Persistir(objeto, objeto.CodigoRepresentante);
            if (objeto == null)
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = "Registro não encontrado!";
            }
            else
            {
                resultadoPersistencia.Sucesso  = true;
                resultadoPersistencia.Mensagem = "Integração ocorrida com sucesso";
            }

            retorno.Add("Resultado", resultadoPersistencia);
            return(CriarMensagemRetorno <Pollux.MSG0192R1>(numeroMensagem, retorno));
        }
Exemple #3
0
        //construtor
        public ContatoListViewModel()
        {
            var repo = new ContatoService();

            Items      = repo.TodosContatos.OrderBy(c => c.Nome).ToList();
            ItemsCount = repo.TodosContatos.Count;
        }
        public ActionResult Edit(Contato contato)
        {
            var contatoService = new ContatoService();

            contatoService.Update(contato);
            return(RedirectToAction("Index"));
        }
        public ContatoServiceTest()
        {
            _repositoryMock = new Mock<IContatoRepository>();
            _userMock = new Mock<IUser>();

            _service = new ContatoService(_repositoryMock.Object, _userMock.Object);
        }
Exemple #6
0
 public override Service <Contato> ObterServico()
 {
     if (_servico == null)
     {
         _servico = new ContatoService(CompromissoGerenciadorFormulario.ObterInstancia().ObterServico() as CompromissoService);
     }
     return(_servico);
 }
Exemple #7
0
        public string Executar(string mensagem, string numeroMensagem, Usuario usuario)
        {
            var objPollux = CarregarMensagem <Pollux.MSG0058>(mensagem);

            if (objPollux.IdentidadeEmissor == Enum.Sistemas.RetornaSistema(Enum.Sistemas.Sistema.Senior))
            {
                this.AtualizaUsuario(objPollux);
            }
            else
            {
                usuarioIntegracao = usuario;
                var objeto = this.DefinirPropriedades(this.CarregarMensagem <Pollux.MSG0058>(mensagem));

                if (!resultadoPersistencia.Sucesso)
                {
                    retorno.Add("Resultado", resultadoPersistencia);
                    return(CriarMensagemRetorno <Pollux.MSG0058R1>(numeroMensagem, retorno));
                }

                try
                {
                    if (objPollux.IdentidadeEmissor == Enum.Sistemas.RetornaSistema(Enum.Sistemas.Sistema.Extranet))
                    {
                        objeto.IntegrarNoPlugin = true;
                    }

                    ContatoService contatoService = new ContatoService(this.Organizacao, this.IsOffline);
                    objeto = contatoService.Persistir(objeto);
                    if (objeto == null)
                    {
                        resultadoPersistencia.Sucesso  = false;
                        resultadoPersistencia.Mensagem = "Chave não enviada e existem vários registros com o mesmo documento de identificação Integração não realizada.";
                    }
                    else
                    {
                        RelacionaContatoMarca(this.CarregarMensagem <Pollux.MSG0058>(mensagem), objeto, contatoService);
                        RelacionaContatoAreaAtuacao(this.CarregarMensagem <Pollux.MSG0058>(mensagem), objeto, contatoService);

                        resultadoPersistencia.Sucesso  = true;
                        resultadoPersistencia.Mensagem = "Integração ocorrida com sucesso";
                        retorno.Add("CodigoContato", objeto.ID.Value.ToString());
                        if (usuarioIntegracao != null)
                        {
                            retorno.Add("Proprietario", usuarioIntegracao.ID.Value.ToString());
                        }
                        retorno.Add("TipoProprietario", "systemuser");
                    }
                }
                catch (ChaveIntegracaoContatoException ex)
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = ex.Message;
                }
            }
            retorno.Add("Resultado", resultadoPersistencia);

            return(CriarMensagemRetorno <Pollux.MSG0058R1>(numeroMensagem, retorno));
        }
        // GET: Contatos/Delete/5
        public ActionResult Delete(int id)
        {
            var tela           = new ContatoViewModel();
            var contatoService = new ContatoService();

            tela.Cnt    = contatoService.Find(id);
            tela.Titulo = "Deletar contato";
            return(View(tela));
        }
        // GET: Contatos
        public ActionResult Index(string query = null)
        {
            var tela           = new ContatoViewModel();
            var contatoService = new ContatoService();

            tela.ListaContato = contatoService.PesquisaAll(query);
            tela.Titulo       = "Contatos";
            return(View(tela));
        }
Exemple #10
0
        static IContatoService SetConfig()
        {
            var context = new ContatoContext();
            IContatoRepository  repository = new ContatoRepository(context);
            IContatoApplication app        = new ContatoApplication(repository);
            IContatoService     service    = new ContatoService(app);

            return(service);
        }
        public ActionResult Create(Contato novoContato)
        {
            if (ModelState.IsValid)
            {
                var contatoService = new ContatoService();
                contatoService.Insert(novoContato);
                return(RedirectToAction("Index"));
            }

            return(View());
        }
 public ActionResult Delete(Contato contato)
 {
     try
     {
         var contatoService = new ContatoService();
         contatoService.Delete(contato);
         return(RedirectToAction("Index"));
     }
     catch
     {
         return(View());
     }
 }
        public IActionResult EnviarEmail([FromBody] ContatoEmail contatoEmail)
        {
            try
            {
                ContatoService contatoService = new ContatoService(this._context);
                contatoService.EnviarEmail(contatoEmail);

                return(Ok());
            }
            catch (Exception ex)
            {
                return(BadRequest(new { message = ex.Message }));
            }
        }
Exemple #14
0
        public ContatosViewModel()
        {
            Contatos = new ObservableCollection <Contato>();

            ExibirCommand = new Command(() =>
            {
                listaContatos = ContatoService.GetContatos(txtNome);
                Contatos.Clear();
                foreach (var item in listaContatos)
                {
                    Contatos.Add(item);
                }
            });
        }
Exemple #15
0
        public void EnviaEmailAcessoPortalCorporativo(Contato contato)
        {
            //Envia e-mail e salva como tarefa no CRM
            try
            {
                string acesso = "";
                if (contato.AcessoAoPortal.HasValue && contato.AcessoAoPortal.Value)
                {
                    Email email = new Email(OrganizationName, IsOffline);
                    email.ReferenteAId   = contato.Id;
                    email.ReferenteAType = "contact";
                    email.ReferenteAName = contato.NomeCompleto;
                    email.ReferenteA     = new Lookup(contato.Id, contato.NomeCompleto, "contact");
                    email.Assunto        = "Acesso ao Portal Corporativo Intelbras";

                    var contatoEmail = new ContatoService(OrganizationName, this.IsOffline).BuscaContato(contato.Id);

                    /*
                     * @Author José Luiz Silveira.
                     * Comentado pois o portal do fidelidade foi descontinuado.
                     *
                     * if(contato.ParticipaFidelidade.HasValue)
                     *  acesso = contato.ParticipaFidelidade.ToString();
                     */

                    //email.Mensagem = (new Domain.Servicos.RepositoryService(OrganizationName, IsOffline).ParametroGlobal.ObterPorCodigoTipoParametroGlobal(0).Valor .Configuration.ConfigurationManager.GetSettingValue("EMAIL_CORPORATIVO").Replace("#ID_CONTATO#", contato.Id.ToString()).Replace("#LOGIN_CONTATO#", contato.Login).Replace("#EMAIL_CONTATO#", contato.Email1).Replace("#PARTICIPA_FIDELIDADE#", fidelidade);
                    string corpoEmail = @"<style type=""text/css""> pre.mscrmpretag {  font-family: Tahoma, Verdana, Arial; style=""word-wrap: break-word;"" }</style>
                    <FONT size=2 face=Calibri>Prezado Usuário, <br /><br />
                    Você recebeu acesso ao Portal Corporativo Intelbras. Basta acessar o portal 
                    <STRONG><a href=""http://corporativo.intelbras.com.br/_auth/account/register.aspx?CRMID=#ID_CONTATO#&login=#LOGIN_CONTATO#&email=#EMAIL_CONTATO#&fidelidade=#PARTICIPA_FIDELIDADE#"">clicando aqui</a></STRONG> e cadastrar sua senha.
                    <br /><br />Seu login de acesso ao Portal Corporativo Intelbras é <STRONG>#LOGIN_CONTATO#</STRONG><br /><br />Obrigado,<br /><br />Intelbras S.A.</FONT>";
                    email.Mensagem = corpoEmail.Replace("#ID_CONTATO#", contato.Id.ToString()).Replace("#LOGIN_CONTATO#", contatoEmail.Login).Replace("#EMAIL_CONTATO#", contatoEmail.Email1).Replace("#PARTICIPA_FIDELIDADE#", acesso);
                    //email.De[0] = new Lookup(new Guid(SDKore.Configuration.ConfigurationManager.GetSettingValue("ID_EMAIL_CORPORATIVO")), "systemuser");
                    email.De   = new Lookup[] { new Lookup(new Guid(SDKore.Configuration.ConfigurationManager.GetSettingValue("ID_EMAIL_CORPORATIVO")), "systemuser") };
                    email.Para = new Lookup[] { new Lookup(contato.Id, "contact") };

                    email.Direcao = false;
                    email.ID      = (new CRM2013.Domain.Servicos.RepositoryService()).Email.Create(email);

                    (new CRM2013.Domain.Servicos.RepositoryService()).Email.EnviarEmail(email.ID.Value);
                }
            }
            catch (Exception ex)
            {
                SDKore.Helper.Log.Logar("emailportalcorportivolog.txt", ex.Message + ex.StackTrace);
            }
        }
Exemple #16
0
        private void ValidaIntegraPontua(Entity entityTargetUpdate, ContatoService ContatoService, Contato contatoUpdate, ref IPluginExecutionContext Context, IOrganizationService service)
        {
            ContatoService.ValidarDadosContato(contatoUpdate);

            var contato = ContatoService.BuscaContato(contatoUpdate.Id);

            if (contato != null)
            {
                if (contato.AssociadoA != null)
                {
                    //Pode estar vinculado à contatos
                    var contaAssociada = new Domain.Servicos.ContaService(Context.OrganizationName, Context.IsExecutingOffline, service).BuscaConta(contato.AssociadoA.Id);
                    if (contaAssociada != null)
                    {
                        var IntegraPontua = (new Domain.Servicos.BeneficioDoCanalService(Context.OrganizationName, Context.IsExecutingOffline, service).validaIntegraPontuaFielo(contaAssociada, null));
                        entityTargetUpdate.Attributes["itbc_integraintelbraspontua"] = IntegraPontua;
                    }
                }
                else if (entityTargetUpdate.Attributes.Contains("parentcustomerid"))
                {
                    if (entityTargetUpdate.Attributes["parentcustomerid"] != null)
                    {
                        var contaAssociada = new Domain.Servicos.ContaService(Context.OrganizationName, Context.IsExecutingOffline, service).BuscaConta(((EntityReference)entityTargetUpdate.Attributes["parentcustomerid"]).Id);
                        if (contaAssociada != null)
                        {
                            var IntegraPontua = (new Domain.Servicos.BeneficioDoCanalService(Context.OrganizationName, Context.IsExecutingOffline, service).validaIntegraPontuaFielo(contaAssociada, null));
                            entityTargetUpdate.Attributes["itbc_integraintelbraspontua"] = IntegraPontua;
                        }
                    }
                    else
                    {
                        entityTargetUpdate.Attributes["itbc_integraintelbraspontua"] = false;
                    }
                }
                else
                {
                    entityTargetUpdate.Attributes["itbc_integraintelbraspontua"] = false;
                }
            }
        }
Exemple #17
0
        public string Executar(string mensagem, string numeroMensagem, Usuario usuario)
        {
            usuarioIntegracao = usuario;
            var objeto = this.DefinirPropriedades(this.CarregarMensagem <Pollux.MSG0276>(mensagem));


            if (!resultadoPersistencia.Sucesso)
            {
                retorno.Add("Resultado", resultadoPersistencia);
                return(CriarMensagemRetorno <Pollux.MSG0276R1>(numeroMensagem, retorno));
            }

            try
            {
                objeto = new ContatoService(this.Organizacao, this.IsOffline).Persistir(objeto);
                if (objeto == null)
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Não foi possível salvar a alteração. Integração não realizada.";
                }
                else
                {
                    resultadoPersistencia.Sucesso  = true;
                    resultadoPersistencia.Mensagem = "Integração ocorrida com sucesso";
                }
            }
            catch (ChaveIntegracaoContatoException ex)
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = ex.Message;
            }

            retorno.Add("Resultado", resultadoPersistencia);

            return(CriarMensagemRetorno <Pollux.MSG0276R1>(numeroMensagem, retorno));
        }
Exemple #18
0
        public AcessoExtranetContato DefinirPropriedades(Intelbras.Message.Helper.MSG0119 xml)
        {
            if (!xml.AceitouTermoDeUso.HasValue)
            {
                throw new ArgumentException("(CRM) Identificador do AceitouTermoDeUso não encontrado!");
            }

            var crm = new AcessoExtranetContato(this.Organizacao, this.IsOffline)
            {
                IntegrarNoPlugin       = true,
                Status                 = xml.Situacao,
                Nome                   = xml.Nome,
                UsuarioAceitouTermoUso = xml.AceitouTermoDeUso,
                DataAceiteTermo        = xml.DataAceiteTermoDeUso
            };

            #region Propriedades Crm->Xml

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

            if (!string.IsNullOrEmpty(xml.TipoAcesso))
            {
                crm.TipoAcesso = new Lookup(new Guid(xml.TipoAcesso), "");
            }
            else
            {
                throw new ArgumentException("(CRM) Identificador do Tipo de Acesso não encontrado!");
            }

            if (!string.IsNullOrEmpty(xml.Contato))
            {
                Contato contato = new ContatoService(this.Organizacao, this.IsOffline).BuscaContato(new Guid(xml.Contato));
                if (contato != null)
                {
                    crm.Contato = new Lookup(contato.ID.Value, "");
                }
                else
                {
                    throw new ArgumentException("(CRM) Contato não cadastrado no Crm!");
                }
            }
            else
            {
                throw new ArgumentException("(CRM) Identificador do Contato não encontrado!");
            }

            if (!string.IsNullOrEmpty(xml.PerfilAcesso))
            {
                crm.AcessoExtranetid = new Lookup(new Guid(xml.PerfilAcesso), "");
            }
            else
            {
                throw new ArgumentException("(CRM) Identificador Perfil Acesso Extranet não encontrado!");
            }

            if (!string.IsNullOrEmpty(xml.Conta))
            {
                Conta contaObj = new Servicos.ContaService(this.Organizacao, this.IsOffline).BuscaConta(new Guid(xml.Conta));
                if (contaObj != null)
                {
                    crm.Canal = new Lookup(contaObj.ID.Value, "");
                }
                else
                {
                    throw new ArgumentException("(CRM) Conta não cadastrada no Crm!");
                }
            }



            if (xml.DataValidade.HasValue)
            {
                crm.Validade = xml.DataValidade;
            }
            else
            {
                throw new ArgumentException("(CRM) Identificador da Data Validade não encontrado!");
            }

            #endregion

            return(crm);
        }
Exemple #19
0
        protected override void Execute(IPluginExecutionContext context, IOrganizationServiceFactory serviceFactory, IOrganizationService adminService, IOrganizationService userService)
        {
            switch (context.GetMessageName())
            {
            case PluginBase.MessageName.Update:

                if (context.PostEntityImages.Contains("imagem") && context.PostEntityImages["imagem"] is Entity &&
                    context.PreEntityImages.Contains("imagem") && context.PreEntityImages["imagem"] is Entity)
                {
                    var ContatoPre = ((Entity)context.PreEntityImages["imagem"]).Parse <Contato>(context.OrganizationName, context.IsExecutingOffline, adminService);
                    var ContatoPos = ((Entity)context.PostEntityImages["imagem"]).Parse <Contato>(context.OrganizationName, context.IsExecutingOffline, adminService);

                    var contatoService = new ContatoService(context.OrganizationName, context.IsExecutingOffline, adminService);
                    var contaService   = new ContaService(context.OrganizationName, context.IsExecutingOffline, adminService);

                    //Atualização de Treinamento
                    new BeneficioDoCanalService(context.OrganizationName, context.IsExecutingOffline, adminService).MudarEmpresa(ContatoPos);

                    #region Integração

                    if (context.Depth > 1)
                    {
                        return;
                    }

                    //Valida se contato tem acesso a Extranet e está sem e-mail
                    if (string.IsNullOrEmpty(ContatoPos.Email1))
                    {
                        ValidaEmailAcessoEXtranet(ContatoPos);
                    }

                    if (!ContatoPos.IntegrarNoPlugin && contatoService.ContatoPossuiTodosCamposParaIntegracao(ContatoPos) && (bool)ContatoPos.IntegrarNoBarramento)
                    {
                        Guid idContatoEmail = new RepositoryService().AcessoExtranetContato.VerificarEmail(ContatoPos.Email1);
                        if (idContatoEmail != Guid.Empty && idContatoEmail != ContatoPos.Id)
                        {
                            throw new ArgumentException(string.Format("(CRM) Duplicidade encontrada, existe outro contato com acesso a extranet com o mesmo e-mail: [{0}].", ContatoPos.Email1));
                        }
                        string xmlResposta = contatoService.IntegracaoBarramento(ContatoPos);
                    }

                    //Caso ele mude a associação tem que resetar o perfil do Konviva
                    //E consequentemente mudar a Unidade do Konviva
                    if (ContatoPre.AssociadoA == null && ContatoPos.AssociadoA != null ||
                        (ContatoPre.AssociadoA != null && ContatoPos.AssociadoA != null &&
                         ContatoPre.AssociadoA.Id != ContatoPos.AssociadoA.Id) ||
                        ContatoPre.AssociadoA != null && ContatoPos.AssociadoA == null)
                    {
                        Guid?guidTmp = ContatoPos.AssociadoA == null ? Guid.Empty : ContatoPos.AssociadoA.Id;
                        guidTmp = guidTmp == Guid.Empty ? null : guidTmp;

                        var acessoKonvivaService         = new AcessoKonvivaService(context.OrganizationName, context.IsExecutingOffline, adminService);
                        var acessoExtranetContatoService = new AcessoExtranetContatoService(context.OrganizationName, context.IsExecutingOffline, adminService);

                        acessoKonvivaService.MudarCanal(ContatoPos, guidTmp);
                        acessoExtranetContatoService.MudarCanal(ContatoPos.ID.Value, guidTmp, ContatoPos.IntegrarNoPlugin);
                        if (ContatoPos.AssociadoA == null)
                        {
                            contatoService.AlteraTipoRelacao(ContatoPos);
                        }
                    }


                    if (context.InputParameters.Contains("Target") && context.InputParameters["Target"] is Entity)
                    {
                        var    entidade      = context.GetContextEntity();
                        Object papelCanalTmp = null;
                        if (entidade.Attributes.Contains("itbc_papelnocanal") && entidade.Attributes.TryGetValue("itbc_papelnocanal", out papelCanalTmp) && papelCanalTmp != null)
                        {
                            if (ContatoPos.AssociadoA == null || entidade.GetAttributeValue <OptionSetValue>("itbc_papelnocanal").Value == (int)Intelbras.CRM2013.Domain.Enum.Contato.PapelNoCanal.Representante)
                            {
                                var postImage = (Entity)context.PostEntityImages["imagem"];
                                postImage  = UpdateImage(postImage, entidade);
                                ContatoPos = postImage.Parse <Contato>(context.OrganizationName, context.IsExecutingOffline, adminService);

                                var           aKService     = new AcessoKonvivaService(context.OrganizationName, context.IsExecutingOffline, adminService);
                                AcessoKonviva acessoKonviva = aKService.ObterPorContato(ContatoPos.ID.Value, Domain.Enum.StateCode.Ativo);

                                if (acessoKonviva != null)
                                {
                                    acessoKonviva = new DeParaDeUnidadeDoKonvivaService(context.OrganizationName, context.IsExecutingOffline, adminService).ObterUnidadeKonvivaDeParaCom(acessoKonviva, null, ContatoPos);

                                    aKService.Persistir(acessoKonviva);
                                }
                            }
                        }
                    }

                    if ((ContatoPos.Email1 != ContatoPre.Email1) && ContatoPos.AcessoAoPortal == true && ContatoPos.Login != null)
                    {
                        if (ContatoPre.Email1 == string.Empty)
                        {
                            (new RepositoryService(context.OrganizationName, context.IsExecutingOffline)).Contato.EnviaEmailAcessoPortalCorporativo(ContatoPos);
                        }
                        (new RepositoryService(context.OrganizationName, context.IsExecutingOffline)).Contato.UpdateEmailFBA(ContatoPos);
                    }

                    //new Domain.Services.PortalFidelidade().RemoverUsuarioDoSharepoint(contato);
                    //if (contato.ParticipaFidelidade.HasValue && contato.ParticipaFidelidade.Value)
                    //{
                    //    new Domain.Services.PortalFidelidade().AdicionarAoGrupoSharePoint(contato);
                    //}

                    #endregion
                }

                break;
            }
        }
Exemple #20
0
 public HomeController()
 {
     service = new ContatoService();
 }
Exemple #21
0
 public void Setup()
 {
     _contatoRepositoryMock  = new Mock <IContatoRepository>();
     _telefoneRepositoryMock = new Mock <ITelefoneRepository>();
     _contatoService         = new ContatoService(_contatoRepositoryMock.Object, _telefoneRepositoryMock.Object);
 }
Exemple #22
0
 public ContatoController(MinhaWebApiContext context, ContatoService contatoService, TipoContatoService tipoContatoService)
 {
     _contatoService     = contatoService;
     _tipoContatoService = tipoContatoService;
     _context            = context;
 }
Exemple #23
0
 //persiste o relacionamento com Area de Atuação
 private bool RelacionaContatoAreaAtuacao(Intelbras.Message.Helper.MSG0058 xml, Contato contato, ContatoService contatoService)
 {
     if (xml.IdentidadeEmissor == Enum.Sistemas.RetornaSistema(Enum.Sistemas.Sistema.API))
     {
         if (xml.ListaAreaAtuacao != null && xml.ListaAreaAtuacao.Count > 0)
         {
             List <AreaAtuacao> listaAreaAtuacao = new List <AreaAtuacao>();
             foreach (var area in xml.ListaAreaAtuacao)
             {
                 AreaAtuacao novaArea = new Servicos.AreaAtuacaoService(this.Organizacao, this.IsOffline).ObterPorCodigo(area);
                 if (novaArea != null)
                 {
                     listaAreaAtuacao.Add(novaArea);
                 }
                 else
                 {
                     resultadoPersistencia.Sucesso = false;
                     throw new ArgumentException("Área de Atuação não cadastrado no Crm.");
                 }
             }
             try
             {
                 contatoService.PersistirAreasAtuacao(contato, listaAreaAtuacao);
             }
             catch
             {
                 throw new ArgumentException("Erro ao salvar relacionamento.");
             }
         }
     }
     return(true);
 }
Exemple #24
0
 //persiste o relacionamento com Marcas
 private bool RelacionaContatoMarca(Intelbras.Message.Helper.MSG0058 xml, Contato contato, ContatoService contatoService)
 {
     if (xml.IdentidadeEmissor == Enum.Sistemas.RetornaSistema(Enum.Sistemas.Sistema.API))
     {
         if (xml.ListaMarcas != null && xml.ListaMarcas.Count > 0)
         {
             List <Marca> listaMarcas = new List <Marca>();
             foreach (var marca in xml.ListaMarcas)
             {
                 Marca novaMarca = new Servicos.MarcaService(this.Organizacao, this.IsOffline).ObterPor(new Guid(marca));
                 if (novaMarca != null)
                 {
                     listaMarcas.Add(novaMarca);
                 }
                 else
                 {
                     resultadoPersistencia.Sucesso = false;
                     throw new ArgumentException("Fabricante não cadastrado no Crm.");
                 }
             }
             try
             {
                 contatoService.PersistirMarcas(contato, listaMarcas);
             }
             catch
             {
                 throw new ArgumentException("Erro ao salvar relacionamento.");
             }
         }
     }
     return(true);
 }
Exemple #25
0
 public AgendaController(ContatoService _Service)
 {
     _service = _Service;
 }
Exemple #26
0
        static void Main(string[] args)
        {
            ContatoService contatoService = new ContatoService(OrganizationName, IsOffline);
            ContaService   contaService   = new ContaService(OrganizationName, IsOffline);

            switch (args[0].ToUpper())
            {
            case "COLOCA_MASCARA_CONTATO":
                contatoService.ColocarMascara();
                break;

            case "COLOCA_MASCARA_CONTA":
                contaService.ColocarMascara();
                break;

            case "CNPJ_REPETIDO":
                try
                {
                    var reader = new StreamReader(File.OpenRead(@"c:\contas_mesmo_cnpjDEV2015.csv"));
                    //if (ErpConection.State == ConnectionState.Closed)
                    //    ErpConection.Open();
                    string[] linhas = reader.ReadToEnd().Split(new string[] { Environment.NewLine }, StringSplitOptions.None);
                    for (int x = 0; x < linhas.Length; x++)
                    {
                        string[] valorAtual = linhas[x].Split(';');
                        string   cnpj = valorAtual[0], id = valorAtual[1].ToUpper(), codigo = valorAtual[2];

                        string[] valorProximo = linhas[x + 1].Split(';');
                        string   cnpjProx = valorProximo[0], idProx = valorProximo[1].ToUpper(), codigoProx = valorProximo[2];

                        if (cnpj != cnpjProx)
                        {
                            Console.WriteLine("");
                            Console.WriteLine("CNPJ Triplicado: Linha " + x.ToString());
                            //Console.ReadKey();
                            continue;
                            //return x;
                        }
                        //string query = "Select [IdRevendaCRM] FROM Revendas where [cpfcnpj] = '" + cnpj + "'";
                        //SqlCommand cmd = new SqlCommand(query, ErpConection);
                        //SqlDataReader registroSellOut = cmd.ExecuteReader();
                        //if (registroSellOut.HasRows)
                        //{
                        //    registroSellOut.Read();
                        //    if (id == Convert.ToString(registroSellOut.GetValue(0)).ToUpper() && string.IsNullOrEmpty(codigo))
                        //        MergeContaCRM(new Guid(idProx), new Guid(id), false);
                        //    else //if (idProx == registroSellOut.GetString(0) && string.IsNullOrEmpty(codigoProx))
                        //        MergeContaCRM(new Guid(id), new Guid(idProx), false);
                        //}
                        //else
                        //{
                        if (string.IsNullOrEmpty(codigo))
                        {
                            MergeContaCRM(new Guid(idProx), new Guid(id), false);
                        }
                        else     //if (idProx == registroSellOut.GetString(0) && string.IsNullOrEmpty(codigoProx))
                        {
                            MergeContaCRM(new Guid(id), new Guid(idProx), true);
                        }
                        //}
                        //registroSellOut.Close();
                        //registroSellOut = null;
                        //cmd.Dispose();
                        //cmd = null;
                        x++;
                    }
                }
                catch (Exception ex)
                {
                    string messageError = SDKore.Helper.Error.Handler(ex);
                    Console.WriteLine("Erro : " + messageError);
                    GravaLog(messageError);
                    var hashcode = ex.GetHashCode();
                }

                break;
            }
        }
Exemple #27
0
 public ContatoController([FromServices] ContatoService service)
 {
     this.service = service;
 }
 public ContatoApiController(ContatoService service)
 {
     _Service = service;
 }
Exemple #29
0
        protected override void Execute(IPluginExecutionContext context, IOrganizationServiceFactory serviceFactory, IOrganizationService adminService, IOrganizationService userService)
        {
            var e = context.GetContextEntity();
            var mAcessoExtranetContato = e.Parse <Model.AcessoExtranetContato>(context.OrganizationName, context.IsExecutingOffline);
            var sAcessoExtranetContato = new AcessoExtranetContatoService(context.OrganizationName, context.IsExecutingOffline);

            switch (EnumConverter <MessageName>(context.MessageName.ToLower()))
            {
                #region Create

            case MessageName.Create:

                switch (context.GetStage())
                {
                case Stage.PreOperation:
                    sAcessoExtranetContato.PreCreate(mAcessoExtranetContato);
                    break;

                case Stage.PostOperation:
                    if (mAcessoExtranetContato.Contato == null)
                    {
                        throw new ArgumentNullException("Campo contato obrigatório.");
                    }

                    if (mAcessoExtranetContato.IntegrarNoPlugin.HasValue && !mAcessoExtranetContato.IntegrarNoPlugin.Value)
                    {
                        string xmlResposta = new Domain.Servicos.AcessoExtranetContatoService(context.OrganizationName,
                                                                                              context.IsExecutingOffline, sAcessoExtranetContato).IntegracaoBarramento(mAcessoExtranetContato);
                    }

                    var acessoKonvivaService = new AcessoKonvivaService(context.OrganizationName, context.IsExecutingOffline, userService);
                    acessoKonvivaService.CriarAcessoKonvivaPadrao(mAcessoExtranetContato.Contato.Id);
                    break;
                }
                break;

                #endregion

                #region Update

            case MessageName.Update:

                var AcessoExtranetPost = ((Entity)context.PostEntityImages["imagem"]).Parse <Domain.Model.AcessoExtranetContato>(context.OrganizationName, context.IsExecutingOffline, sAcessoExtranetContato);
                var preAcessoExtranet  = (context.PreEntityImages["imagem"]).Parse <Model.AcessoExtranetContato>(context.OrganizationName, context.IsExecutingOffline, userService);
                int dep = context.Depth;

                switch (context.GetStage())
                {
                case Stage.PostOperation:

                    if ((AcessoExtranetPost.IntegrarNoPlugin.HasValue && !AcessoExtranetPost.IntegrarNoPlugin.Value) && AcessoExtranetPost.Status == preAcessoExtranet.Status)
                    {
                        string xmlResposta = new Domain.Servicos.AcessoExtranetContatoService(context.OrganizationName,
                                                                                              context.IsExecutingOffline, sAcessoExtranetContato).IntegracaoBarramento(AcessoExtranetPost);
                    }

                    if (AcessoExtranetPost.Status.HasValue)
                    {
                        if (AcessoExtranetPost.Status != preAcessoExtranet.Status)
                        {
                            var deParaService        = new DeParaDeUnidadeDoKonvivaService(context.OrganizationName, context.IsExecutingOffline, userService);
                            var acessoKonvivaService = new AcessoKonvivaService(context.OrganizationName, context.IsExecutingOffline, userService);
                            var acessKonviva         = acessoKonvivaService.ObterPorContato(AcessoExtranetPost.Contato.Id, (Domain.Enum.StateCode)AcessoExtranetPost.Status);

                            if (AcessoExtranetPost.Status == (int)Domain.Enum.AcessoExtranetContatos.StateCode.Ativo)
                            {
                                var contato = new ContatoService(context.OrganizationName, context.IsExecutingOffline, userService).BuscaContato(AcessoExtranetPost.Contato.Id);

                                if (contato.AssociadoA != null && contato.PapelCanal != (int)Domain.Enum.Contato.PapelNoCanal.Representante)
                                {
                                    var canal = new ContaService(context.OrganizationName, context.IsExecutingOffline, userService).BuscaConta(contato.AssociadoA.Id);
                                    acessKonviva = deParaService.ObterUnidadeKonvivaDeParaCom(acessKonviva, canal, null);
                                }
                                else
                                {
                                    acessKonviva = deParaService.ObterUnidadeKonvivaDeParaCom(acessKonviva, null, contato);
                                }
                            }

                            if (acessKonviva != null)
                            {
                                if (acessKonviva.ID.HasValue)
                                {
                                    acessoKonvivaService.MudarStatus(acessKonviva.ID.Value, AcessoExtranetPost.Status.Value);
                                }
                                acessKonviva.Status = null; acessKonviva.Status = null;
                                acessoKonvivaService.Persistir(acessKonviva);
                            }
                        }
                    }

                    break;
                }
                break;

                #endregion
            }
        }
Exemple #30
0
 public ContatoController(ContatoService service)
 {
     _service = service;
 }