Esempio n. 1
0
        protected override void Execute(IPluginExecutionContext context, IOrganizationServiceFactory serviceFactory, IOrganizationService adminService, IOrganizationService userService)
        {
            var e = context.GetContextEntity();

            Intelbras.CRM2013.Domain.Model.UnidadeKonviva mUnidadeKonviva   = e.Parse <Intelbras.CRM2013.Domain.Model.UnidadeKonviva>(context.OrganizationName, context.IsExecutingOffline);
            DeParaDeUnidadeDoKonvivaService ServiceDeParaDeUnidadeDoKonviva = new DeParaDeUnidadeDoKonvivaService(context.OrganizationName, context.IsExecutingOffline, adminService);

            var targetEntity = (Entity)context.InputParameters["Target"];

            switch (EnumConverter <MessageName>(context.MessageName.ToLower()))
            {
            case MessageName.SetStateDynamicEntity:

                var returnQuery = ServiceDeParaDeUnidadeDoKonviva.ObterDeParaPorUnidade(mUnidadeKonviva);


                if (returnQuery.Count > 0)
                {
                    throw new ApplicationException("Erro: Não é possivel inativar essa unidade. Ela esta sendo utilizada em um mapeamento de De Para de Acesso ao Konviva");
                }

                break;
            }
        }
Esempio n. 2
0
        static int Main(string[] args)
        {
            try
            {
                Console.WriteLine("Início Processamento de atualização dos Acessos Konviva.");
                Console.WriteLine(DateTime.Now.ToString());

                string opcao          = "REVALIDARMAPEAMENTO";
                int    quantidadeDias = 7;

                if (args != null && args.Length > 1)
                {
                    opcao          = args[0];
                    quantidadeDias = int.Parse(args[1]);
                }

                string errorString = "";

                switch (opcao)
                {
                case "REVALIDARMAPEAMENTO":
                    var dataInicial = DateTime.Today.AddDays(-quantidadeDias);
                    var conjuntoRespostaRequisicao = new DeParaDeUnidadeDoKonvivaService(OrganizationName, false).AtualizarAcessosKonvivaInconsistentes(dataInicial);

                    StringBuilder sb = new StringBuilder();

                    foreach (var conjuntoRespostaRequisicaoItem in conjuntoRespostaRequisicao)
                    {
                        if (conjuntoRespostaRequisicaoItem.Key != null && conjuntoRespostaRequisicaoItem.Value != null)
                        {
                            var conRespLocal = conjuntoRespostaRequisicaoItem;
                            if (conRespLocal.Key.IsFaulted)
                            {
                                foreach (var item in conRespLocal.Key.Responses)
                                {
                                    if (item.Fault != null)
                                    {
                                        sb.AppendLine(string.Format("Ocorreu uma falha enquanto {1} request era processada, no índice {0} da colecao da requisicao com a seguinte menssagem: {2}", item.RequestIndex + 1,
                                                                    conRespLocal.Value.Requests[item.RequestIndex].RequestName,
                                                                    item.Fault.Message));
                                    }
                                }
                            }
                        }
                    }

                    if (!sb.ToString().Equals(""))
                    {
                        if (sb.ToString().Length < 32000)
                        {
                            SDKore.Helper.Error.Create(sb.ToString(), System.Diagnostics.EventLogEntryType.Error);
                        }
                        else
                        {
                            using (StreamWriter w = File.AppendText("c:\\LogErrosKonviva" + DateTime.Now.Year.ToString() + DateTime.Now.Month.ToString() + DateTime.Now.Day.ToString() + DateTime.Now.Hour.ToString() + ".txt"))
                            {
                                w.WriteLine(sb.ToString());
                            }
                        }
                        errorString = sb.ToString();
                    }


                    break;
                }

                Console.WriteLine(errorString);
                Console.WriteLine(DateTime.Now.ToString());
                Console.WriteLine("Finalizando processo!");
                return(0);
            }
            catch (Exception ex)
            {
                string messageError = SDKore.Helper.Error.Handler(ex);
                Console.WriteLine("Erro : " + messageError);
                return(ex.GetHashCode());
            }
        }
Esempio n. 3
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;
            }
        }
Esempio n. 4
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
            }
        }