public async Task <Respuesta> GuardarUsuarioAsync(Usuario usuario)
{
Message message;
bool estadoTransaccion = false;
if (await this.usuarioRepositorie.ExisteUsuarioAsync(UsuarioMapper.UsuarioEntityMap(usuario)))
{
message = new Message(MessageCode.Message0002);
}
else
{
await this.usuarioRepositorie.GuardarUsuarioAsync(UsuarioMapper.UsuarioEntityMap(usuario));
message = new Message(MessageCode.Message0000);
estadoTransaccion = true;
}
return(new Respuesta
{
EstadoTransaccion = estadoTransaccion,
Mensaje = new Mensaje
{
Identificador = message.Code,
Titulo = message.Title,
Contenido = message.Text
}
});
}
public UsuarioCrudFactory() : base()
{
this.mapper = new UsuarioMapper();
this.archivoMapper = new ArchivoMapper();
dao = SqlDao.GetInstance();
}
public Usuario Login(String user, String pass)
{
List <IDataParameter> listaParametros = new List <IDataParameter>();
IDataParameter pUser = CrearParametro("@Nick", user);
IDataParameter pPass = CrearParametro("@Pass", pass);
listaParametros.Add(pUser);
listaParametros.Add(pPass);
IDataReader dr = EjecutarReader(CommandType.Text,
"Select Nick, Rol, Dicose from Usuarios where Nick like @Nick and Pass = @Pass and Estado = 'Activo'",
listaParametros
);
if (dr != null)
{
if (dr.Read())
{
Usuario u = new Usuario();
UsuarioMapper m = new UsuarioMapper(u);
m.load(dr);
dr.Close();
return(u);
}
}
return(null);
}
public void DeveCriarUsuarioComDataDeCriacaoETelefones()
{
var criarUsuarioCommand = new CriarUsuarioCommand(NOME, EMAIL, SENHA);
criarUsuarioCommand.Telefones.Add(new CriarTelefoneCommand(DDD1, TELEFONE1));
criarUsuarioCommand.Telefones.Add(new CriarTelefoneCommand($"({DDD2})", TELEFONE2));
var usuario = new UsuarioMapper().MapFrom(criarUsuarioCommand);
Assert.IsNotNull(usuario);
Assert.AreNotEqual(Guid.Empty, usuario.Id);
Assert.IsNotNull(usuario.Telefones);
Assert.IsTrue(usuario.Telefones.Any());
Assert.AreEqual(2, usuario.Telefones.Count);
Assert.AreEqual(NOME, usuario.Nome);
Assert.AreEqual(EMAIL, usuario.Email);
Assert.IsTrue(new PasswordEncryptionService().ComparePasswords(SENHA, usuario.Senha));
Assert.AreEqual(usuario.Telefones.First().Ddd, DDD1);
Assert.AreEqual(usuario.Telefones.First().Numero, TELEFONE1);
Assert.AreEqual(usuario.Telefones.Last().Ddd, DDD2.OnlyNumbers());
Assert.AreEqual(usuario.Telefones.Last().Numero, TELEFONE2.OnlyNumbers());
}
public Usuario getByLoginName(string loginName)
{
var user = _context.Web.SiteUsers.GetByLoginName(loginName);
_context.Load(user);
_context.ExecuteQuery();
return(UsuarioMapper.Map(user));
}
public Usuario getByEmail(string email)
{
var user = _context.Web.SiteUsers.GetByEmail(email);
_context.Load(user);
_context.ExecuteQuery();
return(UsuarioMapper.Map(user));
}
public Usuario getById(int id)
{
var user = _context.Web.SiteUsers.GetById(id);
_context.Load(user);
_context.ExecuteQuery();
return(UsuarioMapper.Map(user));
}
public void Pas(Usuario u)
{
UsuarioMapper m;
//VALIDAR
m = new UsuarioMapper(u);
m.Modificar();
}
public void Rem(Usuario u)
{
UsuarioMapper m;
//VALIDAR
m = new UsuarioMapper(u);
m.Eliminar();
}
public static int Insertar(Usuario usr)
{
usr.Password = GestionarEncriptacion.Encriptar(usr.Password);
int res = UsuarioMapper.Insertar(usr);
CalcularDVV();
Bitacora("Insertar", usr);
return(res);
}
public void Add(Usuario u)
{
UsuarioMapper m;
//VALIDAR
m = new UsuarioMapper(u);
m.Insertar();
m = null;
}
public async Task <IActionResult> Registrar([FromBody] RegistrarDTO dto)
{
var usuario = UsuarioMapper.Map(dto);
var usuarioCreado = await _userService.Crear(usuario, dto.Password);
var registrarDTO = UsuarioMapper.Map(usuarioCreado);
return(Ok(registrarDTO));
}
public List <Usuario> getAllOfGroup(int id)
{
GroupCollection collGroup = _context.Web.SiteGroups;
Group oGroup = collGroup.GetById(id);
_context.Load(oGroup, g => g.Users);
_context.ExecuteQuery();
return(UsuarioMapper.Map(oGroup.Users));
}
public static Usuario Get(int id)
{
Usuario item;
UsuarioEntity entity;
entity = UsuarioDao.Get(id);
item = UsuarioMapper.Get(entity);
return(item);
}
public async Task <Usuario> LogueoAsync(Usuario usuario)
{
var respuesta = await this.usuarioRepositorie.LogueoAsync(UsuarioMapper.UsuarioEntityMap(usuario));
if (respuesta != null)
{
return(usuario);
}
return(null);
}
public IEnumerable <Usuario> ObtenerUsuarios()
{
var usuarios = _dbContext.Usuarios.ToList();
var list = new List <Usuario>();
foreach (var usuario in usuarios)
{
list.Add(UsuarioMapper.MapModel(usuario));
}
return(list);
}
public async Task <IActionResult> Get(int id)
{
var usuario = await _unitOfWork.Usuarios.GetByIdUsuarioWithAllInformation(id);
if (usuario.IsAtivo)
{
return(Ok(UsuarioMapper.ModelToResource(usuario)));
}
return(NoContent());
}
public AutoMapperProfile()
{
UsuarioMapper.Map(this);
CargoMapper.Map(this);
DisciplinaMapper.Map(this);
ProfessorMapper.Map(this);
EscolaridadeMapper.Map(this);
ModalidadeEnsinoMapper.Map(this);
ContratoAulaMapper.Map(this);
AvaliacaoProfessorMapper.Map(this);
}
public Usuario CrearUsuario(Usuario Usuario)
{
UsuarioEntity entidad = UsuarioMapper.MapEntity(Usuario);
SensibilidadLocalEntity sensibilidadEntidad = SensibilidadLocalMapper.MapEntity(Usuario.Sensibilidad);
sensibilidadEntidad.UsuarioId = Usuario.UsuarioId;
_dbContext.Usuarios.Add(entidad);
_dbContext.SensibilidadLocal.Add(sensibilidadEntidad);
_dbContext.SaveChanges();
return(Usuario);
}
public static int Modificar(Usuario usr, bool yaEncriptado)
{
if (!yaEncriptado)
{
usr.Password = GestionarEncriptacion.Encriptar(usr.Password);
}
int res = UsuarioMapper.Modificar(usr);
Bitacora("Modificar", usr);
CalcularDVV();
return(res);
}
public static void RestablecerContrasenia(string email, string contrasenia)
{
Usuario usuario = UsuarioMapper.Obtener(email);
if (usuario != null)
{
usuario.Contrasenia = Encriptador.Encriptar(contrasenia);
usuario.IntentosLogin = 0;
usuario.TokenRecuperacion = null;
UsuarioMapper.Guardar(usuario);
}
}
private bool validateEmail()
{
DataTable dt = new DataTable();
dt = _unitOfWork.Usuarios.FindUserByEmail(_usuario);
if (dt.Rows.Count > 0)
{
_usuario = (Usuario)UsuarioMapper.ToUser(dt);
return(true);
}
else
{
return(false);
}
}
public static void Update(Usuario item)
{
try
{
UsuarioEntity entity;
entity = UsuarioMapper.Get(item);
UsuarioDao.Update(entity);
}
catch (Exception)
{
throw;
}
}
public static Usuario Get(string usuario, string contrasenia)
{
try
{
Usuario usuario1;
UsuarioEntity usuarioEntity;
usuarioEntity = UsuarioDao.Get(usuario, contrasenia);
usuario1 = UsuarioMapper.Get(usuarioEntity);
return(usuario1);
}
catch (Exception)
{
throw;
}
}
public GetUsuariosResponse GetUsuarios()
{
var response = new GetUsuariosResponse();
try
{
response.UsuarioViewModel = UsuarioMapper.ConvertToUsuarioViewModel(_usuarioRepository.GetByCriteria(x => x.IsActivo));
response.IsValid = true;
}
catch (Exception ex)
{
response.IsValid = false;
response.ErrorMessage = ex.Message;
}
return(response);
}
public Usuario ObtenerUsuario(int usuarioId)
{
//return _dbContext.Usuarios
// .Include(u => u.Guardarropas)
// .FirstOrDefault(u => u.UsuarioId == id);
UsuarioEntity entidad = _dbContext.Usuarios.FirstOrDefault(s => s.UsuarioId == usuarioId);
GuardarropaRepositorio repo = new GuardarropaRepositorio();
Usuario usuario = UsuarioMapper.MapModel(entidad);
usuario.Guardarropas = new List <Guardarropa>();
usuario.Guardarropas = repo.ObtenerGuardarropasUsuario(usuarioId);
SensibilidadLocalEntity sensibilidad = _dbContext.SensibilidadLocal.Find(usuarioId);
usuario.CambiarSensibilidadLocal(SensibilidadLocalMapper.MapModel(sensibilidad));
return(usuario);
}
public static List <UsuarioItem> GetAllEliminados()
{
try
{
List <UsuarioItem> lista;
List <UsuarioEntity> entities;
entities = UsuarioDao.GetAllEliminados();
lista = UsuarioMapper.GetAll(entities);
return(lista);
}
catch (Exception)
{
throw;
}
}
public static List <Usuario> GetAllByEmpresaId(int empresaId)
{
try
{
List <Usuario> lista;
List <UsuarioEntity> entities;
entities = UsuarioDao.GetAllByEmpresaId(empresaId);
lista = UsuarioMapper.GetAll(entities);
return(lista);
}
catch (Exception)
{
throw;
}
}
public static Usuario Login(Usuario usuario)
{
try
{
Usuario item;
UsuarioEntity entity;
entity = UsuarioDao.Login(usuario.NombreDeUsuario, usuario.Contrasenia);
item = UsuarioMapper.Get(entity);
return(item);
}
catch (Exception)
{
throw;
}
}
public async Task <MethodResult> ExecuteAsync(ObterUsuarioPeloIdCommand command)
{
if (command == null)
{
return(Error(Messages.ComandoInvalido));
}
var usuario = await _service.ObterPeloIdAsync(command.Id);
if (usuario == null)
{
return(Error(Messages.UsuarioNaoCadastrado));
}
var output = new UsuarioMapper().OutputFrom(usuario);
return(Success(output));
}
