public bool add(UsuarioDTO user)
{
using (var context = getContext())
{
try
{
Usuario usuario = new Usuario();
usuario.Nombre = user.Nombre;
usuario.InicialesNombre = user.InicialesNombre;
usuario.Email = user.Email;
usuario.Cuenta = user.Cuenta;
usuario.Pass = Encrypt.GetCrypt(user.Pass);
usuario.IdRol = user.IdRolUsuario;//>= 2 ? user.IdRol : 3;
//usuario.IdCargo = user.IdCargo;
usuario.RutaFirma = user.RutaFirma;
usuario.Estado = true;
usuario.FechaRegistro = DateTime.Now;
if (user.IdRolUsuario == 4)
usuario.IdCliente = (user.IdCliente.GetValueOrDefault() != 0) ? user.IdCliente : null;
else
usuario.IdCliente = null;
context.Usuario.Add(usuario);
context.SaveChanges();
return true;
}
catch (Exception e)
{
throw e;
}
}
}
//Convierte un objeto DTO en una Entity de NHibernate, sus propiedades basicas
//y utiliza el metodo Transformer de sus objetos mas complejos
public static Usuario DTOToEntity(UsuarioDTO pUsuarioDTO)
{
Usuario rReturn = new Usuario();
rReturn.ID = pUsuarioDTO.ID;
rReturn.Nombre = pUsuarioDTO.Nombre;
rReturn.Password = pUsuarioDTO.Password;
rReturn.Activo = pUsuarioDTO.Activo;
rReturn.ForzarExpiracion = pUsuarioDTO.ForzarExpiracion;
rReturn.CantidadDias = pUsuarioDTO.CantidadDias;
rReturn.ProximaFechaExpiracion = pUsuarioDTO.ProximaFechaExpiracion;
rReturn.MSTS = pUsuarioDTO.MSTS;
//Para objetos complejos
//if (pConsulta.IdHistoriaClinicaLookup != null)
//{
// pReturn.IdHistoriaClinicaLookup = TransformerHistoriaClinica.DTOToEntity(pConsulta.IdHistoriaClinicaLookup);
//}
//Roles
//if (pConsulta.Estudios != null)
//{
// foreach (EstudioDTO pObj in pConsulta.Estudios)
// {
// pReturn.Estudios.Add(TransformerEstudio.DTOToEntity(pObj));
// }
//}
return rReturn;
}
//Convierte un objeto DTO en una Entity de NHibernate, sus propiedades basicas
//y utiliza el metodo Transformer de sus objetos mas complejos
public static UsuarioDTO EntityToDTO(Usuario pUsuario)
{
UsuarioDTO rReturn = new UsuarioDTO();
rReturn.ID = pUsuario.ID;
rReturn.Nombre = pUsuario.Nombre;
rReturn.Password = pUsuario.Password;
rReturn.Activo = pUsuario.Activo;
rReturn.ForzarExpiracion = pUsuario.ForzarExpiracion;
rReturn.CantidadDias = pUsuario.CantidadDias;
rReturn.ProximaFechaExpiracion = pUsuario.ProximaFechaExpiracion;
rReturn.MSTS = pUsuario.MSTS;
//if (pConsulta.IdHistoriaClinicaLookup != null)
//{
// pReturn.IdHistoriaClinicaLookup = TransformerHistoriaClinica.EntityToDTO(pConsulta.IdHistoriaClinicaLookup);
//}
//Roles
//if (pConsulta.Estudios != null)
//{
// foreach (Estudio pObj in pConsulta.Estudios)
// {
// pReturn.Estudios.Add(TransformerEstudio.EntityToDTO(pObj));
// }
//}
return rReturn;
}
private void EliminarUsuario()
{
UsuarioDTO oUsuario = new UsuarioDTO();
oUsuario.ID = 1;
oUsuario.Eliminar();
}
private void RegistrarUsuario()
{
UsuarioDTO oUsuario = new UsuarioDTO();
oUsuario.Nombre = "Juan";
oUsuario.Password = "******";
oUsuario.Activo = true;
oUsuario.ForzarExpiracion = true;
oUsuario.CantidadDias = 30;
oUsuario.ProximaFechaExpiracion = DateTime.Today;
oUsuario.MSTS = DateTime.Today;
oUsuario.Insertar();
}
protected void btnRegistrar_Click(object sender, EventArgs e)
{
usu = new UsuarioDTO();
usu.IdUsu = txtIDuser.Text;
usu.ClaveUsu = txtClave.Text;
usu.NomUsu = txtNombre.Text;
usu.ApeUsu = txtApellido.Text;
usu.Email = txtEmail.Text;
proxy.registrarUsuario(usu);
Response.Redirect("RegistroCorrecto.aspx");
}
private void ActualizarUsuario()
{
UsuarioDTO oUsuario = new UsuarioDTO();
oUsuario.ID = 2;
oUsuario.Nombre = "pepepe";
oUsuario.Password = "******";
oUsuario.Activo = true;
oUsuario.ForzarExpiracion = true;
oUsuario.CantidadDias = 30;
oUsuario.ProximaFechaExpiracion = DateTime.Today;
oUsuario.MSTS = DateTime.Today;
oUsuario.Modificar();
}
public int ValidarUsuario(UsuarioDTO dto)
{
try
{
DataTable bolinho = new DataTable();
bolinho = dao.SelectWhere("tbl_usuario", $@"tbl_usuario.emailUsuario = '{dto.EmailUsuario}' and tbl_usuario.senhaUsuario = '{dto.SenhaUsuario}'");
if (bolinho.Rows.Count == 1)
{
return(Convert.ToInt32(bolinho.Rows[0]["tipoUsuario"]));
}
else
{
return(-1);
}
}
catch (Exception)
{
throw new Exception("Problemas, você tem problemas.");
}
}
public async Task <ActionResult> Login([FromBody] UsuarioDTO userInfo)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Values.SelectMany(e => e.Errors)));
}
var result = await _signInManager.PasswordSignInAsync(userInfo.Email, userInfo.Password,
isPersistent : false, lockoutOnFailure : false);
if (result.Succeeded)
{
return(Ok(GeraToken(userInfo)));
}
else
{
ModelState.AddModelError(string.Empty, "Login Inválido...");
return(BadRequest(ModelState));
}
}
public async Task <IActionResult> DeleteAsync([FromBody] UsuarioDTO usuarioDTO)
{
ResponseQuery responseQuery = new ResponseQuery();
if (usuarioDTO.id_usuario == 0)
{
responseQuery.error_number = -1;
responseQuery.error_message = "id_usuario tiene un valor errado o nulo.";
return(BadRequest(responseQuery));
}
responseQuery = await _usuarioApplication.DeleteAsync(usuarioDTO);
if (responseQuery.error_number == 0)
{
return(Ok(responseQuery));
}
return(BadRequest(responseQuery));
}
public async Task <IActionResult> UpdateAsync([FromBody] UsuarioDTO usuarioDTO)
{
ResponseQuery responseQuery = new ResponseQuery();
if (usuarioDTO == null)
{
responseQuery.error_number = -1;
responseQuery.error_message = "usuarioDTO no puede ser nulo.";
return(BadRequest(responseQuery));
}
responseQuery = await _usuarioApplication.UpdateAsync(usuarioDTO);
if (responseQuery.error_number == 0)
{
return(Ok(responseQuery));
}
return(BadRequest(responseQuery));
}
public async Task <IActionResult> RegisterUser([FromBody] UsuarioDTO model) //recebe no corpo as informações do usuário
{
var user = new IdentityUser
{
UserName = model.Email,
Email = model.Email,
EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, model.Password); //criando instancia do usuário
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
await _signInManager.SignInAsync(user, false);
return(Ok(GeraToken(model)));
}
public Tuple <string, DateTime> GerarToken(UsuarioDTO Usuario)
{
var Validade = DateTime.UtcNow.AddHours(8);
JwtSecurityTokenHandler TokenHandler = new JwtSecurityTokenHandler();
byte[] Key = Encoding.ASCII.GetBytes(_configuration.GetSection("Config").GetSection("secret_auth").Value);
SecurityTokenDescriptor TokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, Usuario.Nome.ToString()),
new Claim(ClaimTypes.Role, Usuario.Perfil.ToString())
}),
Expires = Validade,
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(Key), SecurityAlgorithms.HmacSha256Signature)
};
SecurityToken Token = TokenHandler.CreateToken(TokenDescriptor);
return(new Tuple <string, DateTime>(TokenHandler.WriteToken(Token), Validade));
}
private void modificar(UsuarioDTO usuario)
{
// Mostrar
gridNuevoModificarUsuario.Visibility = Visibility.Visible;
btnEliminar.Visibility = Visibility.Visible;
btnModifAceptar.Visibility = Visibility.Visible;
btnCancelar.Visibility = Visibility.Visible;
// Ocultar
gridAjustes.Visibility = Visibility.Hidden;
gridGestionUsuario.Visibility = Visibility.Hidden;
ajustesViewModel.usuario = usuario;
cmbRolNuevoModif.ItemsSource = ajustesViewModel.observableCollectionRol;
modo = Constantes.MODIFICA;
cargarDatos(modo);
}
public List <UsuarioDTO> ObterTodosUsuarios()
{
List <UsuarioDTO> usuarioDTOs = new List <UsuarioDTO>();
var usuarios = _context.CollectionUsuario.Find <Usuario>(usu => true).ToList();
foreach (var item in usuarios)
{
UsuarioDTO usuarioDTO = new UsuarioDTO
{
IdUsuario = item.IdUsuario,
Login = item.Login,
Senha = item.Senha,
Nome = item.Nome,
PerfilSuper = item.PerfilSuper,
Email = item.Email
};
usuarioDTOs.Add(usuarioDTO);
}
return(usuarioDTOs);
}
public static void ModificarUsuario(UsuarioDTO _Usuario)
{
try
{
using (consultoriosEntities dbContext = new consultoriosEntities())
{
Usuario Entidad = (from n in dbContext.Usuario
where n.Id == _Usuario.Id
select n).FirstOrDefault();
Entidad.Nombre = _Usuario.Nombre;
Entidad.Password = _Usuario.Password;
Entidad.Tipo_usuario = _Usuario.Tipo_usuario;
dbContext.Entry(Entidad).CurrentValues.SetValues(Entidad);
dbContext.SaveChanges();
}
}
catch (Exception)
{
}
}
public async Task <ActionResult> Login([FromBody] UsuarioDTO userInfo)
{
var result = await _signInManager.PasswordSignInAsync(
userInfo.Email,
userInfo.Password,
isPersistent : false,
lockoutOnFailure : false
);
if (result.Succeeded)
{
return(Ok(GerarToken(userInfo)));
}
ModelState.AddModelError(
string.Empty,
"Login inválido!"
);
return(BadRequest(ModelState));
}
public async Task <ActionResult <UsuarioDTO> > GetUsuarioByUsername(string username)
{
UsuarioDTO Usuario = await DBContext.Usuarios.Select(
s => new UsuarioDTO
{
Username = s.Username,
UserId = s.UserId,
HashedPassword = s.HashedPassword
})
.FirstOrDefaultAsync(s => s.Username == username);
if (Usuario == null)
{
return(NotFound());
}
else
{
return(Usuario);
}
}
//Botão Excluir
private void btnExcluir_Click(object sender, EventArgs e)
{
DialogResult msg = MessageBox.Show("Deseja mesmo excluir este registro!?", "ATENÇÂO!!", MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
//Manipulando o resultado escolhido pelo usuario
if (msg == DialogResult.Yes)
{
UsuarioDTO objUser = new UsuarioDTO();
objUser.NomeUsuario = txtNome.Text;
UsuarioBLL objExcluiBLL = new UsuarioBLL();
int codigo = Convert.ToInt32(txtID.Text);
objExcluiBLL.ExcluirUsuario(codigo);
Limpar();
MessageBox.Show(objUser.NomeUsuario + " excluido com sucesso!");
}
else if (msg == DialogResult.No)
{
Limpar();
}
}
public async Task <ActionResult> RegisterUser([FromBody] UsuarioDTO usuarioDTO)
{
var user = new IdentityUser
{
UserName = usuarioDTO.Email,
Email = usuarioDTO.Email,
EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, usuarioDTO.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
await _signManager.SignInAsync(user, false);
return(Ok(GeraToken(usuarioDTO)));
}
public void InserirNovos_UsuariosBLL(UsuarioDTO dto)
{
try
{
bd = new AcessoBancoDados();
bd.Conectar();
string comando = "INSERT INTO tb_Usuario(nome_usuario,senha_usuario,funcao) VALUES('" + dto.nome_usuario + "','" + dto.senha_usuario + "', '" + dto.funcao_usuario + "')";
bd.ExecutarComandoSQL(comando);
}
catch (Exception ex)
{
//throw new Exception("Erro ao Inserir Paciente. Detalhe:"+ ex.Message);
MessageBox.Show("Erro ao Inserir Novo Usuario.Detalhe:" + ex.Message);
}
finally
{
bd = null;
}
}
public async Task <IActionResult> Insert(UsuarioDTO user)
{
try
{
if (ModelState.IsValid)
{
var entity = await _usuarioService.Insert(this.Usuario, user);
return(Ok(entity));
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception e)
{
return(StatusCode(500, e));
}
}
public async Task <Guid> CrearProceso(Proceso proceso, UsuarioDTO usuario)
{
try
{
if (proceso.Id == 0)
{
return(await CrearInspeccionEntrada(proceso, usuario));
}
else
{
Guid procesoGuid = await _procesoRepository.CrearProceso(proceso, usuario);
return(procesoGuid);
}
}
catch (Exception e)
{
throw e;
}
}
public UsuarioDTO IniciarSesion(string Nombreusuario, string contrasenia)
{
var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(db));
var u = userManager.Find(Nombreusuario, contrasenia);
UsuarioDTO usuarioDTO = null;
if (u != null)
{
usuarioDTO = new UsuarioDTO();
usuarioDTO.Id = u.Id;
usuarioDTO.Nombres = u.Nombres;
usuarioDTO.Apellidos = u.Apellidos;
usuarioDTO.NombreUsuario = u.UserName;
usuarioDTO.Email = u.Email;
}
return(usuarioDTO);
}
public int deletaUsuario(UsuarioDTO USU)
{
try
{
SqlConnection CON = new SqlConnection();
CON.ConnectionString = Properties.Settings.Default.CST;
SqlCommand CM = new SqlCommand();
CM.CommandType = System.Data.CommandType.Text;
CM.CommandText = "DELETE tb_usuarios WHERE cod_usuario = @cod_usuario";
CM.Parameters.Add("cod_usuario", System.Data.SqlDbType.Int).Value = USU.cod_usuario;
CM.Connection = CON;
CON.Open();
int qtd = CM.ExecuteNonQuery();
return(qtd);
}
catch (Exception ex)
{
throw ex;
}
}
public ActionResult Login([FromBody] UsuarioDTO usuarioDTO)
{
ModelState.Remove("Nome");
ModelState.Remove("ConfirmacaoSenha");
if (ModelState.IsValid)
{
ApplicationUser usuario = _usuarioRepository.Obter(usuarioDTO.Email, usuarioDTO.Senha);
if (usuario != null)
{
//Login no Identity
//_signInManager.SignInAsync(usuario, false);
//retorna o Token (JWT)
var token = BuildToken(usuario);
//Salvar o Token no Banco
var tokenModel = new Token()
{
RefreshToken = token.RefreshToken,
ExpirationToken = token.Expiration,
ExpirationRefreshToken = token.ExpirationRefreshToken,
Usuario = usuario,
Criado = DateTime.Now,
Utilizado = false
};
_tokenRepository.Cadastrar(tokenModel);
return(Ok(token));
}
else
{
return(NotFound("Usuário não localizado!"));
}
}
else
{
return(UnprocessableEntity(ModelState));
}
}
public IList <UsuarioDTO> CarregarUsuario()
{
PgSqlConnection conn = new PgSqlConnection("User Id=postgres;Password=root;host=localhost;database=NIVEL_ACESSO;");
PgSqlCommand cmd = new PgSqlCommand();
cmd.CommandText = "SELECT * FROM public.\"TRABALHADORES\"";
cmd.Connection = conn;
conn.Open();
int aff = cmd.ExecuteNonQuery();
PgSqlDataReader ER;
IList <UsuarioDTO> listaUsuarioDTO = new List <UsuarioDTO>();
ER = cmd.ExecuteReader();
if (ER.HasRows)
{
while (ER.Read())
{
UsuarioDTO usuario = new UsuarioDTO();
usuario.Cpf = Convert.ToString(ER["CPF"]);
usuario.Nome = Convert.ToString(ER["NOME"]);
usuario.Email = Convert.ToString(ER["EMAIL"]);
usuario.Login = Convert.ToString(ER["LOGIN"]);
usuario.Status = Convert.ToChar(ER["STATUS"]);
usuario.Senha = Convert.ToString(ER["SENHA"]);
usuario.NivelDeAcesso = Convert.ToInt16(ER["NIVEL_DE_ACESSO"]);
listaUsuarioDTO.Add(usuario);
}
}
conn.Close();
return(listaUsuarioDTO);
}
public ActionResult Atualizar(string id, [FromBody]UsuarioDTO usuarioDTO)
{
//TODO - Adicionar Filtro de Validação
ApplicationUser usuario = _userManager.GetUserAsync(HttpContext.User).Result;
if (usuario.Id != id)
{
return Forbid();
}
if (ModelState.IsValid)
{
//TODO - Refatorar para AutoMapper.
usuario.FullName = usuarioDTO.Nome;
usuario.UserName = usuarioDTO.Email;
usuario.Email = usuarioDTO.Email;
usuario.Slogan = usuarioDTO.Slogan;
//TODO - Remover no Identity critérios da senha.
var resultado = _userManager.UpdateAsync(usuario).Result;
_userManager.RemovePasswordAsync(usuario);
_userManager.AddPasswordAsync(usuario, usuarioDTO.Senha);
if (!resultado.Succeeded)
{
List<string> erros = new List<string>();
foreach (var erro in resultado.Errors)
{
erros.Add(erro.Description);
}
return UnprocessableEntity(erros);
}
else
{
return Ok(usuario);
}
}
else
{
return UnprocessableEntity(ModelState);
}
}
public IActionResult Form([FromQuery] AccionesCRUD accionCRUD, int?Id)
{
try
{
if (accionCRUD.Equals(AccionesCRUD.AGREGAR) || accionCRUD.Equals(AccionesCRUD.MODIFICAR))
{
List <SelectListItem> Perfiles = this._perfilService.getPerfiles().Select(x => new SelectListItem
{
Value = x.Id.ToString(),
Text = $"{x.Descripcion} - [{x.ModulosDescripcion}]"
}).ToList();
ViewData["accionCRUD"] = accionCRUD;
if (accionCRUD.Equals(AccionesCRUD.AGREGAR))
{
UsuarioViewModel usuarioViewModel = new UsuarioViewModel();
usuarioViewModel.Perfiles = Perfiles;
return(View(usuarioViewModel));
}
if (accionCRUD.Equals(AccionesCRUD.MODIFICAR))
{
UsuarioDTO usuarioDTO = this._usuarioService.getUsuario((int)Id);
PerfilDTO perfilDTO = this._perfilService.getPerfil(usuarioDTO.PerfilId);
UsuarioViewModel usuarioViewModel = this._mapper.Map <UsuarioViewModel>(usuarioDTO);
usuarioViewModel.PerfilDescripcion = $"{perfilDTO.Descripcion} - [{perfilDTO.ModulosDescripcion}]";
usuarioViewModel.Perfiles = Perfiles;
return(View(usuarioViewModel));
}
}
throw new Exception("Ocurrio un error inesperado.");
}
catch (Exception ex)
{
ViewBag.error = ex.Message;
return(View("index"));
}
}
public IActionResult Agregar(UsuarioViewModel p_UsuarioVM)
{
try
{
if (!ModelState.IsValid)
{
throw new Exception("Error al validar datos.");
}
else
{
if (p_UsuarioVM.Password != p_UsuarioVM.ConfirmacionPassword)
{
throw new Exception("No coinciden las contraseñas ingresadas, asegurese de que sean identicos.");
}
if (p_UsuarioVM.UserName.Trim().Contains(" "))
{
throw new Exception("El nombre de usuario de debe contener espacios en blando.");
}
if (p_UsuarioVM.PerfilId == 0)
{
throw new Exception("Debe seleccionar un perfil para el usuario.");
}
UsuarioDTO usuarioDTO = this._mapper.Map <UsuarioDTO>(p_UsuarioVM);
int result = this._usuarioService.AgregarUsuario(usuarioDTO);
ViewBag.result = "Accion realizada con exito.";
List <UsuarioViewModel> UsuarioViewModels = this._usuarioService.getUsuarios()
.Select(x => this._mapper.Map <UsuarioViewModel>(x)).ToList();
return(View("index", UsuarioViewModels));
}
}
catch (Exception ex)
{
ViewBag.error = ex.Message;
ViewData["accionCRUD"] = AccionesCRUD.AGREGAR;
return(View("form", p_UsuarioVM));
}
}
public async Task <IEnumerable <TipoRecursoMaterialDTO> > List(UsuarioDTO userlogged, TipoRecursoMaterialFilterDTO filter = null /*, bool? includeRrhh = false*/)
{
var entities = await _tipoRecursoMaterialRespository.ListBy(tipo =>
(
(tipo.IdEmpresa == userlogged.IdEmpresa) &&
(!filter.CreationDateFrom.HasValue || tipo.CreationDate >= filter.CreationDateFrom.Value) &&
(!filter.CreationDateTo.HasValue || tipo.CreationDate <= filter.CreationDateTo.Value) &&
(
filter.Name.IsNullOrEmpty() ||
tipo.Descripcion.ToLower().Contains(filter.Name)
)
) &&
tipo.Active == true
);
return(_mapper.Map <IEnumerable <TipoRecursoMaterialDTO> >(entities));
/* if (!includeRrhh == true)
* {
* var entities = await _tipoRecursoMaterialRespository.ListBy();
* var dtos = _mapper.Map<IEnumerable<TipoRecursoMaterialDTO>>(entities);
* return dtos;
* }
* else
* {
* var entities = await _tipoRecursoMaterialRespository.ListBy();
* var dtos = _mapper.Map<IEnumerable<TipoRecursoMaterialDTO>>(entities);
* var result = new List<TipoRecursoMaterialDTO> { new TipoRecursoMaterialDTO
* {
* Active = true,
* Descripcion = TipoRecursoEnum.Recurso_Humano.GetDescription(),
* Id = TipoRecursoEnum.Recurso_Humano.ToInt()
* } };
* result.AddRange(dtos);
* return result;
* }*/
}
public async Task <Guid> CrearFormato(Formato formato, UsuarioDTO usuario)
{
try
{
if (formato.FormatoTiposConexion != null)
{
foreach (var tipo in formato.FormatoTiposConexion)
{
_context.Entry(tipo.TipoConexion).State = EntityState.Detached;
_context.Entry(tipo).State = tipo.Id <= 0 ? EntityState.Added : EntityState.Modified;
}
}
if (formato.Codigo != null)
{
var exitesCodigo = await _context.Formato.AnyAsync(d => d.Codigo == formato.Codigo);
if (exitesCodigo)
{
throw new Exception("El codigo de para este formato ya existe, por favor intente otro");
}
}
formato.Guid = Guid.NewGuid();
formato.GuidUsuarioCrea = Guid.NewGuid();
formato.NombreUsuarioCrea = "USUARIO CREA";
formato.FechaRegistro = DateTime.Now;
_context.Formato.Add(formato);
await _context.SaveChangesAsync();
return(formato.Guid);
}
catch (Exception e)
{
throw e;
}
}
public bool SalvarEquipe(int idProjeto, UsuarioDTO gerenteProj, List <UsuarioDTO> listaUsuarios)
{
try
{
if (listaUsuarios.Count > 0 && idProjeto != null)
{
using (SAARHEntities db = new SAARHEntities())
{
// Insere cada usuário na tabela Projeto_Funcionário.
foreach (UsuarioDTO usuario in listaUsuarios)
{
Projeto_Funcionario recurso = new Projeto_Funcionario();
recurso.prfu_proj_id = idProjeto;
recurso.prfu_usu_id = Convert.ToInt32(usuario.UsuarioID);
recurso.prfu_data_inicio = usuario.DataInicio;
recurso.prfu_data_termino = usuario.DataTermino;
db.Projeto_Funcionario.Add(recurso);
//db.SaveChanges();
}
// Adiciona o gerente do projeto a equipe
Projeto_Funcionario gerente = new Projeto_Funcionario();
gerente.prfu_proj_id = idProjeto;
gerente.prfu_usu_id = Convert.ToInt32(gerenteProj.UsuarioID);
gerente.prfu_data_inicio = gerenteProj.DataInicio;
gerente.prfu_data_termino = gerenteProj.DataTermino;
db.Projeto_Funcionario.Add(gerente);
db.SaveChanges();
return(true);
}
}
}
catch (Exception)
{
throw new Excecoes.EquipeExcecao("Ocorreu um problema ao salvar a equipe para este projeto!");
}
return(false);
}
public ActionResult Create(UsuarioModel model)
{
try
{
if (ModelState.IsValid)
{
if (model.Contraseña2.Equals(model.Contraseña))
{
UsuarioModel model2 = new UsuarioModel()
{
Id_usuario = model.Id_usuario,
Nombre = model.Nombre,
Contraseña = model.Contraseña
};
MapeadorUIUsuario mapeador = new MapeadorUIUsuario();
UsuarioDTO dto = mapeador.MapearT2T1(model2);
bool guardado = _controlador.IngresarUsuario(dto);
if (guardado)
{
return(RedirectToAction("Index"));
}
else
{
return(View(model));
}
}
else
{
return(View(model));
}
}
else
{
return(View(model));
}
}
catch
{
return(View());
}
}
}//incluir
public void Alterar(UsuarioDTO usrDalCrud)
{
try
{
SqlCommand cmd = new SqlCommand();
cmd.Connection = conexao.Conexao;
cmd.CommandText = "update tbUsuario set usr_nome = @usr_nome, usr_cpf = @usr_cpf, "
+ "usr_telefone = @usr_telefone, usr_celular = @usr_celular, usr_logradouro = @usr_logradouro, "
+ "usr_numero = @usr_numero, usr_complemento = @usr_complemento, usr_bairro = @usr_bairro, "
+ "usr_cidade = @usr_cidade, usr_estado = @usr_estado, usr_cargo = @usr_cargo, usr_usuario = @usr_usuario, "
+ "usr_senha = @usr_senha, usr_confirmarSenha = @usr_confirmarSenha, usr_email = @usr_email where usr_id = @usr_id;";
cmd.Parameters.AddWithValue("@usr_id", usrDalCrud.Usr_id);
cmd.Parameters.AddWithValue("@usr_nome", usrDalCrud.Usr_nome);
cmd.Parameters.AddWithValue("@usr_cpf", usrDalCrud.Usr_cpf);
cmd.Parameters.AddWithValue("@usr_telefone", usrDalCrud.Usr_telefone);
cmd.Parameters.AddWithValue("@usr_celular", usrDalCrud.Usr_celular);
cmd.Parameters.AddWithValue("@usr_logradouro", usrDalCrud.Usr_logradouro);
cmd.Parameters.AddWithValue("@usr_numero", usrDalCrud.Usr_numero);
cmd.Parameters.AddWithValue("@usr_complemento", usrDalCrud.Usr_complemento);
cmd.Parameters.AddWithValue("@usr_bairro", usrDalCrud.Usr_bairro);
cmd.Parameters.AddWithValue("@usr_cidade", usrDalCrud.Usr_cidade);
cmd.Parameters.AddWithValue("@usr_estado", usrDalCrud.Usr_estado);
cmd.Parameters.AddWithValue("@usr_cargo", usrDalCrud.Usr_cargo);
cmd.Parameters.AddWithValue("@usr_usuario", usrDalCrud.Usr_usuario);
cmd.Parameters.AddWithValue("@usr_senha", usrDalCrud.Usr_senha);
cmd.Parameters.AddWithValue("@usr_confirmarSenha", usrDalCrud.Usr_confirmarSenha);
cmd.Parameters.AddWithValue("@usr_email", usrDalCrud.Usr_email);
conexao.Conectar();
cmd.ExecuteNonQuery(); //não retorna parametro algum
}
catch (Exception erro)
{
throw new Exception(erro.Message);
}
finally
{
conexao.Desconectar();
}
}//alterar
public ActionResult Login(Usuario user)
{
UsuarioDTO userDB = null;
using (SecurityContext db = new SecurityContext())
{
userDB = (from u in db.Usuario
join r in db.Rol
on u.IdRol equals r.IdRol
where u.NickName.Equals(user.NickName, StringComparison.OrdinalIgnoreCase) &&
u.Password.Equals(user.Password, StringComparison.Ordinal)
select new UsuarioDTO
{
IdUsuario = u.IdUsuario,
NomUsuario = u.NomUsuario,
IdRol = r.IdRol,
NomRol = r.NomRol
}).FirstOrDefault();
}
if (userDB != null)
{
var identity = new ClaimsIdentity(new List <Claim>
{
new Claim("IdUsuario", userDB.IdUsuario.ToString()),
new Claim(ClaimTypes.Name, userDB.NomUsuario),
new Claim(ClaimTypes.Role, userDB.NomRol)
},
"SecurityAppCookie");
var ctx = Request.GetOwinContext();
var authManager = ctx.Authentication;
authManager.SignIn(identity);
return(RedirectToAction("PrincipalPage"));
}
ViewBag.Error = "User does not exist";
return(View("Index"));
}
private void ConfirmaEquipe()
{
fachada = new Fachada();
try
{
// primeiro valida se existe algum recurso já alocado para este projeto.
int quantidadeMembros = BuscarMembrosEquipe();
if (quantidadeMembros > 0)
{
// abre uma popup de confirmação para atualizar a equipe.
AbrirConfirmarPopup();
}
else
{
// salva no banco a nova equipe.
int projetoID = Convert.ToInt32(ddlProjeto.SelectedItem.Value);
// verifica se o usuário logado é um gerente para adicioná-lo ao projeto, é uma validação adicional
if (projetoID > 0)
{
if (Master.UsuarioAtual.TipoUsuario == 1)
{
UsuarioDTO gerente = Master.UsuarioAtual;
gerente.DataInicio = DataInicioProjeto;
gerente.DataTermino = DataTerminoProjeto;
bool equipeSalva = fachada.SalvarEquipe(projetoID, gerente, ListaUsuariosSelecionados);
if (equipeSalva)
{
Master.OpenSuccesModal("Equipe salva com sucesso!");
LimparDadosPesquisa();
VoltarConfigPesquisa();
}
}
}
}
}
catch (Exception ex)
{
Master.OpenErrorModal(ex.Message);
}
}
public ActionResult Login(UsuarioDTO user)
{
if (ModelState.IsValid)
{
UsuariosBL usuariosBL = new UsuariosBL();
if (usuariosBL.isValidUser(user))
{
System.Web.HttpContext.Current.Session["User"] = usuariosBL.getUsuarioByCuenta(user);//new UsuarioDTO() { Nombre = "NubeLabs", IdUsuario = 1, IdRol = 1 }; //{ Nombre = "Responsable 1", IdUsuario = 2, IdRol = 3 }; //usuariosBL.getUsuarioByCuenta(user);
return RedirectToAction("Index");
}
}
return RedirectToAction("Ingresar");
}
public void ObtenerDepartamento()
{
var proxiesUsuaio = new UsuarioServiceClient();
var usuario = proxiesUsuaio.ObtenerUsuario();
if (usuario!=null)
{
foreach (var item in usuario)
{
var obtenerUsuario = new UsuarioDTO
{
UsuarioId = item.UsuarioId,
Nombre = item.Nombre,
Apellido = item.Apellido,
Contraseña = item.Contraseña,
ConfirmacionContraseña = item.ConfirmacionContraseña,
FechaNacimiento = item.FechaNacimiento,
Sexo = item.Sexo,
Telefono = item.Telefono
};
ListUsuario.Add(obtenerUsuario);
ListUsuarioOriginal.Add(obtenerUsuario);
}
}
proxiesUsuaio.ObtenerUsuarioAsync();
}
public void RegistrarUsuario()
{
var proxiesUsurio = new UsuarioServiceClient();
var addUsuario = new UsuarioDTO()
{
UsuarioId = UsuarioId,
Nombre = Nombre,
Apellido = Apellido,
Contraseña = Contrasena,
ConfirmacionContraseña = ConfirmarContrasena,
Telefono = Telefono,
FechaNacimiento = FechaNacimiento,
Sexo = Sexo
};
proxiesUsurio.CrearUsuarioAsync(addUsuario);
ListUsuario.Add(addUsuario);
MostrarLogin = true;
Registrarse = false ;
MessageBox.Show("El Usuario ha sido Registrado");
}
public bool validateUsuario(UsuarioDTO user)
{
using (var context = getContext())
{
if (user.Cuenta != null && user.Email != null)
{
var result = from r in context.Usuario
where r.Cuenta == user.Cuenta || r.Email == user.Email
select r;
if (result.FirstOrDefault<Usuario>() == null)
{
return true;
}
}
return false;
}
}
public OrdenReposicionEventoEnTransito(OrdenReposicion r, int camion, UsuarioDTO usuario, string comentario = null)
: base()
{
evento = new OrdenReposicionEvento(r, OrdenReposicionEventoTipo.en_transito, usuario, comentario);
evento.IndexedString = camion.ToString();
}
public bool update(UsuarioDTO user, string passUser, string passChange, UsuarioDTO currentUser)
{
using (var context = getContext())
{
try
{
Usuario usuario = context.Usuario.Where(x => x.IdUsuario == user.IdUsuario).SingleOrDefault();
if (usuario != null)
{
usuario.Nombre = user.Nombre;
usuario.InicialesNombre = user.InicialesNombre;
usuario.Email = user.Email;
usuario.IdRol = user.IdRolUsuario;// >= 2 ? user.IdRol : 3;
//usuario.IdCargo = user.IdCargo;
usuario.Cuenta = user.Cuenta;
usuario.Estado = user.Active;
usuario.RutaFirma = user.RutaFirma;
if (user.IdRolUsuario == 4)
usuario.IdCliente = (user.IdCliente.GetValueOrDefault() != 0) ? user.IdCliente : null;
else
usuario.IdCliente = null;
if (!String.IsNullOrWhiteSpace(passUser) && !String.IsNullOrWhiteSpace(passChange))
{
if ((currentUser.IdRolUsuario <= 2 || currentUser.IdUsuario == user.IdUsuario)
&& Encrypt.comparetoCrypt(passUser, currentUser.Pass))
{
usuario.Pass = Encrypt.GetCrypt(passChange);
}
else return false;
}
context.SaveChanges();
return true;
}
}
catch (Exception e)
{
//throw e;
return false;
}
return false;
}
}
public bool updatePassword(UsuarioDTO user, string passChange)
{
using (var context = getContext())
{
try
{
Usuario usuario = context.Usuario.Where(x => x.IdUsuario == user.IdUsuario).SingleOrDefault();
usuario.Pass = Encrypt.GetCrypt(passChange);
context.SaveChanges();
return true;
}
catch (Exception e)
{
//throw e;
return false;
}
}
}
public void SendMailPassRecovery(UsuarioDTO user, string passChange)
{
string to = user.Email;
string subject = "Recuperación de Contraseña";
string body = "Sr(a). " + user.Nombre + " su contraseña es : " + passChange;
MailHandler.Send(to, "", subject, body);
}
public bool isValidUser(UsuarioDTO user)
{
if (user.Cuenta == null || user.Pass == null)
return false;
using (var context = getContext())
{
var result = from r in context.Usuario
where r.Estado == true & r.Cuenta == user.Cuenta
select r;
Usuario usuario = result.SingleOrDefault<Usuario>();
if (usuario != null)
{
if (Encrypt.comparetoCrypt(user.Pass, usuario.Pass))
return true;
}
}
return false;
}
public UsuarioDTO getUsuarioByCuenta(UsuarioDTO user)
{
using (var context = getContext())
{
var result = from r in context.Usuario
where r.Estado == true & r.Cuenta == user.Cuenta
select new UsuarioDTO
{
IdUsuario = r.IdUsuario,
Nombre = r.Nombre,
IdRolUsuario = r.IdRol,// ?? 0,
Active = r.Estado,
Email = r.Email,
Pass = r.Pass,
Cuenta = r.Cuenta,
IdCliente = r.IdCliente
};
return result.SingleOrDefault<UsuarioDTO>();
}
}
public OrdenReposicionEventoConfirmacion(OrdenReposicion r, UsuarioDTO usuario, string comentario = null)
: base()
{
evento = new OrdenReposicionEvento(r, OrdenReposicionEventoTipo.confirmacion, usuario, comentario);
}
public ActionResult AddUser(UsuarioDTO user, string passUser = "", string passChange = "")
{
if (!this.currentUser()) { return RedirectToAction("Ingresar"); }
UsuarioDTO currentUser = getCurrentUser();
if (!this.isAdministrator() && user.IdUsuario != currentUser.IdUsuario) { return RedirectToAction("Index"); }
if (user.IdUsuario == 1 && !this.isSuperAdministrator()) { return RedirectToAction("Index"); }
try
{
UsuariosBL usuariosBL = new UsuariosBL();
if (user.IdUsuario == 0 && usuariosBL.validateUsuario(user))
{
usuariosBL.add(user);
createResponseMessage(CONSTANTES.SUCCESS);
return RedirectToAction("Usuarios");
}
else if (user.IdUsuario != 0)
{
if (usuariosBL.update(user, passUser, passChange, this.getCurrentUser()))
{
createResponseMessage(CONSTANTES.SUCCESS);
if (user.IdUsuario == this.getCurrentUser().IdUsuario)
{
System.Web.HttpContext.Current.Session["User"] = usuariosBL.getUsuario(user.IdUsuario);
if (!this.getCurrentUser().Active) System.Web.HttpContext.Current.Session["User"] = null;
}
return RedirectToAction("Usuarios");
}
else
{
createResponseMessage(CONSTANTES.ERROR, CONSTANTES.ERROR_UPDATE_MESSAGE + "<br>Si está intentando actualizar la contraseña, verifique que ha ingresado la contraseña actual correctamente.");
}
}
else
{
createResponseMessage(CONSTANTES.ERROR, CONSTANTES.ERROR_INSERT_MESSAGE);
}
}
catch
{
if (user.IdUsuario != 0)
createResponseMessage(CONSTANTES.ERROR, CONSTANTES.ERROR_UPDATE_MESSAGE);
else createResponseMessage(CONSTANTES.ERROR, CONSTANTES.ERROR_INSERT_MESSAGE);
}
TempData["Usuario"] = user;
return RedirectToAction("Usuario");
}
private void BuscarUsuarios()
{
UsuarioDTO oUsuario = new UsuarioDTO();
dgvUsuarios.DataSource = oUsuario.GetAll();
}
public OrdenReposicionEventoComentario(OrdenReposicion r, UsuarioDTO usuario, string comentario)
: base()
{
evento = new OrdenReposicionEvento(r, OrdenReposicionEventoTipo.comentario, usuario, comentario);
}
