/// <summary> /// Insere o log da a��o como pendente para processamento. /// </summary> /// <param name="entityUsuario">Entidade do usu�rio</param> /// <param name="acao">Enumerador da a��o</param> /// <param name="senha">Senha do usu�rio (Opcional)</param> /// <returns></returns> public static bool Insert(SYS_Usuario entityUsuario, LOG_UsuarioAD.eAcao acao, TalkDBTransaction banco = null, string senha = null) { // Verifica regras salvar o log da a��o "Alterar Senha" e "Incluir Usu�rio" if (LOG_UsuarioAD.eAcao.ExcluirUsuario != acao && string.IsNullOrEmpty(senha)) { throw new ValidationException("Senha � obrigat�rio para esta a��o."); } // Verifica se usu�rio � do tipo "Usu�rio integrado com AD / Replica��o de senha". if ((byte)SYS_Usuario.eIntegracaoAD.IntegradoAD_ReplicacaoSenha != entityUsuario.usu_integracaoAD) { return(false); } LOG_UsuarioAD entityLog = new LOG_UsuarioAD() { usu_id = entityUsuario.usu_id , usa_acao = (short)acao , usa_status = (short)LOG_UsuarioAD.eStatus.Pendente , usa_dataAcao = DateTime.Now , usa_origemAcao = (short)LOG_UsuarioAD.eOrigem.Autenticador , usa_dados = GetDadosUsuarioAD(entityUsuario, senha) }; return(banco == null? Save(entityLog) : Save(entityLog, banco)); }
protected void LoadSession(SYS_Usuario entityUsuario) { __SessionWEB.__UsuarioWEB.Usuario = entityUsuario; System.Web.Configuration.PagesSection pagesSection = System.Configuration.ConfigurationManager.GetSection("system.web/pages") as System.Web.Configuration.PagesSection; if ((pagesSection != null)) { __SessionWEB.TemaPadraoLogado = CFG_TemaPadraoBO.CarregarPorNome(pagesSection.Theme); } // Armazena o cid_id referente a entidade do usuário na Session Guid ene_id = SYS_EntidadeEnderecoBO.Select_ene_idBy_ent_id(__SessionWEB.__UsuarioWEB.Usuario.ent_id); SYS_EntidadeEndereco entityEntidadeEndereco = new SYS_EntidadeEndereco { ent_id = __SessionWEB.__UsuarioWEB.Usuario.ent_id, ene_id = ene_id }; SYS_EntidadeEnderecoBO.GetEntity(entityEntidadeEndereco); END_Endereco entityEndereco = new END_Endereco { end_id = entityEntidadeEndereco.end_id }; END_EnderecoBO.GetEntity(entityEndereco); __SessionWEB._cid_id = entityEndereco.cid_id; // Armazena o nome da pessoa ou o login do usuário na Session PES_Pessoa EntityPessoa = new PES_Pessoa { pes_id = __SessionWEB.__UsuarioWEB.Usuario.pes_id }; PES_PessoaBO.GetEntity(EntityPessoa); __SessionWEB.UsuarioLogado = string.IsNullOrEmpty(EntityPessoa.pes_nome) ? __SessionWEB.__UsuarioWEB.Usuario.usu_login : EntityPessoa.pes_nome; }
private void _ExcluirUsuario(Guid usu_id) { try { //Carrega os grupos do usuário SYS_UsuarioBO.GetGruposUsuario(usu_id, _VS_Grupos, _VS_EntidadeUA); //Remove o grupo do usuário SYS_UsuarioBO.RemoveTmpGrupo(_VS_gru_id, _VS_Grupos, _VS_EntidadeUA); //Recupera os dados do usuário SYS_Usuario usu = new SYS_Usuario { usu_id = usu_id }; SYS_UsuarioBO.GetEntity(usu); usu.usu_senha = string.Empty; //Deleta o grupo do usuário if (SYS_UsuarioBO.Save(usu, _VS_Grupos, _VS_EntidadeUA, false, string.Empty, string.Empty, string.Empty, string.Empty, null)) { ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Delete, "gru_id: " + _VS_gru_id + "; usu_id: " + usu_id.ToString()); _lblMessage.Text = UtilBO.GetErroMessage(String.Format("Associação do usuário excluída com sucesso."), UtilBO.TipoMensagem.Sucesso); } //Carrega o grid de usuário _LoadGridUsuarios(); } catch (Exception ex) { ApplicationWEB._GravaErro(ex); _lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar excluir a associação do usuário.", UtilBO.TipoMensagem.Erro); } }
/// <summary> /// Realiza a sincroniza��o das senhas alteradas no AD com o Autenticador. /// </summary> /// <param name="log">Dados do usu�rio.</param> /// <returns></returns> public static bool SincronizaSenhaAlteradaAD(sLOG_UsuarioAD log) { bool processou = false; switch (log.usuarioAD.usa_acao) { case (short)LOG_UsuarioAD.eAcao.IncluirUsuario: case (short)LOG_UsuarioAD.eAcao.ExcluirUsuario: break; case (short)LOG_UsuarioAD.eAcao.AlterarSenha: { SYS_Usuario entityUsuario = log.usuario; entityUsuario.IsNew = false; entityUsuario.usu_senha = log.dadosUsuario.senha; processou = SYS_UsuarioBO.AlterarSenhaAtualizarUsuario(entityUsuario, false, true); } break; default: throw new ValidationException("Opera��o inv�lida."); } return(processou); }
public static void AutenticarUsuarioDaRespostaDoSaml(string nameIdValue) { var dadosUsuario = nameIdValue.Split('\\'); Guid entidadeId; string login; if (dadosUsuario.Length == 2) { entidadeId = Guid.Parse(dadosUsuario[0]); login = dadosUsuario[1]; var usuarioCore = new SYS_Usuario { ent_id = entidadeId, usu_login = login }; if (SYS_UsuarioBO.GetSelectBy_ent_id_usu_login(usuarioCore)) { AutenticarUsuario(usuarioCore); } else { throw new Exception("Usuário(Saml) não encontrado"); } } else { throw new Exception("Nome de Usuário inválido! Usuario(saml): " + nameIdValue); } }
/// <summary> /// Retorna os dados do log criptografado. /// </summary> /// <param name="entityUsuario">Entidade do usu�rio</param> /// <param name="senha">Senha do usu�rio (Opcional)</param> /// <returns></returns> public static string GetDadosUsuarioAD(SYS_Usuario entityUsuario, string senha = null) { LOG_DadosUsuarioAD log = new LOG_DadosUsuarioAD() { entidade = entityUsuario.ent_id , login = entityUsuario.usu_login , senha = string.IsNullOrEmpty(senha) ? string.Empty : senha }; // Remover o Namespace xsi, xsd do XML XmlSerializerNamespaces xmlNamespace = new XmlSerializerNamespaces(); xmlNamespace.Add(string.Empty, string.Empty); // Omite a declara��o do XML: <?xml version="1.0" encoding="utf-8"?> XmlWriterSettings settings = new XmlWriterSettings(); settings.OmitXmlDeclaration = true; StringBuilder sb = new StringBuilder(); using (XmlWriter writer = XmlWriter.Create(sb, settings)) { XmlSerializer serializer = new XmlSerializer(typeof(LOG_DadosUsuarioAD)); serializer.Serialize(writer, log, xmlNamespace); } SymmetricAlgorithm encript = new SymmetricAlgorithm(SymmetricAlgorithm.Tipo.TripleDES); return(encript.Encrypt(sb.ToString())); }
private void Salvar() { // Configura criptografia da senha eCriptografa criptografia = (eCriptografa)Enum.Parse(typeof(eCriptografa), Convert.ToString(__SessionWEB.__UsuarioWEB.Usuario.usu_criptografia), true); if (!Enum.IsDefined(typeof(eCriptografa), criptografia)) { criptografia = eCriptografa.SHA512; } try { if (UtilBO.EqualsSenha(__SessionWEB.__UsuarioWEB.Usuario.usu_senha, UtilBO.CriptografarSenha(txtSenhaAtual.Text, criptografia), criptografia)) { // Configura entidade SYS_Usuario SYS_Usuario entityUsuario = new SYS_Usuario { usu_id = __SessionWEB.__UsuarioWEB.Usuario.usu_id }; SYS_UsuarioBO.GetEntity(entityUsuario); if (!string.IsNullOrEmpty(txtNovaSenha.Text)) { entityUsuario.usu_senha = txtNovaSenha.Text; entityUsuario.usu_criptografia = (byte)eCriptografa.SHA512; } entityUsuario.usu_email = txtEmail.Text; // Altera os dados do usuário SYS_UsuarioBO.AlterarDadosUsuario(entityUsuario, !string.IsNullOrEmpty(txtNovaSenha.Text)); // Grava Log de sistema ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Update, "usu_id: " + entityUsuario.usu_id); Response.Redirect(ApplicationWEB._DiretorioVirtual + ApplicationWEB._PaginaLogoff, false); } else { string mensagemSenhaAtualInvalida = SYS_MensagemSistemaBO.RetornaValor(SYS_MensagemSistemaChave.MeusDadosMensagemSenhaAtualIncorreta); lblMessage.Text = UtilBO.GetErroMessage(string.IsNullOrEmpty(mensagemSenhaAtualInvalida) ? "Senha atual inválida." : mensagemSenhaAtualInvalida, UtilBO.TipoMensagem.Alerta); } } catch (DuplicateNameException ex) { lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta); } catch (ValidationException ex) { lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta); } catch (ArgumentException ex) { lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta); } catch (Exception ex) { ApplicationWEB._GravaErro(ex); lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar salvar o usuário.", UtilBO.TipoMensagem.Erro); } }
private void LoadSession(SYS_Usuario entityUsuario) { __SessionWEB.__UsuarioWEB.Usuario = entityUsuario; __SessionWEB.__UsuarioWEB.responsavel = RadioButtonList1.SelectedIndex == 1; if (__SessionWEB.__UsuarioWEB.responsavel) { SYS_Usuario entityUsuarioAluno = new SYS_Usuario { ent_id = UCComboEntidade1.Valor , usu_login = ACA_ParametroAcademicoBO.ParametroValorPorEntidade(eChaveAcademico.PREFIXO_LOGIN_ALUNO_AREA_ALUNO, __SessionWEB.__UsuarioWEB.Usuario.ent_id) + txtLogin.Text }; SYS_UsuarioBO.GetSelectBy_ent_id_usu_login(entityUsuarioAluno); __SessionWEB.__UsuarioWEB.pes_idAluno = entityUsuarioAluno.pes_id; } // Carrega grupos do usuário IList <SYS_Grupo> list = SYS_GrupoBO.GetSelectBySis_idAndUsu_id(__SessionWEB.__UsuarioWEB.Usuario.usu_id, ApplicationWEB.AreaAlunoSistemaID); // Verifica se foi carregado os grupos do usuário if (list.Count > 0) { __SessionWEB.__UsuarioWEB.Grupo = list[0]; } else { throw new ValidationException("Não foi possível atender a solicitação, nenhum grupo de usuário encontrado."); } // Armazena o cid_id referente a entidade do usuário na Session Guid ene_id = SYS_EntidadeEnderecoBO.Select_ene_idBy_ent_id(__SessionWEB.__UsuarioWEB.Usuario.ent_id); SYS_EntidadeEndereco entityEntidadeEndereco = new SYS_EntidadeEndereco { ent_id = __SessionWEB.__UsuarioWEB.Usuario.ent_id, ene_id = ene_id }; SYS_EntidadeEnderecoBO.GetEntity(entityEntidadeEndereco); END_Endereco entityEndereco = new END_Endereco { end_id = entityEntidadeEndereco.end_id }; END_EnderecoBO.GetEntity(entityEndereco); __SessionWEB._cid_id = entityEndereco.cid_id; // Armazena o nome da pessoa ou o login do usuário na Session PES_Pessoa EntityPessoa = new PES_Pessoa { pes_id = __SessionWEB.__UsuarioWEB.Usuario.pes_id }; PES_PessoaBO.GetEntity(EntityPessoa); __SessionWEB.UsuarioLogado = string.IsNullOrEmpty(EntityPessoa.pes_nome) ? __SessionWEB.__UsuarioWEB.Usuario.usu_login : EntityPessoa.pes_nome; }
/// <summary> /// Valida se já existe usuário com o email. /// </summary> /// <param name="email">Email.</param> /// <param name="usu_id">ID do usuário.</param> /// <returns></returns> public static bool ValidarEmailExistente(string email, Guid usu_id) { SYS_Usuario entityUsuario = new SYS_Usuario { usu_id = usu_id }; SYS_UsuarioBO.GetEntity(entityUsuario); entityUsuario.usu_email = email; return(string.IsNullOrEmpty(entityUsuario.usu_email) || !SYS_UsuarioBO.VerificaEmailExistente(entityUsuario)); }
/// <summary> /// Configura pop up de alteração de senha expirada. /// </summary> /// <param name="entityUsuario"></param> private void ConfigurarTelaSenhaExpirada(SYS_Usuario entityUsuario) { ScriptManager sm = ScriptManager.GetCurrent(this.Page); if (sm != null) { string script = String.Format(@"var usu_id = '{0}';", entityUsuario.usu_id); if (sm.IsInAsyncPostBack) { ScriptManager.RegisterClientScriptBlock(this, typeof(Page), "Usuario", script, true); } else { Page.ClientScript.RegisterClientScriptBlock(typeof(Page), "Usuario", script, true); } } // Mensagem de validação da senha atual. string mensagem = SYS_MensagemSistemaBO.RetornaValor(SYS_MensagemSistemaChave.MeusDadosMensagemSenhaAtualIncorreta); if (!string.IsNullOrEmpty(mensagem)) { cvSenhaAtual.ErrorMessage = mensagem; } // Mensagem de validação de confirmação da nova senha. mensagem = SYS_MensagemSistemaBO.RetornaValor(SYS_MensagemSistemaChave.MeusDadosMensagemConfirmarSenhaNaoIdentico); if (!string.IsNullOrEmpty(mensagem)) { _cpvConfirmarSenha.ErrorMessage = mensagem; } mensagem = SYS_MensagemSistemaBO.RetornaValor(SYS_MensagemSistemaChave.MeusDadosMensagemSenhaAtualSenhaNovaDiferenca); if (!string.IsNullOrEmpty(mensagem)) { CompareValidator1.ErrorMessage = mensagem; } _txtSenhaAtual.Text = string.Empty; _txtNovaSenha.Text = string.Empty; _txtConfNovaSenha.Text = string.Empty; _txtSenhaAtual.Focus(); ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Login, "Senha expirada." + entityUsuario.usu_login); ScriptManager.RegisterStartupScript(this, GetType(), "AlterarSenha", "$(document).ready(function(){ $('#divAlterarSenha').dialog('open'); }); ", true); }
/// <summary> /// Método utilizado via Web API para alteração de login de um usuário /// </summary> /// <param name="data">Parametros de entrada: Id Entidade, login antigo, login novo</param> /// <param name="entityUsuarioAPI">Usuário da API usado para gravar log de ação</param> public static void UpdateLogin(AlterarLoginEntradaDTO data, CFG_UsuarioAPI entityUsuarioAPI) { if (data.ent_id == Guid.Empty || string.IsNullOrWhiteSpace(data.usu_login_antigo) || string.IsNullOrWhiteSpace(data.usu_login_novo)) { throw new ValidationException("Todos os campos são obrigatórios."); } SYS_Usuario entity = new SYS_Usuario { ent_id = data.ent_id, usu_login = data.usu_login_antigo }; SYS_UsuarioBO.GetSelectBy_ent_id_usu_login(entity); if (!entity.IsNew) { //Validação de usuário padrão do sistema if (entity.usu_situacao == (byte)SYS_UsuarioBO.eSituacao.Padrao_Sistema) { throw new ValidationException("Não é possível alterar dados do usuário padrão do sistema."); } entity.usu_login = data.usu_login_novo; } else { throw new ValidationException("Usuário não existe."); } SYS_UsuarioBO.Save(entity); #region [ Log de ação] LOG_UsuarioAPIBO.Save ( new LOG_UsuarioAPI { usu_id = entity.usu_id , uap_id = entityUsuarioAPI.uap_id , lua_dataHora = DateTime.Now , lua_acao = (byte)LOG_UsuarioAPIBO.eAcao.AlteracaoLogin } ); #endregion }
public static void AutenticarUsuario(SYS_Usuario usuarioCore, SYS_Grupo entityGrupo = null) { var authenticationManager = HttpContext.Current.GetOwinContext().Authentication; var claims = GetClaims(usuarioCore, entityGrupo); var identity = new ClaimsIdentity(claims, DefaultAuthenticationTypes.ApplicationCookie); authenticationManager.SignIn(new AuthenticationProperties() { AllowRefresh = true, IsPersistent = false, ExpiresUtc = ConfigCustomAutenticadorCookieAuthentication.ExpiresUtc }, identity); }
public static SYS_Usuario GetEntity(Guid entidadeId, string Login) { SYS_UsuarioDAO usuarioDao = new SYS_UsuarioDAO(); var usuario = new SYS_Usuario { ent_id = entidadeId, usu_login = Login }; if (usuarioDao.CarregarBy_ent_id_usu_login(usuario)) { return(usuario); } else { return(null); } }
public static SYS_Usuario GetEntity(Guid entidadeId, Guid usuarioId) { SYS_UsuarioDAO dal = new SYS_UsuarioDAO(); var entidade = new SYS_Usuario { ent_id = entidadeId, usu_id = usuarioId }; if (dal.Carregar(entidade)) { return(entidade); } else { return(null); } }
/// <summary> /// M�todo que salva a senha do usu�rio no hist�rico. /// </summary> /// <param name="entityUsuario">Entidade do usu�rio (senha criptografada).</param> /// <param name="banco">Transa��o.</param> /// <returns></returns> public static bool Salvar(SYS_Usuario entityUsuario, TalkDBTransaction banco) { SYS_UsuarioSenhaHistoricoDAO dao = new SYS_UsuarioSenhaHistoricoDAO { _Banco = banco }; SYS_UsuarioSenhaHistorico entity = new SYS_UsuarioSenhaHistorico { usu_id = entityUsuario.usu_id , ush_senha = entityUsuario.usu_senha , ush_criptografia = entityUsuario.usu_criptografia }; return(dao.Salvar(entity)); }
public static bool ValidarSenhaAtual(string senhaAtual, Guid usu_id) { SYS_Usuario entityUsuario = new SYS_Usuario { usu_id = usu_id }; SYS_UsuarioBO.GetEntity(entityUsuario); eCriptografa criptografia = (eCriptografa)Enum.Parse(typeof(eCriptografa), Convert.ToString(entityUsuario.usu_criptografia), true); if (!Enum.IsDefined(typeof(eCriptografa), criptografia)) { criptografia = eCriptografa.SHA512; } return(UtilBO.EqualsSenha(entityUsuario.usu_senha, UtilBO.CriptografarSenha(senhaAtual, criptografia), criptografia)); }
public static SYS_Usuario ObterUsuarioDoClaimsIdentity() { SYS_Usuario usuarioCore = null; var identity = HttpContext.Current.User.Identity as ClaimsIdentity; if (identity != null) { var usuarioIdClaim = identity.FindFirst(ClaimTypes.NameIdentifier); usuarioCore = new SYS_Usuario { usu_id = Guid.Parse(usuarioIdClaim.Value) }; SYS_UsuarioBO.GetEntity(usuarioCore); } return(usuarioCore); }
private void AlterarSenhaEsqueci(Guid usu_id, byte usu_situacao, byte usu_integracaoAD) { if (ValidarAlterarSenhaEsqueci()) { try { if (usu_situacao == (byte)SYS_UsuarioBO.eSituacao.Ativo || usu_situacao == (byte)SYS_UsuarioBO.eSituacao.Senha_Expirada) { SYS_Usuario entityUsuario = new SYS_Usuario { usu_id = usu_id }; SYS_UsuarioBO.GetEntity(entityUsuario); entityUsuario.usu_situacao = 1; entityUsuario.usu_senha = txtNovaSenhaEsqueci.Text; entityUsuario.usu_dataAlteracao = DateTime.Now; SYS_UsuarioBO.AlterarSenhaAtualizarUsuario(entityUsuario, usu_integracaoAD == (byte)SYS_UsuarioBO.eIntegracaoAD.IntegradoADReplicacaoSenha); ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Login, "Senha alterada com sucesso."); _lblMessage.Text = UtilBO.GetErroMessage("Senha alterada com sucesso.", UtilBO.TipoMensagem.Sucesso); } else if (usu_situacao == (byte)SYS_UsuarioBO.eSituacao.Padrao_Sistema) { ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Login, "Erro na alteração de senha. Usuário padrão."); _lblMessage.Text = UtilBO.GetErroMessage("Usuário padrão.", UtilBO.TipoMensagem.Alerta); } else { ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Login, "Erro na alteração de senha. Usuário bloqueado."); _lblMessage.Text = UtilBO.GetErroMessage("Usuário bloqueado.", UtilBO.TipoMensagem.Alerta); } } catch (DuplicateNameException ex) { _lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta); } catch (Exception ex) { ApplicationWEB._GravaErro(ex); _lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar alterar a senha do usuário.", UtilBO.TipoMensagem.Erro); } } }
private void EnviaNovaSenhaEmail(Guid usu_id, byte usu_situacao, string pes_nome, byte usu_integracaoAD) { try { if (usu_situacao == (byte)SYS_UsuarioBO.eSituacao.Ativo || usu_situacao == (byte)SYS_UsuarioBO.eSituacao.Senha_Expirada) { SYS_Usuario usu = new SYS_Usuario { usu_id = usu_id }; SYS_UsuarioBO.GetEntity(usu); usu.usu_situacao = (byte)SYS_UsuarioBO.eSituacao.Senha_Expirada; SYS_UsuarioBO.Save(usu, pes_nome, __SessionWEB.TituloGeral, ApplicationWEB._EmailHost, ApplicationWEB._EmailSuporte, ApplicationWEB.EmailRemetente); ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Login, "Senha enviada para o e-mail com sucesso."); string mensagemSucesso = SYS_MensagemSistemaBO.RetornaValor(SYS_MensagemSistemaChave.LoginMensagemSenhaEmailEnviadaSucesso); _lblMessage.Text = UtilBO.GetErroMessage(string.IsNullOrEmpty(mensagemSucesso) ? "Senha enviada para o e-mail com sucesso." : mensagemSucesso, UtilBO.TipoMensagem.Sucesso); } else if (usu_situacao == (byte)SYS_UsuarioBO.eSituacao.Padrao_Sistema) { ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Login, "Erro no envio de senha. Usuário padrão."); _lblMessage.Text = UtilBO.GetErroMessage("Usuário padrão.", UtilBO.TipoMensagem.Alerta); } else { ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Login, "Erro no envio de senha. Usuário bloqueado."); _lblMessage.Text = UtilBO.GetErroMessage("Usuário bloqueado.", UtilBO.TipoMensagem.Alerta); } } catch (DuplicateNameException ex) { _lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta); ScriptManager.RegisterClientScriptBlock(this, GetType(), "EsqueciSenhaErro", "$('#divEsqueciSenha').dialog('close');", true); } catch (Exception ex) { ApplicationWEB._GravaErro(ex); _lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar enviar e-mail com a senha para o usuário.", UtilBO.TipoMensagem.Erro); ScriptManager.RegisterClientScriptBlock(this, GetType(), "EsqueciSenhaErro", "$('#divEsqueciSenha').dialog('close');", true); } }
private static IList <Claim> GetClaims(SYS_Usuario usuarioCore, SYS_Grupo entityGrupo = null) { string roles = ""; string grupoId = null; if (entityGrupo != null) { SYS_Sistema entitySistema = new SYS_Sistema { sis_id = entityGrupo.sis_id }; grupoId = entityGrupo.gru_id.ToString(); SYS_SistemaBO.GetEntity(entitySistema); if (entitySistema.sis_tipoAutenticacao == 1) { SYS_Visao entityVisao = new SYS_Visao { vis_id = entityGrupo.vis_id }; SYS_VisaoBO.GetEntity(entityVisao); roles = entityVisao.vis_nome; } } string name = FormatarUserNameDoCookie(usuarioCore.ent_id.ToString(), usuarioCore.usu_login, grupoId); var claims = new List <Claim>(); claims.Add(new Claim(ClaimTypes.NameIdentifier, usuarioCore.usu_id.ToString())); claims.Add(new Claim(ClaimTypes.Name, name)); claims.Add(new Claim(ClaimTypes.Email, usuarioCore.usu_email ?? string.Empty)); claims.Add(new Claim(ClaimTypes.Role, roles)); claims.Add(new Claim(AutenticadorCustomClaimTypes.EntidadeId, usuarioCore.ent_id.ToString())); claims.Add(new Claim(AutenticadorCustomClaimTypes.GrupoId, grupoId ?? string.Empty)); return(claims); }
/// <summary> /// Validação de senha de acordo com suas senhas anteriores. /// </summary> /// <param name="novaSenha">Nova senha.</param> /// <param name="usu_id">ID do usuário.</param> /// <returns></returns> public static bool ValidarHistoricoSenha(string novaSenha, Guid usu_id) { if (SYS_ParametroBO.ParametroValorBooleano(SYS_ParametroBO.eChave.SALVAR_HISTORICO_SENHA_USUARIO)) { SYS_Usuario entityUsuario = new SYS_Usuario { usu_id = usu_id }; SYS_UsuarioBO.GetEntity(entityUsuario); List <SYS_UsuarioSenhaHistorico> listaHistoricoSenhas = SYS_UsuarioSenhaHistoricoBO.SelecionaUltimasSenhas(entityUsuario.usu_id); // Configura criptografia da senha eCriptografa criptografia = (eCriptografa)Enum.Parse(typeof(eCriptografa), Convert.ToString(entityUsuario.usu_criptografia), true); if (!Enum.IsDefined(typeof(eCriptografa), criptografia)) { criptografia = eCriptografa.SHA512; } return(!listaHistoricoSenhas.Any(p => p.ush_senha == UtilBO.CriptografarSenha(novaSenha, criptografia) && p.ush_criptografia == entityUsuario.usu_criptografia)); } return(true); }
protected void _dgvUsuario_RowCommand(object sender, GridViewCommandEventArgs e) { if (e.CommandName == "Deletar") { try { int index = int.Parse(e.CommandArgument.ToString()); Guid usu_id = new Guid(_dgvUsuario.DataKeys[index].Value.ToString()); //DELETA O VINCULO DE USUARIO COM USUARIOLOGINPROVIDER (CASO EXISTA) SYS_UsuarioLoginProviderBO.DeleteBy_usu_id(usu_id); SYS_Usuario entity = new SYS_Usuario { usu_id = usu_id }; SYS_UsuarioBO.GetEntity(entity); if (SYS_UsuarioBO.Delete(entity, null)) { _dgvUsuario.PageIndex = 0; _dgvUsuario.DataBind(); ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Delete, "usu_id: " + usu_id); _lblMessage.Text = UtilBO.GetErroMessage("Usuário excluído com sucesso.", UtilBO.TipoMensagem.Sucesso); } else { _lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar excluir o usuário.", UtilBO.TipoMensagem.Erro); } } catch (Exception ex) { ApplicationWEB._GravaErro(ex); _lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Erro); } } }
public HttpResponseMessage UserAuthorized([FromBody] UsuarioEntradaDTO data) { try { if (data == null || data.usu_login == null) { throw new ValidationException("É necessário informar o(s) parâmetro(s)."); } SYS_Usuario usuario = new SYS_Usuario { usu_login = data.usu_login, usu_senha = data.senha, ent_id = data.ent_id }; LoginStatus status = SYS_UsuarioBO.LoginWEB(usuario, false); bool retorno = false; if (status == LoginStatus.Sucesso) { retorno = true; } return(Request.CreateResponse(HttpStatusCode.OK, retorno)); } catch (ValidationException ex) { Util.GravarErro(ex); return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message)); } catch (Exception ex) { Util.GravarErro(ex); return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex.Message)); } }
public HttpResponseMessage UpdatePassword([FromBody] RedefinirSenhaEntradaDTO data) { RedefinirSenhaSaidaDTO retorno = new RedefinirSenhaSaidaDTO(); try { SYS_Usuario entity = new SYS_Usuario { ent_id = data.ent_id , usu_login = data.usu_login }; SYS_UsuarioBO.GetSelectBy_ent_id_usu_login(entity); // Verifica se o id do usuário enviado existe na base de dados. if (entity.IsNew) { retorno.Message = "Usuário não encontrado."; retorno.statusCode = (int)HttpStatusCode.NotFound; return(Request.CreateResponse <RedefinirSenhaSaidaDTO>(HttpStatusCode.NotFound, retorno)); } // Configura criptografia da senha eCriptografa criptografia = (eCriptografa)Enum.Parse(typeof(eCriptografa), Convert.ToString(entity.usu_criptografia), true); if (!Enum.IsDefined(typeof(eCriptografa), criptografia)) { criptografia = eCriptografa.TripleDES; } if (!UtilBO.EqualsSenha(entity.usu_senha, data.senhaAtual, criptografia)) { retorno.Message = "Senha atual inválida."; retorno.statusCode = (int)HttpStatusCode.Unauthorized; return(Request.CreateResponse <RedefinirSenhaSaidaDTO>(HttpStatusCode.Unauthorized, retorno)); } if (data.senhaAtual.Equals(data.senhaNova)) { retorno.Message = "Senha nova deve ser diferente da atual."; retorno.statusCode = (int)HttpStatusCode.BadRequest; return(Request.CreateResponse <RedefinirSenhaSaidaDTO>(HttpStatusCode.BadRequest, retorno)); } entity.usu_senha = data.senhaNova; SYS_UsuarioBO.AlterarSenhaUsuario(entity, false); retorno.Message = "Senha alterada com sucesso."; retorno.statusCode = (int)HttpStatusCode.OK; CFG_UsuarioAPI entityUsuarioAPI = CFG_UsuarioAPIBO.SelecionaPorUsername(data.uap_username); LOG_UsuarioAPIBO.Save ( new LOG_UsuarioAPI { usu_id = entity.usu_id , uap_id = entityUsuarioAPI.uap_id , lua_dataHora = DateTime.Now , lua_acao = (byte)LOG_UsuarioAPIBO.eAcao.AlteracaoSenha } ); return(Request.CreateResponse <RedefinirSenhaSaidaDTO>(HttpStatusCode.OK, retorno)); } catch (Exception ex) { retorno.Message = ex.Message; retorno.statusCode = (int)HttpStatusCode.InternalServerError; Util.GravarErro(ex); return(Request.CreateResponse <RedefinirSenhaSaidaDTO>(HttpStatusCode.InternalServerError, retorno)); } }
/// <summary> /// Método utilizado via Web API para deleção de um usuário /// </summary> /// <param name="data">Parametros de entrada: Id Entidade, login, senha</param> /// <param name="entityUsuarioAPI">Usuário da API usado para gravar log de ação</param> public static HttpResponseMessage Delete(DeletarUsuarioDTO data, CFG_UsuarioAPI entityUsuarioAPI, HttpRequestMessage request) { try { //Verifica se todos os dados vieram if (data.ent_id == Guid.Empty || string.IsNullOrWhiteSpace(data.usu_login) || string.IsNullOrWhiteSpace(data.senha)) { return(request.CreateErrorResponse(HttpStatusCode.BadRequest, "Todos os campos são obrigatórios.")); } SYS_Usuario entity = new SYS_Usuario { ent_id = data.ent_id, usu_login = data.usu_login }; SYS_UsuarioBO.GetSelectBy_ent_id_usu_login(entity); //Validação de usuário padrão do sistema if (entity.usu_situacao == (byte)SYS_UsuarioBO.eSituacao.Padrao_Sistema) { return(request.CreateErrorResponse(HttpStatusCode.BadRequest, "Não é possível alterar um usuário padrão do sistema.")); } // Verifica se o id do usuário enviado existe na base de dados. if (entity.IsNew) { return(request.CreateErrorResponse(HttpStatusCode.NotFound, "Usuário não encontrado.")); } var senhaDescriptografada = new SymmetricAlgorithm(SymmetricAlgorithm.Tipo.TripleDES).Decrypt(entity.usu_senha); if (data.senha != senhaDescriptografada) { return(request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Não foi possível excluir usuário. Acesso negado.")); } SYS_UsuarioBO.Delete(entity, null); #region [ Log de ação] LOG_UsuarioAPIBO.Save ( new LOG_UsuarioAPI { usu_id = entity.usu_id , uap_id = entityUsuarioAPI.uap_id , lua_dataHora = DateTime.Now , lua_acao = (byte)LOG_UsuarioAPIBO.eAcao.DelecaoUsuario } ); #endregion return(request.CreateResponse(HttpStatusCode.OK, "Usuário excluído com sucesso.")); } catch (Exception ex) { Util.GravarErro(ex); return(request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex.Message)); } }
/// <summary> /// Método utilizado via Web API para criação de Usuários /// OBSERVACAO: Este metodo faz uma busca por nome, data de nascimento e CPF /// para tentar vincular uma pessoa já existente com estes dados ao usuario /// que esta sendo criado, sendo que apenas nome e data de nascimento são requeridos. /// </summary> /// <param name="data">Parametros de entrada: Id Entidade, Id Grupo, ID Usuario, Nome, /// CPF, Data de nascimento, E-mail, Senha</param> /// <param name="entityUsuarioAPI">Usuário da API usado para gravar log de ação</param> public static void Create(UsuarioEntradaDTO data, CFG_UsuarioAPI entityUsuarioAPI) { #region [ Validação de campos obrigatórios ] if (data.ent_id == Guid.Empty) { throw new ValidationException("Id da entidade é obrigatório."); } if (string.IsNullOrWhiteSpace(data.usu_login)) { throw new ValidationException("Login do usuário é obrigatório."); } if (data.gru_id.Count() == 0) { throw new ValidationException("Ao menos um grupo deve ser informado."); } if (data.dataNascimento == new DateTime()) { throw new ValidationException("Data de nascimento é obrigatória."); } if (data.sexo != null && data.sexo > 2) { throw new ValidationException("Para o sexo informe: 1 - masculino ou 2 - feminino"); } #endregion SYS_Usuario entity = new SYS_Usuario { ent_id = data.ent_id , usu_login = data.usu_login }; SYS_UsuarioBO.GetSelectBy_ent_id_usu_login(entity); // Verifica se o id do usuário enviado existe na base de dados. if (entity.IsNew) { Guid? tdo_id = null; bool savePessoaReturn = false; PES_Pessoa entityPessoa = null; //Se não for informado nome e data de nascimento não cria a pessoa if (!string.IsNullOrWhiteSpace(data.nome) && data.dataNascimento != null) { #region [Validações CPF] //Se CPF existir, realiza validações if (!string.IsNullOrWhiteSpace(data.CPF)) { if (UtilBO._ValidaCPF(data.CPF)) { //Recupera o tipo de documento CPF, utilizado para recuperar a pessoa string tipoDocCPF = SYS_ParametroBO.ParametroValor(SYS_ParametroBO.eChave.TIPO_DOCUMENTACAO_CPF); if (!string.IsNullOrEmpty(tipoDocCPF)) { tdo_id = Guid.Parse(tipoDocCPF); } } else { throw new ValidationException("CPF inválido."); } } #endregion //Recupera a pessoa entityPessoa = PES_PessoaBO.SelecionaPorNomeNascimentoDocumento(data.nome, data.dataNascimento, tdo_id, data.CPF); //Se pessoa não existir, faz o cadastro com as informações básicas if (entityPessoa.pes_id == Guid.Empty) { #region [Cria Pessoa] //Adiciona valores na entidade de pessoa entityPessoa.pes_id = Guid.Empty; entityPessoa.pes_nome = data.nome; entityPessoa.pes_sexo = data.sexo; entityPessoa.pes_nome_abreviado = string.Empty; entityPessoa.pai_idNacionalidade = Guid.Empty; entityPessoa.pes_naturalizado = false; entityPessoa.cid_idNaturalidade = Guid.Empty; entityPessoa.pes_dataNascimento = (String.IsNullOrEmpty(data.dataNascimento.ToString()) ? new DateTime() : Convert.ToDateTime(data.dataNascimento.ToString())); entityPessoa.pes_racaCor = Convert.ToByte(null); entityPessoa.pes_idFiliacaoPai = Guid.Empty; entityPessoa.pes_idFiliacaoMae = Guid.Empty; entityPessoa.tes_id = Guid.Empty; entityPessoa.pes_estadoCivil = Convert.ToByte(null); entityPessoa.pes_situacao = 1; PES_PessoaDeficiencia entityPessoaDeficiencia = new PES_PessoaDeficiencia { pes_id = Guid.Empty, tde_id = Guid.Empty, IsNew = true }; savePessoaReturn = PES_PessoaBO.Save(entityPessoa , entityPessoaDeficiencia , new DataTable() //dtEndereco , new DataTable() //dtContato , RetornaDocumento(data.CPF) //dtDocumento , new DataTable() //dtCertidao , Guid.Empty //pai_idAntigo , Guid.Empty //cid_idAntigo , Guid.Empty //pes_idPaiAntigo , Guid.Empty //pes_idMaeAntigo , Guid.Empty //tes_idAntigo , Guid.Empty //tde_idAntigo , null //arquivosPermitidos , 0 //tamanhoMaximoKB , null //entFoto , false //ExcluirImagemAtual ); #endregion } } #region [ Cria usuário ] entity.ent_id = data.ent_id; entity.usu_id = Guid.Empty; entity.usu_login = data.usu_login; entity.usu_email = string.IsNullOrEmpty(data.email) ? string.Empty : data.email; entity.usu_senha = string.IsNullOrEmpty(data.senha) ? string.Empty : data.senha; //Se foi recuperado ou criado uma pessoa, vincula o pes_id if (entityPessoa != null) { entity.pes_id = entityPessoa.pes_id; } entity.usu_criptografia = Convert.ToByte(eCriptografa.TripleDES); entity.usu_situacao = 1; entity.usu_dataAlteracao = DateTime.Now; entity.usu_dataCriacao = DateTime.Now; entity.usu_dominio = string.Empty; entity.usu_integracaoAD = (byte)SYS_UsuarioBO.eIntegracaoAD.NaoIntegrado; entity.IsNew = true; SortedDictionary <Guid, SYS_UsuarioBO.TmpGrupos> grupos = new SortedDictionary <Guid, SYS_UsuarioBO.TmpGrupos>(); foreach (Guid gruId in data.gru_id) { SYS_UsuarioBO.AddTmpGrupo(gruId, grupos, 1); } SortedDictionary <Guid, List <SYS_UsuarioBO.TmpEntidadeUA> > entidadeUA = new SortedDictionary <Guid, List <SYS_UsuarioBO.TmpEntidadeUA> >(); SYS_UsuarioBO.Save(entity, grupos, entidadeUA, false, data.nome, string.Empty, string.Empty, string.Empty, null); #endregion } else { throw new ValidationException("Usuário já existe."); } #region [ Log de ação] LOG_UsuarioAPIBO.Save ( new LOG_UsuarioAPI { usu_id = entity.usu_id , uap_id = entityUsuarioAPI.uap_id , lua_dataHora = DateTime.Now , lua_acao = (byte)LOG_UsuarioAPIBO.eAcao.CriacaoUsuario } ); #endregion }
/// <summary> /// Método utilizado via Web API para alteração de Usuários /// </summary> /// <param name="data">Parametros de entrada: Id Entidade, Id Grupo, ID Usuario, Nome, /// CPF, Data de nascimento, E-mail, Senha</param> /// <param name="entityUsuarioAPI">Usuário da API usado para gravar log de ação</param> public static void Update(UsuarioEntradaDTO data, CFG_UsuarioAPI entityUsuarioAPI) { #region [ Validação de campos obrigatórios ] if (data.ent_id == Guid.Empty || string.IsNullOrWhiteSpace(data.usu_login)) { throw new ValidationException("Id da entidade e login do usuário são obrigatórios."); } #endregion SYS_Usuario entity = new SYS_Usuario { ent_id = data.ent_id , usu_login = data.usu_login }; SYS_UsuarioBO.GetSelectBy_ent_id_usu_login(entity); PES_Pessoa entityPessoa = null; if (!entity.IsNew) { //Validação de usuário padrão do sistema if (entity.usu_situacao == (byte)SYS_UsuarioBO.eSituacao.Padrao_Sistema) { throw new ValidationException("Não é possível alterar dados do usuário padrão do sistema."); } //Se o usuário recuperado não possuir pessoa, pula os passos de update de Pessoa if (entity.pes_id != Guid.Empty) { #region [Pessoa] entityPessoa = new PES_Pessoa { pes_id = entity.pes_id }; PES_PessoaBO.GetEntity(entityPessoa); if (!string.IsNullOrWhiteSpace(data.nome) && entityPessoa.pes_nome.ToLower() != data.nome.ToLower()) { entityPessoa.pes_nome = data.nome; } if (data.dataNascimento != new DateTime() && entityPessoa.pes_dataNascimento != data.dataNascimento) { entityPessoa.pes_dataNascimento = data.dataNascimento; } if (data.sexo == 1 || data.sexo == 2) { entityPessoa.pes_sexo = data.sexo; } entityPessoa.pes_dataAlteracao = DateTime.Now; #region [Validações CPF] Guid?tdo_id = null; bool criarCPF = false; //Recupera os documentos da pessoa DataTable documentosPessoa = PES_PessoaDocumentoBO.GetSelect(entityPessoa.pes_id, false, 1, 1); //Se CPF existir, realiza validações if (!string.IsNullOrWhiteSpace(data.CPF)) { if (UtilBO._ValidaCPF(data.CPF)) { //Recupera o tipo de documento CPF string tipoDocCPF = SYS_ParametroBO.ParametroValor(SYS_ParametroBO.eChave.TIPO_DOCUMENTACAO_CPF); if (!string.IsNullOrEmpty(tipoDocCPF)) { tdo_id = Guid.Parse(tipoDocCPF); criarCPF = true; } } else { throw new ValidationException("CPF inválido."); } if (documentosPessoa.Rows.Count > 0) { //Recupera o indice da linha que contém o documento do tipo CPF var indiceRowCPF = documentosPessoa.AsEnumerable() .Select((row, index) => new { row, index }) .Where(item => item.row.Field <Guid>("tdo_id") == tdo_id) .Select(item => item.index).ToArray(); //Se a pessoa possui um documento do tipo CPF, verifica se precisa alterar if (indiceRowCPF.Count() > 0) { if (documentosPessoa.Rows[indiceRowCPF[0]]["numero"].ToString() != data.CPF) { documentosPessoa.Rows[indiceRowCPF[0]]["numero"] = data.CPF; } } else { //Pessoa ainda não possue CPF, nesse caso cria usando o datatable recuperado DataRow rowDoc = documentosPessoa.NewRow(); rowDoc["tdo_id"] = tdo_id; rowDoc["unf_idEmissao"] = Guid.Empty.ToString(); rowDoc["unf_idAntigo"] = Guid.Empty.ToString(); rowDoc["numero"] = data.CPF; rowDoc["dataemissao"] = string.Empty; rowDoc["orgaoemissao"] = string.Empty; rowDoc["info"] = string.Empty; documentosPessoa.Rows.Add(rowDoc); } criarCPF = false; } if (criarCPF) { if (tdo_id != null) { //Cria o datatable na estrutura necessária com o CPF enviado documentosPessoa = RetornaDocumento(data.CPF); } } } #endregion PES_PessoaDeficiencia entityPessoaDeficiencia = new PES_PessoaDeficiencia { pes_id = Guid.Empty, tde_id = Guid.Empty, IsNew = true }; PES_PessoaBO.Save(entityPessoa , entityPessoaDeficiencia , new DataTable() //dtEndereco , new DataTable() //dtContato , documentosPessoa //dtDocumento , new DataTable() //dtCertidao , Guid.Empty //pai_idAntigo , Guid.Empty //cid_idAntigo , Guid.Empty //pes_idPaiAntigo , Guid.Empty //pes_idMaeAntigo , Guid.Empty //tes_idAntigo , Guid.Empty //tde_idAntigo , null //arquivosPermitidos , 0 //tamanhoMaximoKB , null //entFoto , false //ExcluirImagemAtual ); #endregion } #region [Usuário] //entity.usu_login = data.usu_login; if (!string.IsNullOrWhiteSpace(data.email) && entity.usu_email != data.email) { entity.usu_email = data.email; } //Se não vier senha, seta a senha da entidade como vazia para o método do sistema //não encriptar novamente o que já estava encriptado if (string.IsNullOrWhiteSpace(data.senha)) { entity.usu_senha = string.Empty; } else { entity.usu_senha = data.senha; } if (entityPessoa != null) { entity.pes_id = entityPessoa.pes_id; } entity.usu_criptografia = Convert.ToByte(eCriptografa.TripleDES); entity.usu_dataAlteracao = DateTime.Now; SortedDictionary <Guid, SYS_UsuarioBO.TmpGrupos> grupos = new SortedDictionary <Guid, SYS_UsuarioBO.TmpGrupos>(); SortedDictionary <Guid, List <SYS_UsuarioBO.TmpEntidadeUA> > entidadeUA = new SortedDictionary <Guid, List <SYS_UsuarioBO.TmpEntidadeUA> >(); //Se vier grupos cria a lista com base nesses grupos if (data.gru_id.Count() > 0) { foreach (Guid gruId in data.gru_id) { SYS_UsuarioBO.AddTmpGrupo(gruId, grupos, 1); } } else { //Senão, recupera os grupos do usuário para enviar ao método salvar SYS_UsuarioBO.GetGruposUsuario(entity.usu_id, grupos, entidadeUA); } SYS_UsuarioBO.Save(entity, grupos, entidadeUA, false, data.nome, string.Empty, string.Empty, string.Empty, null); #endregion } else { throw new ValidationException("Usuário não existe."); } #region [ Log de ação] LOG_UsuarioAPIBO.Save ( new LOG_UsuarioAPI { usu_id = entity.usu_id , uap_id = entityUsuarioAPI.uap_id , lua_dataHora = DateTime.Now , lua_acao = (byte)LOG_UsuarioAPIBO.eAcao.AlteracaoUsuario } ); #endregion }
/// <summary> /// Método utilizado via Web API para inclusão de novos grupos de usuário /// </summary> /// <param name="entityUsuarioAPI">Usuário da API usado para gravar log de ação</param> public static void AssociateUserGroup(Guid usu_id, AssociarUsuarioGrupoEntradaDTO data, CFG_UsuarioAPI entityUsuarioAPI) { #region [ Validação de campos obrigatórios ] if (data == null || data.usergroup == null || data.usergroup.Count(p => p.gru_id != Guid.Empty) == 0) { throw new ValidationException("Obrigatório no mínimo um Id de grupo do usuário."); } #endregion SYS_Usuario entity = SYS_UsuarioBO.GetEntity(new SYS_Usuario { usu_id = usu_id }); entity.usu_senha = string.Empty; entity.usu_dataAlteracao = DateTime.Now; if (!entity.IsNew) { // Validação de usuário padrão do sistema if (entity.usu_situacao == (byte)SYS_UsuarioBO.eSituacao.Padrao_Sistema) { throw new ValidationException("Não é possível alterar dados do usuário padrão do sistema."); } SortedDictionary <Guid, SYS_UsuarioBO.TmpGrupos> grupos = new SortedDictionary <Guid, SYS_UsuarioBO.TmpGrupos>(); SortedDictionary <Guid, List <SYS_UsuarioBO.TmpEntidadeUA> > grupoUas = new SortedDictionary <Guid, List <SYS_UsuarioBO.TmpEntidadeUA> >(); SYS_UsuarioBO.GetGruposUsuario(entity.usu_id, grupos, grupoUas); foreach (UsuarioGrupoDTO grupo in data.usergroup) { // Adiciona o grupo if (grupo.gru_id != Guid.Empty) { SYS_UsuarioBO.AddTmpGrupo(grupo.gru_id, grupos, 1); // Adiciona a unidade administrativa ao grupo, caso necessário if (grupo.uad_id != Guid.Empty) { List <SYS_UsuarioBO.TmpEntidadeUA> ltEntidadeUA = grupoUas.ContainsKey(grupo.gru_id) ? grupoUas[grupo.gru_id] : new List <SYS_UsuarioBO.TmpEntidadeUA>(); SYS_UsuarioBO.AddTmpEntidadeUA(grupo.gru_id, entity.ent_id, grupo.uad_id, ltEntidadeUA); } } } SYS_UsuarioBO.Save(entity, grupos, grupoUas, false, string.Empty, string.Empty, string.Empty, string.Empty, null); } else { throw new ValidationException("Usuário não existe."); } #region [ Log de ação] LOG_UsuarioAPIBO.Save ( new LOG_UsuarioAPI { usu_id = entity.usu_id , uap_id = entityUsuarioAPI.uap_id , lua_dataHora = DateTime.Now , lua_acao = (byte)LOG_UsuarioAPIBO.eAcao.AssociacaoUsuarioGrupo } ); #endregion }
public static bool Save ( PES_Pessoa entityPessoa , PES_PessoaDeficiencia entityPessoaDeficiencia , DataTable dtEndereco , DataTable dtContato , DataTable dtDocumento , PES_CertidaoCivil entityCertidaoCivil , Guid pai_idAntigo , Guid cid_idAntigo , StructColaboradorFiliacao PaiAntigo , StructColaboradorFiliacao MaeAntigo , Guid tes_idAntigo , Guid tde_idAntigo , RHU_Colaborador entityColaborador , DataTable dtCargoFuncao , DataTable dtCargoDisciplina , bool bSalvarUsuario , bool bSalvarLive , SYS_Usuario entityUsuario , bool bEnviaEmail , string sNomePortal , string sHost , string sEmailSuporte , Guid ent_idUsuario , ACA_Docente entityDocente , string[] arquivosPermitidos , int tamanhoMaximoKB , CFG_Arquivo entFoto , bool ExcluirImagemAtual ) { TalkDBTransaction bancoCore = new PES_PessoaDAO()._Banco.CopyThisInstance(); TalkDBTransaction bancoGestao = new ACA_DocenteDAO()._Banco.CopyThisInstance(); bancoCore.Open(IsolationLevel.ReadCommitted); bancoGestao.Open(IsolationLevel.ReadCommitted); try { //Limpa o cache do docente CacheManager.Factory.Remove(string.Format(ModelCache.DOCENTE_POR_ENTIDADE_PESSOA_MODEL_KEY, entityColaborador.ent_id, entityPessoa.pes_id)); //Verifica se os dados da pessoa serão sempre salvos em maiúsculo. string sSalvarMaiusculo = SYS_ParametroBO.ParametroValor(SYS_ParametroBO.eChave.SALVAR_SEMPRE_MAIUSCULO); bool Salvar_Sempre_Maiusculo = !string.IsNullOrEmpty(sSalvarMaiusculo) && Convert.ToBoolean(sSalvarMaiusculo); var y = from DataRow dr in dtCargoFuncao.Rows where dr.RowState == DataRowState.Deleted select dr; if (dtCargoFuncao.Rows.Count == 0 || y.Count() == dtCargoFuncao.Rows.Count) { throw new ValidationException("É obrigatório o preenchimento de pelo menos um vínculo de trabalho do docente."); } string sPadraoUsuarioDocente = ACA_ParametroAcademicoBO.ParametroValorPorEntidade(eChaveAcademico.PAR_GRUPO_PERFIL_DOCENTE, ent_idUsuario); //Integraçao como o live UserLive entityUserLive = null; if (bSalvarLive) { entityUserLive = new UserLive(eTipoUserLive.Docente); //Cria o usuário docente para integraçao como o live ManageUserLive live = new ManageUserLive(); entityUserLive.email = entityUsuario.usu_email; entityUserLive.senha = entityUsuario.usu_senha; //Caso seja alteração carrega as turma //TODO: Fazer método específico para buscar apenas pelo doc_id. DataTable dtTurmas = entityDocente.doc_id > 0 ? TUR_TurmaBO.GetSelectBy_Pesquisa_TodosTipos (Guid.Empty, Guid.Empty, Guid.Empty, Guid.Empty, 0, 0, 0, 0, 0, 0, "", entityDocente.doc_id, false) : new DataTable(); //Obtendo CPF do docente string tdo_id = SYS_ParametroBO.ParametroValor(SYS_ParametroBO.eChave.TIPO_DOCUMENTACAO_CPF); var x = from DataRow dr in dtDocumento.Rows where dr.RowState != DataRowState.Deleted && dr["tdo_id"].ToString() == tdo_id select dr["numero"].ToString(); //Carrega primeira matricula ativa associada ao cargo de docente do colaborador var mat = from DataRow dr in dtCargoFuncao.Rows where dr.RowState != DataRowState.Deleted && dr["situacao_id"].ToString() == "1" select dr["coc_matricula"].ToString(); //Carrega os tipos de disciplinas var tipo_dis = from DataRow dr in dtCargoDisciplina.Rows where dr.RowState != DataRowState.Deleted select dr["tds_id"].ToString(); DataTable dtTipoDisciplinas = tipo_dis.Count() > 0 ? ACA_TipoDisciplinaBO.SelecionaTipoDisciplinaPorTipoDisciplina (Convert.ToInt32(tipo_dis.First()), bancoGestao, ent_idUsuario) : new DataTable(); if (x.Count() > 0) { DadosUserDocente dadosDocente = new DadosUserDocente { nome = entityPessoa.pes_nome , CPF = x.First() , matricula = mat.Count() > 0 ? mat.First() : string.Empty , turma = dtTurmas.Rows.Count > 0 ? dtTurmas.Rows[0]["tur_cod_desc_nome"].ToString() : string.Empty , serie = dtTurmas.Rows.Count > 0 ? dtTurmas.Rows[0]["crp_descricao"].ToString() : string.Empty , disciplina = dtTipoDisciplinas.Rows.Count > 0 ? dtTipoDisciplinas.Rows[0]["tds_nome"].ToString() : string.Empty }; entityUserLive.dadosUserDocente = dadosDocente; } else { if (!live.VerificarContaEmailExistente(entityUserLive)) { throw new ArgumentException("CPF é um documento obrigatório, para integração do docente com live."); } } } RHU_ColaboradorBO.Save(entityPessoa , entityPessoaDeficiencia , dtEndereco , dtContato , dtDocumento , entityCertidaoCivil , pai_idAntigo , cid_idAntigo , PaiAntigo , MaeAntigo , tes_idAntigo , tde_idAntigo , entityColaborador , dtCargoFuncao , dtCargoDisciplina , bSalvarUsuario , bSalvarLive , entityUsuario , entityUserLive , sPadraoUsuarioDocente , bEnviaEmail , sNomePortal , sHost , sEmailSuporte , ent_idUsuario , bancoCore , bancoGestao , arquivosPermitidos , tamanhoMaximoKB , entFoto , ExcluirImagemAtual); entityDocente.col_id = entityColaborador.col_id; if (entityDocente.Validate()) { Save(entityDocente, bancoGestao); } else { throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entityDocente)); } return(true); } catch (Exception err) { bancoGestao.Close(err); bancoCore.Close(err); throw; } finally { bancoGestao.Close(); bancoCore.Close(); } }
public static string FormatarUserNameDoCookie(SYS_Usuario usuarioCore) { return(FormatarUserNameDoCookie(usuarioCore.ent_id.ToString(), usuarioCore.usu_login)); }