public void AtualizarUnidadeKonvivaDosContatosDoCanal(Guid?canalId)
        {
            if (canalId.HasValue)
            {
                var           aKService       = new AcessoKonvivaService(RepositoryService);
                Conta         canal           = RepositoryService.Conta.Retrieve(canalId.Value);
                AcessoKonviva acessoKonviva   = new AcessoKonviva(RepositoryService.NomeDaOrganizacao, RepositoryService.IsOffline);
                var           listaDeContatos = RepositoryService.Contato.ListarPor(canal);

                var novo = new AcessoKonviva(RepositoryService.NomeDaOrganizacao, RepositoryService.IsOffline);
                novo = ObterUnidadeKonvivaDeParaCom(acessoKonviva, canal, null);
                foreach (var contato in listaDeContatos)
                {
                    acessoKonviva = aKService.ObterPorContato(contato.ID.Value, Enum.StateCode.Ativo);
                    acessoKonviva.UnidadeKonviva       = novo.UnidadeKonviva;
                    acessoKonviva.DeParaUnidadeKonviva = novo.DeParaUnidadeKonviva;
                    aKService.Persistir(acessoKonviva);
                }
            }
        }
Example #2
0
        protected override void Execute(IPluginExecutionContext context, IOrganizationServiceFactory serviceFactory, IOrganizationService adminService, IOrganizationService userService)
        {
            //if (context.GetStage() != Stage.PreValidation)
            //    return;
            var e        = context.GetContextEntity();
            var _service = new Intelbras.CRM2013.Domain.Servicos.AcessoKonvivaService(context.OrganizationName, context.IsExecutingOffline, null);

            switch (Util.Utilitario.ConverterEnum <Domain.Enum.Plugin.MessageName>(context.MessageName))
            {
            case Domain.Enum.Plugin.MessageName.Create:
            {
                Domain.Model.AcessoKonviva mAcessoKonviva = e.Parse <Domain.Model.AcessoKonviva>(context.OrganizationName, context.IsExecutingOffline, userService);

                //Adicionado verificação preEvent pra poder mudar o nome da entidade
                if (mAcessoKonviva.Contato == null)
                {
                    throw new ArgumentException("(CRM) Contato obrigatório");
                }

                Domain.Model.Contato mContato = new Intelbras.CRM2013.Domain.Servicos.ContatoService(context.OrganizationName, context.IsExecutingOffline).BuscaContato(mAcessoKonviva.Contato.Id);

                if (mContato == null)
                {
                    throw new ArgumentException("(CRM) Contato não encontrado");
                }

                if (!new AcessoExtranetContatoService(context.OrganizationName, context.IsExecutingOffline, userService).ValidarExistenciaAcessoExtranet(mAcessoKonviva.Contato.Id))
                {
                    throw new ApplicationException("(CRM) Contato não possui acesso na extranet");
                }

                if (!_service.ValidarTipoAcesso(mAcessoKonviva))
                {
                    throw new ApplicationException("(CRM) Usuários sem vínculo com a Intelbras não podem criar Acesso no Konviva com Perfil Administrador");
                }

                //Já validamos se o contato existe mesmo na service com o método validarTipoAcesso
                e.Attributes["itbc_name"] = mContato.NomeCompleto;

                if (!e.Attributes.Contains("itbc_acaocrm") || e.GetAttributeValue <bool>("itbc_acaocrm") == false)
                {
                    context.SharedVariables.Add("IntegraKonviva", true);
                }
                e.Attributes.Remove("itbc_acaocrm");

                break;
            }

            case Domain.Enum.Plugin.MessageName.Update:
            {
                Guid contatoId;
                //Domain.Model.AcessoKonviva acessoKonvivaImagem = ((Entity)context.PreEntityImages["imagem"]).Parse<Domain.Model.AcessoKonviva>(context.OrganizationName, context.IsExecutingOffline, context.UserId);
                Domain.Model.AcessoKonviva acessoKonvivaImagem  = ((Entity)context.GetContextEntityMerge("imagem")).Parse <Domain.Model.AcessoKonviva>(context.OrganizationName, context.IsExecutingOffline, context.UserId);
                Domain.Model.AcessoKonviva mAcessoKonvivaUpdate = e.Parse <Domain.Model.AcessoKonviva>(context.OrganizationName, context.IsExecutingOffline, userService);

                //Adicionado verificação preEvent pra poder mudar o nome da entidade
                if (acessoKonvivaImagem.Contato == null && mAcessoKonvivaUpdate.Contato == null)
                {
                    throw new ArgumentException("(CRM) Contato obrigatório");
                }

                if (mAcessoKonvivaUpdate.Contato == null)
                {
                    contatoId = acessoKonvivaImagem.Contato.Id;
                }
                else
                {
                    contatoId = mAcessoKonvivaUpdate.Contato.Id;
                }

                Domain.Model.Contato mContatoUpdate = new Intelbras.CRM2013.Domain.Servicos.ContatoService(context.OrganizationName, context.IsExecutingOffline).BuscaContato(contatoId);

                if (mContatoUpdate == null)
                {
                    throw new ArgumentException("(CRM) Contato não encontrado");
                }

                if (!_service.ValidarTipoAcesso(acessoKonvivaImagem))
                {
                    throw new ApplicationException("(CRM) Usuários sem vínculo com a Intelbras não podem criar Acesso no Konviva com Perfil Administrador");
                }

                //Já validamos se o contato existe mesmo na service validarTipoAcesso
                e.Attributes["itbc_name"] = mContatoUpdate.NomeCompleto;

                // SharedVariable para a Integração
                if (!e.Attributes.Contains("itbc_acaocrm") || e.GetAttributeValue <bool>("itbc_acaocrm") == false)
                {
                    context.SharedVariables.Add("IntegraKonviva", true);
                }
                e.Attributes.Remove("itbc_acaocrm");
                break;
            }
            }
        }
        public List <KeyValuePair <ExecuteMultipleResponse, ExecuteMultipleRequest> > AtualizarAcessosKonvivaInconsistentes(DateTime dataInicial)
        {
            var           listaDePara               = RepositoryService.DeParaDeUnidadeDoKonviva.ListarPor(new Dictionary <string, object>(), dataInicial, false);
            var           listaAcessosKonviva       = new List <AcessoKonviva>();
            var           listaAcessosKonvivaPadrao = new List <AcessoKonviva>();
            var           novaListaKonvivaUpdate    = new List <AcessoKonviva>();
            var           novaListaKonvivaAdd       = new List <AcessoKonviva>();
            var           retornosPaginacao         = new List <KeyValuePair <ExecuteMultipleResponse, ExecuteMultipleRequest> >();
            List <object> deParaUnidadesKonviva     = new List <object>();

            if (listaDePara.Count > 0)
            {
                foreach (var item in listaDePara)
                {
                    deParaUnidadesKonviva.Add(item.ID.Value);
                }
                listaAcessosKonviva = RepositoryService.AcessoKonviva.ListarPor(deParaUnidadesKonviva.ToArray());

                var aKService = new AcessoKonvivaService(RepositoryService);
                #region Correção de entradas de Acesso do Konviva que tiveram critérios alterados

                foreach (var item in listaAcessosKonviva)
                {
                    if (item.Contato != null)
                    {
                        var           contato = new ContatoService(RepositoryService).BuscaContato(item.Contato.Id);
                        AcessoKonviva akTmp   = this.ProcessaAcessoKonviva(contato, item);
                        if (akTmp != null)
                        {
                            novaListaKonvivaUpdate.Add(akTmp);
                        }
                    }
                }
                #endregion

                #region Correção de entradas de acesso padrão do Konviva, avaliando se algum dos novos critérios se enquadram

                listaDePara = RepositoryService.DeParaDeUnidadeDoKonviva.ListarPor(new Dictionary <string, object>(), dataInicial, true);
                foreach (var item in listaDePara)
                {
                    var listaMudar = new List <AcessoKonviva>();
                    if (item.Categoria != null || item.TipoDeRelacao == null)
                    {
                        listaMudar = RepositoryService.AcessoKonviva.ListarPorCriterioDeParaContas(item, this.unidadeKonvivaPadrao.Value);
                    }
                    else
                    {
                        if (item.PapelNoCanalIntelbras.HasValue)
                        {
                            listaMudar = RepositoryService.AcessoKonviva.ListarPorCriterioDeParaContatos(item, this.unidadeKonvivaPadrao.Value);
                        }
                    }

                    foreach (var itemMudar in listaMudar)
                    {
                        itemMudar.UnidadeKonviva       = item.UnidadeDoKonviva;
                        itemMudar.DeParaUnidadeKonviva = new Lookup(item.ID.Value, "");
                        novaListaKonvivaUpdate.Add(itemMudar);
                    }
                }
                #endregion

                List <AcessoKonviva> acessosTimeout = new List <AcessoKonviva>();
                for (int i = 0; i < novaListaKonvivaUpdate.Count; i += 10)
                {
                    try
                    {
                        retornosPaginacao.Add(RepositoryService.AcessoKonviva.ExecuteMultiple(novaListaKonvivaUpdate.Skip(i).Take(10).ToList(), new UpdateRequest()));
                    }
                    catch (TimeoutException e)
                    {
                        Console.WriteLine("Erro de Timeout nos seguintes GUIDs:");
                        foreach (var itemTimeout in novaListaKonvivaUpdate.Skip(i).Take(10).ToList())
                        {
                            Console.WriteLine(itemTimeout.ID.ToString());
                        }
                        Console.WriteLine("------------------------------------");
                        acessosTimeout.AddRange(novaListaKonvivaUpdate.Skip(i).Take(10).ToList());
                    }
                }
                for (int i = 0; i < acessosTimeout.Count; i += 10)
                {
                    try
                    {
                        retornosPaginacao.Add(RepositoryService.AcessoKonviva.ExecuteMultiple(acessosTimeout.Skip(i).Take(10).ToList(), new UpdateRequest()));
                    }
                    catch (TimeoutException e)
                    {
                        Console.WriteLine("Erro de Timeout nos seguintes GUIDs (2a):");
                        foreach (var itemTimeout in novaListaKonvivaUpdate.Skip(i).Take(10).ToList())
                        {
                            Console.WriteLine(itemTimeout.ID.ToString());
                        }
                        Console.WriteLine("------------------------------------");
                    }
                }
            }

            return(retornosPaginacao);
        }