Example #1
0
        public string ResponderExcluir()
        {
            string lIdItem       = Request["Id"];
            string lItemPaiID    = lIdItem.Split('|')[0];
            string lUsuarioID    = lIdItem.Split('|')[1];
            string lTipoDeObjeto = lIdItem.Split('|')[2];

            ReceberUsuarioRequest lRequest = new ReceberUsuarioRequest()
            {
                CodigoSessao  = this.CodigoSessao,
                CodigoUsuario = lUsuarioID
            };

            try
            {
                ReceberUsuarioResponse lResponse = ServicoSeguranca.ReceberUsuario(lRequest);

                if (lResponse.StatusResposta == MensagemResponseStatusEnum.OK)
                {
                    UsuarioInfo lUsuario = lResponse.Usuario;

                    if (lTipoDeObjeto == "Perfil")
                    {
                        lUsuario.Perfis.Remove(lItemPaiID);
                    }
                    else if (lTipoDeObjeto == "Grupo")
                    {
                        lUsuario.Grupos.Remove(lItemPaiID);
                    }

                    var lSalvarUsuarioReq = new SalvarUsuarioRequest()
                    {
                        CodigoSessao = this.CodigoSessao,
                        Usuario      = lUsuario
                    };

                    SalvarUsuarioResponse lSalvarUsuarioRes = ServicoSeguranca.SalvarUsuario(lSalvarUsuarioReq);

                    if (lSalvarUsuarioRes.StatusResposta == MensagemResponseStatusEnum.OK)
                    {
                        base.RegistrarLogExclusao(string.Concat("Excluido usuário: ", lResponse.Usuario.Email));
                        return(RetornarSucessoAjax("Usuario excluido com sucesso."));
                    }
                    else
                    {
                        return(RetornarErroAjax("Erro: " + lSalvarUsuarioRes.DescricaoResposta));
                    }
                }
                else
                {
                    return(RetornarErroAjax("Erro:" + lResponse.DescricaoResposta));
                }
            }
            catch (Exception ex)
            {
                return(RetornarErroAjax("Erro:" + ex.Message));
            }
        }
Example #2
0
        public string ResponderSalvar()
        {
            string lObjetoJson                  = Request["ObjetoJson"];
            string lTipoDeObjetoPai             = Request["TipoDeObjetoPai"];
            TransporteSegurancaItemFilho lDados = null;

            ReceberUsuarioRequest lRequest = new ReceberUsuarioRequest()
            {
                CodigoSessao = this.CodigoSessao
            };

            ReceberUsuarioResponse lResponse = null;

            try
            {
                lDados = JsonConvert.DeserializeObject <TransporteSegurancaItemFilho>(lObjetoJson);

                lRequest.CodigoUsuario = lDados.Item;

                lResponse = this.ServicoSeguranca.ReceberUsuario(lRequest);


                UsuarioInfo lUsuario = lResponse.Usuario;

                if (lTipoDeObjetoPai == "Grupo")
                {
                    lUsuario.Grupos.Add(lDados.ParentId);
                }
                else if (lTipoDeObjetoPai == "Perfil")
                {
                    lUsuario.Perfis.Add(lDados.ParentId);
                }

                SalvarUsuarioRequest lSalvarUsuarioReq = new SalvarUsuarioRequest()
                {
                    CodigoSessao = this.CodigoSessao,
                    Usuario      = lUsuario
                };

                SalvarUsuarioResponse lSalvarUsuarioRes = ServicoSeguranca.SalvarUsuario(lSalvarUsuarioReq);

                if (lSalvarUsuarioRes.StatusResposta == MensagemResponseStatusEnum.OK)
                {
                    base.RegistrarLogInclusao(string.Concat("Incluído usuário: ", lResponse.Usuario.Email));
                    return(RetornarSucessoAjax(new TransporteRetornoDeCadastro(lDados.ParentId + "|" + lDados.Item + "|" + lTipoDeObjetoPai), "Usuario associado com sucesso."));
                }
                else
                {
                    return(RetornarErroAjax(lResponse.DescricaoResposta));
                }
            }
            catch (Exception ex)
            {
                return(RetornarErroAjax(ex.Message));
            }
        }
Example #3
0
        public string ResponderCadastrar()
        {
            string lretorno    = string.Empty;
            string lObjetoJson = Request["ObjetoJson"];

            TransporteSegurancaUsuario lDadosUsuario = null;

            SalvarUsuarioResponse lResponse = null;
            SalvarUsuarioRequest  lRequest  = new SalvarUsuarioRequest();

            UsuarioInfo lUsuarioInfo = new UsuarioInfo();

            try
            {
                lDadosUsuario = JsonConvert.DeserializeObject <TransporteSegurancaUsuario>(lObjetoJson);

                lUsuarioInfo = lDadosUsuario.ToUsuarioInfo();

                lUsuarioInfo.CodigoUsuario = "0";

                lRequest.Usuario = lUsuarioInfo;

                lRequest.CodigoSessao = this.CodigoSessao;

                lResponse = ServicoSeguranca.SalvarUsuario(lRequest);

                if (lResponse.StatusResposta == MensagemResponseStatusEnum.OK)
                {
                    ReceberUsuarioResponse lREsponseUsuario = ServicoSeguranca.ReceberUsuario(
                        new ReceberUsuarioRequest()
                    {
                        CodigoSessao = this.CodigoSessao,
                        Email        = lUsuarioInfo.Email
                    });

                    if (lREsponseUsuario.StatusResposta == MensagemResponseStatusEnum.OK)
                    {
                        lretorno = RetornarSucessoAjax(new TransporteRetornoDeCadastro(lREsponseUsuario.Usuario.CodigoUsuario), "Usuário cadastrado com sucesso");
                        base.RegistrarLogInclusao(string.Concat("Usuário incluído: ", lDadosUsuario.Email));
                    }
                    else
                    {
                        lretorno = RetornarErroAjax(lREsponseUsuario.DescricaoResposta);
                    }
                }
                else
                {
                    lretorno = RetornarErroAjax(lResponse.DescricaoResposta);
                }
            }
            catch (Exception ex)
            {
                lretorno = RetornarErroAjax("Erro durante o envio do pedido para cadastrar usuário", ex);
            }
            return(lretorno);
        }
Example #4
0
        public string ResponderExcluir()
        {
            string lIdItem = Request["Id"];

            try
            {
                string lCodigoUsuario = lIdItem.Split('|')[0];
                string lCodigoGrupo   = lIdItem.Split('|')[1];

                ReceberUsuarioRequest lRequest = new ReceberUsuarioRequest()
                {
                    CodigoSessao  = this.CodigoSessao,
                    CodigoUsuario = lCodigoUsuario
                };

                ReceberUsuarioResponse lResponse = ServicoSeguranca.ReceberUsuario(lRequest);

                if (lResponse.StatusResposta == MensagemResponseStatusEnum.OK)
                {
                    lResponse.Usuario.Grupos.Remove(lCodigoGrupo);

                    MensagemResponseBase lREsponseAUx = ServicoSeguranca.SalvarUsuario(new SalvarUsuarioRequest()
                    {
                        CodigoSessao = this.CodigoSessao,
                        Usuario      = lResponse.Usuario
                    });

                    if (lREsponseAUx.StatusResposta == MensagemResponseStatusEnum.OK)
                    {
                        base.RegistrarLogExclusao();
                        return(RetornarSucessoAjax("Grupo removido com sucesso."));
                    }
                    else
                    {
                        return(RetornarErroAjax(lREsponseAUx.DescricaoResposta));
                    }
                }
            }
            catch (Exception ex)
            {
                return(RetornarErroAjax(ex.Message));
            }
            return(string.Empty);
        }
Example #5
0
        public string ResponderSalvar()
        {
            string lRetorno     = string.Empty;
            string lObjetoJson  = Request.Params["ObjetoJson"];
            string TipoDeObjeto = Request["TipoDeObjetoPai"];

            MensagemRequestBase  lRequest;
            MensagemResponseBase lResponse;

            bool lTinhaGTI   = false;
            bool lTinhaStock = false;

            try
            {
                TransporteSegurancaPermissao lDados = JsonConvert.DeserializeObject <TransporteSegurancaPermissao>(lObjetoJson);

                switch (TipoDeObjeto)
                {
                case "Usuario":
                    lRequest = new ReceberUsuarioRequest()
                    {
                        CodigoSessao  = this.CodigoSessao,
                        CodigoUsuario = lDados.ParentId
                    };
                    lResponse = this.ServicoSeguranca.ReceberUsuario((ReceberUsuarioRequest)lRequest);
                    break;

                case "Grupo":
                    lRequest = new ReceberUsuarioGrupoRequest()
                    {
                        CodigoSessao       = this.CodigoSessao,
                        CodigoUsuarioGrupo = lDados.ParentId
                    };
                    lResponse = this.ServicoSeguranca.ReceberUsuarioGrupo((ReceberUsuarioGrupoRequest)lRequest);
                    break;

                case "Perfil":
                    lRequest = new ReceberPerfilRequest()
                    {
                        CodigoSessao = this.CodigoSessao,
                        CodigoPerfil = lDados.ParentId
                    };
                    lResponse = this.ServicoSeguranca.ReceberPerfil((ReceberPerfilRequest)lRequest);
                    break;

                default:
                    return(RetornarErroAjax("Só é possível salvar permissões para grupos, usuários e perfis."));
                }

                if (lResponse.StatusResposta == MensagemResponseStatusEnum.OK)
                {
                    MensagemRequestBase  lRequestBase;
                    MensagemResponseBase lResponseBase = new MensagemResponseBase();

                    if (lResponse is ReceberUsuarioResponse)
                    {
                        PermissaoAssociadaInfo lPermissao;
                        UsuarioInfo            lUsuario = ((ReceberUsuarioResponse)lResponse).Usuario;

                        //precisa verificar todas que tinha antes pra não re-enviar o email quando uma outra permissão que não a do GTI ou Stock forem adicionadas
                        foreach (Gradual.OMS.Seguranca.Lib.PermissaoAssociadaInfo lPerm in lUsuario.Permissoes)
                        {
                            if (lPerm.CodigoPermissao.ToUpper() == ConfiguracoesValidadas.PermissaoDeAcesso_GTI.ToUpper())
                            {
                                lTinhaGTI = true;
                            }

                            if (lPerm.CodigoPermissao.ToUpper() == ConfiguracoesValidadas.PermissaoDeAcesso_Stock.ToUpper())
                            {
                                lTinhaStock = true;
                            }
                        }

                        lUsuario.Permissoes.Clear();

                        var lCount = default(int);

                        do
                        {
                            lPermissao = new PermissaoAssociadaInfo()
                            {
                                CodigoPermissao = lDados.Permissoes.Count > 0 ? lDados.Permissoes[lCount] : string.Empty,
                                Status          = PermissaoAssociadaStatusEnum.Permitido
                            };

                            lUsuario.Permissoes.Add(lPermissao);

                            lRequestBase = new SalvarUsuarioRequest()
                            {
                                CodigoSessao = this.CodigoSessao,
                                Usuario      = lUsuario
                            };

                            lResponseBase = ServicoSeguranca.SalvarUsuario((SalvarUsuarioRequest)lRequestBase);

                            if (lResponseBase.StatusResposta == MensagemResponseStatusEnum.OK)
                            {
                                base.RegistrarLogInclusao(new LogIntranetInfo()
                                {
                                    CdBovespaClienteAfetado = lUsuario.CodigoUsuario.DBToInt32(),

                                    DsObservacao = string.Format("Cód. Usuário logado: {0}; Nome do cliente: {1}; e-Mail:", base.UsuarioLogado.Id, lUsuario.Nome, lUsuario.Email),
                                });

                                if (TipoDeObjeto == "Usuario")
                                {
                                    if (!lTinhaGTI && lPermissao.CodigoPermissao.ToUpper() == ConfiguracoesValidadas.PermissaoDeAcesso_GTI.ToUpper())
                                    {
                                        EnviarEmailDePermissaoGTI(lUsuario.CodigoUsuario.DBToInt32(), "Gradual Trader Interface (GTI)");
                                    }

                                    if (!lTinhaStock && lPermissao.CodigoPermissao.ToUpper() == ConfiguracoesValidadas.PermissaoDeAcesso_Stock.ToUpper())
                                    {
                                        EnviarEmailDePermissaoGTI(lUsuario.CodigoUsuario.DBToInt32(), "Stock Market");
                                    }
                                }
                            }

                            lCount++;
                        } while (lDados.Permissoes.Count > lCount);
                    }
                    else if (lResponse is ReceberUsuarioGrupoResponse)
                    {
                        PermissaoAssociadaInfo lPermissao;
                        UsuarioGrupoInfo       lUsuarioGrupo = ((ReceberUsuarioGrupoResponse)lResponse).UsuarioGrupo;
                        foreach (string itemPermissao in lDados.Permissoes)
                        {
                            lPermissao = new PermissaoAssociadaInfo()
                            {
                                CodigoPermissao = itemPermissao,
                                Status          = PermissaoAssociadaStatusEnum.Permitido
                            };
                            lUsuarioGrupo.Permissoes.Add(lPermissao);

                            lRequestBase = new SalvarUsuarioGrupoRequest()
                            {
                                CodigoSessao = this.CodigoSessao,
                                UsuarioGrupo = lUsuarioGrupo
                            };
                            lResponseBase = ServicoSeguranca.SalvarUsuarioGrupo((SalvarUsuarioGrupoRequest)lRequestBase);
                        }
                    }
                    else
                    {
                        PermissaoAssociadaInfo lPermissao;
                        PerfilInfo             lPerfil = ((ReceberPerfilResponse)lResponse).Perfil;
                        lPerfil.Permissoes.Clear();

                        foreach (string itemPermissao in lDados.Permissoes)
                        {
                            lPermissao = new PermissaoAssociadaInfo()
                            {
                                CodigoPermissao = itemPermissao,
                                Status          = PermissaoAssociadaStatusEnum.Permitido
                            };
                            lPerfil.Permissoes.Add(lPermissao);

                            lRequestBase = new SalvarPerfilRequest()
                            {
                                CodigoSessao = this.CodigoSessao,
                                Perfil       = lPerfil
                            };
                            lResponseBase = ServicoSeguranca.SalvarPerfil((SalvarPerfilRequest)lRequestBase);
                        }
                    }

                    if (lResponseBase.StatusResposta == MensagemResponseStatusEnum.OK)
                    {
                        return(RetornarSucessoAjax("Permissão associada com sucesso."));
                    }
                    else
                    {
                        return(RetornarErroAjax(lResponseBase.DescricaoResposta));
                    }
                }
                else
                {
                    return(RetornarErroAjax(lResponse.DescricaoResposta));
                }
            }
            catch (Exception ex)
            {
                return(RetornarErroAjax(ex.Message));
            }
        }
Example #6
0
        public string ResponderAtualizar()
        {
            string lretorno    = string.Empty;
            string lObjetoJson = this.Request.Form["ObjetoJson"];

            TransporteSegurancaUsuario lDadosUsuario = null;

            SalvarUsuarioResponse lResponseSalvar = null;
            SalvarUsuarioRequest  lRequestSalvar  = new SalvarUsuarioRequest()
            {
                CodigoSessao = this.CodigoSessao
            };

            UsuarioInfo lUsuarioInfo = null;

            try
            {
                lDadosUsuario = JsonConvert.DeserializeObject <TransporteSegurancaUsuario>(lObjetoJson);

                ReceberUsuarioResponse lResponseReceber = ServicoSeguranca.ReceberUsuario(
                    new ReceberUsuarioRequest()
                {
                    CodigoSessao  = this.CodigoSessao,
                    CodigoUsuario = lDadosUsuario.Id
                });

                if (lResponseReceber.StatusResposta == MensagemResponseStatusEnum.OK)
                {
                    lUsuarioInfo       = lResponseReceber.Usuario;
                    lUsuarioInfo.Nome  = lDadosUsuario.Nome;
                    lUsuarioInfo.Email = lDadosUsuario.Email;
                    int lTipoAcesso = 0;
                    if (int.TryParse(lDadosUsuario.TipoAcesso, out lTipoAcesso))
                    {
                        lUsuarioInfo.CodigoTipoAcesso = lTipoAcesso;
                    }

                    if ((eTipoAcesso)lTipoAcesso == eTipoAcesso.Assessor)
                    {
                        int lCodAssessor = -1;
                        if (int.TryParse(lDadosUsuario.CodAssessor, out lCodAssessor))
                        {
                            lUsuarioInfo.CodigoAssessor       = lCodAssessor;
                            lUsuarioInfo.CodigosFilhoAssessor = lDadosUsuario.CodAssessorAssociado;
                        }
                        else
                        {
                            throw new Exception("Codigo de assessor inválido.");
                        }
                    }

                    lRequestSalvar.Usuario = lUsuarioInfo;

                    lResponseSalvar = ServicoSeguranca.SalvarUsuario(lRequestSalvar);

                    if (lResponseSalvar.StatusResposta == MensagemResponseStatusEnum.OK)
                    {
                        lretorno = RetornarSucessoAjax("Usuário alterado com sucesso");
                        base.RegistrarLogAlteracao(string.Concat("Usuário alterado: ", lDadosUsuario.Email));
                    }
                    else
                    {
                        lretorno = RetornarErroAjax(lResponseSalvar.DescricaoResposta);
                    }
                }
                else
                {
                    lretorno = RetornarErroAjax(lResponseReceber.DescricaoResposta);
                }
            }
            catch (Exception ex)
            {
                lretorno = RetornarErroAjax("Erro durante o envio do request para cadastrar usuário", ex);
            }

            return(lretorno);
        }
        public string Salvar()
        {
            string lObjetoJson = Request.Params["ObjetoJson"];

            try
            {
                TransporteSegurancaDadosAssociados lDados = JsonConvert.DeserializeObject <TransporteSegurancaDadosAssociados>(lObjetoJson);
                MensagemRequestBase  lRequestItem;
                MensagemRequestBase  lRequestSalvarItem;
                MensagemResponseBase lResponseItem, lResponseSalvar;
                UsuarioGrupoInfo     lUsuarioGrupo = null;
                UsuarioInfo          lUsuario      = null;

                if (lDados.EhGrupo)
                {
                    lRequestItem       = new ReceberUsuarioGrupoRequest();
                    lRequestSalvarItem = new SalvarUsuarioGrupoRequest();
                    lRequestSalvarItem.CodigoSessao = this.CodigoSessao;
                    lRequestItem.CodigoSessao       = this.CodigoSessao;

                    ((ReceberUsuarioGrupoRequest)lRequestItem).CodigoUsuarioGrupo = lDados.Grupo;
                    lResponseItem = ServicoSeguranca.ReceberUsuarioGrupo((ReceberUsuarioGrupoRequest)lRequestItem);
                }
                else if (lDados.EhUsuario)
                {
                    lRequestItem       = new ReceberUsuarioRequest();
                    lRequestSalvarItem = new SalvarUsuarioRequest();
                    lRequestSalvarItem.CodigoSessao = this.CodigoSessao;
                    lRequestItem.CodigoSessao       = this.CodigoSessao;

                    ((ReceberUsuarioRequest)lRequestItem).CodigoUsuario = lDados.Usuario;
                    lResponseItem = ServicoSeguranca.ReceberUsuario((ReceberUsuarioRequest)lRequestItem);
                }
                else
                {
                    return(RetornarErroAjax("Selecione um grupo ou usuário para associar as permissões"));
                }



                if (lResponseItem.StatusResposta != MensagemResponseStatusEnum.OK)
                {
                    return(RetornarErroAjax(lResponseItem.DescricaoResposta));
                }

                if (lResponseItem is ReceberUsuarioGrupoResponse)
                {
                    lUsuarioGrupo = ((ReceberUsuarioGrupoResponse)lResponseItem).UsuarioGrupo;
                }
                else
                {
                    lUsuario = ((ReceberUsuarioResponse)lResponseItem).Usuario;
                }

                string nomePermissao = string.Empty;

                nomePermissao = lDados.Interface.Trim() + "Consultar";
                this.AssociarPermissaoAoObjeto(lResponseItem, nomePermissao, lDados.Consultar);

                nomePermissao = lDados.Interface.Trim() + "Salvar";
                this.AssociarPermissaoAoObjeto(lResponseItem, nomePermissao, lDados.Salvar);

                nomePermissao = lDados.Interface.Trim() + "Excluir";
                this.AssociarPermissaoAoObjeto(lResponseItem, nomePermissao, lDados.Excluir);

                nomePermissao = lDados.Interface.Trim() + "Executar";
                this.AssociarPermissaoAoObjeto(lResponseItem, nomePermissao, lDados.Executar);

                if (lDados.EhGrupo)
                {
                    ((SalvarUsuarioGrupoRequest)lRequestSalvarItem).UsuarioGrupo = lUsuarioGrupo;
                    lResponseSalvar = ServicoSeguranca.SalvarUsuarioGrupo((SalvarUsuarioGrupoRequest)lRequestSalvarItem);
                }
                else
                {
                    ((SalvarUsuarioRequest)lRequestSalvarItem).Usuario = lUsuario;
                    lResponseSalvar = ServicoSeguranca.SalvarUsuario((SalvarUsuarioRequest)lRequestSalvarItem);
                }

                if (lResponseSalvar.StatusResposta == MensagemResponseStatusEnum.OK)
                {
                    base.RegistrarLogInclusao();
                    return(RetornarSucessoAjax("Itens Associados com sucesso"));
                }
                else
                {
                    return(RetornarErroAjax(lResponseSalvar.DescricaoResposta));
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex.Message, ex);
                return(RetornarErroAjax(ex.Message, ex));
            }
        }
Example #8
0
        public string ResponderExcluir()
        {
            string lIdItemPermissao = Request["Id"];

            string lItemPaiID    = lIdItemPermissao.Split('|')[0];
            string lPerfilID     = lIdItemPermissao.Split('|')[1];
            string lTipoDeObjeto = lIdItemPermissao.Split('|')[2];

            MensagemRequestBase  lRequest;
            MensagemResponseBase lResponse;

            switch (lTipoDeObjeto)
            {
            case "Usuario":
                lRequest = new ReceberUsuarioRequest()
                {
                    CodigoUsuario = lItemPaiID,
                    CodigoSessao  = this.CodigoSessao
                };
                lResponse = this.ServicoSeguranca.ReceberUsuario((ReceberUsuarioRequest)lRequest);
                break;

            case "Grupo":
                lRequest = new ReceberUsuarioGrupoRequest()
                {
                    CodigoUsuarioGrupo = lItemPaiID,
                    CodigoSessao       = this.CodigoSessao
                };
                lResponse = this.ServicoSeguranca.ReceberUsuarioGrupo((ReceberUsuarioGrupoRequest)lRequest);
                break;

            default:
                return(RetornarErroAjax("Só é permitido listar os perfis se o tipo de objeto for Usuário ou Grupo."));
            }

            if (lResponse.StatusResposta == MensagemResponseStatusEnum.OK)
            {
                MensagemRequestBase  lSalvarRequest;
                MensagemResponseBase lSalvarResponse;

                if (lResponse is ReceberUsuarioResponse)
                {
                    UsuarioInfo lUsuario = ((ReceberUsuarioResponse)lResponse).Usuario;
                    lUsuario.Perfis.Remove(lPerfilID);

                    lSalvarRequest = new SalvarUsuarioRequest()
                    {
                        CodigoSessao = this.CodigoSessao,
                        Usuario      = lUsuario
                    };
                    lSalvarResponse = ServicoSeguranca.SalvarUsuario((SalvarUsuarioRequest)lSalvarRequest);
                }
                else
                {
                    UsuarioGrupoInfo lUsuarioGrupo = ((ReceberUsuarioGrupoResponse)lResponse).UsuarioGrupo;
                    lUsuarioGrupo.Perfis.Remove(lPerfilID);

                    lSalvarRequest = new SalvarUsuarioGrupoRequest()
                    {
                        CodigoSessao = this.CodigoSessao,
                        UsuarioGrupo = lUsuarioGrupo
                    };
                    lSalvarResponse = ServicoSeguranca.SalvarUsuarioGrupo((SalvarUsuarioGrupoRequest)lSalvarRequest);
                }

                if (lSalvarResponse.StatusResposta == MensagemResponseStatusEnum.OK)
                {
                    base.RegistrarLogExclusao();
                    return(RetornarSucessoAjax("Perfil excluido com sucesso."));
                }
                else
                {
                    return(RetornarErroAjax("Erro ao excluir o perfil"));
                }
            }
            else
            {
                return(RetornarErroAjax("Erro ao excluir o perfil"));
            }
        }
Example #9
0
        public string ResponderSalvar()
        {
            string lRetorno     = string.Empty;
            string lObjetoJson  = Request.Params["ObjetoJson"];
            string TipoDeObjeto = Request["TipoDeObjetoPai"];

            TransporteSegurancaItemFilho lDados;

            MensagemRequestBase lRequest;

            MensagemResponseBase lResponse;

            try
            {
                lDados = JsonConvert.DeserializeObject <TransporteSegurancaItemFilho>(lObjetoJson);
                switch (TipoDeObjeto)
                {
                case "Usuario":
                    lRequest = new ReceberUsuarioRequest();
                    ((ReceberUsuarioRequest)lRequest).CodigoUsuario = lDados.ParentId;
                    lRequest.CodigoSessao = this.CodigoSessao;
                    lResponse             = ServicoSeguranca.ReceberUsuario((ReceberUsuarioRequest)lRequest);
                    break;

                case "Grupo":
                    lRequest = new ReceberUsuarioGrupoRequest();
                    ((ReceberUsuarioGrupoRequest)lRequest).CodigoUsuarioGrupo = lDados.ParentId;
                    lRequest.CodigoSessao = this.CodigoSessao;
                    lResponse             = ServicoSeguranca.ReceberUsuarioGrupo((ReceberUsuarioGrupoRequest)lRequest);
                    break;

                default:
                    return(RetornarErroAjax("Não é possível associar um tipo de item que não seja Usuários ou Grupos."));
                }

                if (lResponse.StatusResposta == MensagemResponseStatusEnum.OK)
                {
                    MensagemResponseBase lSalvarResponse;
                    MensagemRequestBase  lSalvarRequest = null;
                    if (lResponse is ReceberUsuarioResponse)
                    {
                        UsuarioInfo lUsuario = ((ReceberUsuarioResponse)lResponse).Usuario;
                        lUsuario.Perfis.Add(lDados.Item);
                        lSalvarRequest = new SalvarUsuarioRequest()
                        {
                            CodigoSessao = this.CodigoSessao,
                            Usuario      = lUsuario
                        };
                        lSalvarResponse = ServicoSeguranca.SalvarUsuario((SalvarUsuarioRequest)lSalvarRequest);
                    }
                    else
                    {
                        UsuarioGrupoInfo lGrupo = ((ReceberUsuarioGrupoResponse)lResponse).UsuarioGrupo;

                        lGrupo.Perfis.Add(lDados.Item);
                        lSalvarRequest = new SalvarUsuarioGrupoRequest()
                        {
                            CodigoSessao = this.CodigoSessao,
                            UsuarioGrupo = lGrupo
                        };
                        lSalvarResponse = ServicoSeguranca.SalvarUsuarioGrupo((SalvarUsuarioGrupoRequest)lSalvarRequest);
                    }

                    if (lSalvarResponse.StatusResposta == MensagemResponseStatusEnum.OK)
                    {
                        base.RegistrarLogInclusao();
                        return(RetornarSucessoAjax(new TransporteRetornoDeCadastro(lDados.ParentId + "|" + lDados.Item + "|" + TipoDeObjeto), "Dados associados com sucesso"));
                    }
                    else
                    {
                        return(RetornarErroAjax(lSalvarResponse.DescricaoResposta));
                    }
                }
                else
                {
                    return(RetornarErroAjax(lResponse.DescricaoResposta));
                }
            }
            catch (Exception ex)
            {
                return(RetornarErroAjax(ex.Message));
            }
        }