public UsuarioViewModel Create(UsuarioViewModel toCreate, ref string error)
{
UsuarioViewModel resultado = null;
try
{
var request = toCreate.ConvertToModel();
UsuarioResponse response;
var objReq = new UsuarioRequest
{
Item = request,
Operacion = Operacion.Agregar
};
using (var proxy = new ServicioClient())
{
response = proxy.UsuarioEjecutarOperacion(objReq);
}
if (!response.Resultado)
{
error = response.MensajeError;
return(null);
}
resultado = response.Item.ConvertToViewModel();
}
catch (Exception ex)
{
error = ex.Message;
}
return(resultado);
}
public IActionResult Post(UsuarioRequest request)
{
Reply reply = new Reply();
try
{
using (XTECDigitalContext db = new XTECDigitalContext())
{
Usuario usuario = new Usuario();
usuario.IdRol = request.IdRol;
usuario.Id = request.Id;
db.Usuarios.Add(usuario);
db.SaveChanges();
reply.conexionSuccess = 1;
reply.message = "Usuario agregado";
}
}
catch (Exception ex)
{
reply.conexionSuccess = 0;
reply.message = ex.Message;
}
return(Ok(reply));
}
public GenericResponse MandarDatosUsuario(UsuarioRequest request, string _operation)
{
GenericResponse _response = new GenericResponse();
try
{
#region Encryptar contraseña de usuario
string Password = String.Empty;
Encryptador.EncryptDecrypt(true, request.password, ref Password);
request.password = Password;
#endregion
if (_conectorBD.InsertDatosUsuario(request, _operation))
{
_response.codigo = GerenteCodigo.GetCodigo("OK");
_response.mensaje = GerenteMensaje.GetMensaje("OK");
_response.exito = true;
Informacion.LogInformacion(LogManager.GetCurrentClassLogger(), " [ " + GerenteLog.GetObtenerMetodo() + " ] -- [ " + _operation + " ]. Se guardo de manera correcta al cliente con email: " + request.correo_Electronico);
}
else
{
Informacion.LogInformacion(LogManager.GetCurrentClassLogger(), " [ " + GerenteLog.GetObtenerMetodo() + " ] -- [ " + _operation + " ]. Ocurrio un error al guardar al cliente con email: " + request.correo_Electronico);
_response.codigo = 400;
_response.mensaje = "No se pudo registrar la informacion del usuario en base de datos";
_response.exito = false;
}
}
catch (Exception ex)
{
_response.codigo = GerenteCodigo.GetCodigo("ERROR_FATAL");
_response.mensaje = GerenteMensaje.GetMensaje("ERROR_FATAL");
_response.exito = false;
Informacion.LogError(LogManager.GetCurrentClassLogger(), " [ " + GerenteLog.GetObtenerMetodo() + " ] -- [ " + _operation + " ]. Se genero un error inesperado. ", ex);
}
return(_response);
}
public bool Delete(ref string error, int id)
{
UsuarioResponse response = null;
try
{
var obj = new Usuario()
{
Id = id
};
var objReq = new UsuarioRequest
{
Item = obj,
Operacion = Operacion.Eliminar
};
using (var proxy = new ServicioClient())
{
response = proxy.UsuarioEjecutarOperacion(objReq);
}
error = !response.Resultado ? response.MensajeError : "";
}
catch (Exception ex)
{
error = ex.Message;
}
return(response != null && response.Resultado);
}
public UsuarioResponse RegistrarUsuario(UsuarioRequest request)
{
UsuarioResponse response = null;
Usuario usuario = new Usuario();
usuario.NombreCompleto = request.nombreCompleto;
usuario.Edad = request.edad;
usuario.Correo = request.correo;
var password = AES.GetInstance().Encrypt(request.clave);
usuario.Clave = password;
var exists = _context.Usuarios.Any(x => x.Correo == usuario.Correo);
if (!exists)
{
_context.Usuarios.Add(usuario);
int result = _context.SaveChanges();
response = new UsuarioResponse()
{
correo = usuario.Correo,
nombreCompleto = usuario.NombreCompleto
};
response = result == 1 ? response : null;
}
return(response);
}
public IActionResult Add(UsuarioRequest oUsuarioRequest)
{
Respuesta oResponse = new Respuesta();
try
{
using (TodoListContext db = new TodoListContext())
{
Usuario oUsuario = new Usuario();
oUsuario.Nombre = oUsuarioRequest.Nombre;
oUsuario.Password = oUsuarioRequest.Password;
oUsuario.UserName = oUsuarioRequest.UserName;
db.Usuario.Add(oUsuario);
db.SaveChanges();
oResponse.Result = 1;
oResponse.Message = "Usuario agregado exitosamente";
return(Ok(oResponse));
}
}
catch (Exception ex)
{
oResponse.Message = ex.Message;
}
return(Ok(oResponse));
}
public UsuarioResponse cambiarPerfil(UsuarioRequest request)
{
DataAccess.DataAccess da = new DataAccess.DataAccess {
CadenaConexion = ConfigurationManager.ConnectionStrings["jadetBD"].ConnectionString
};
var resultado = da.guardarUsuario(new DataAccess.Usuario {
Direccion = request.Direccion,
Foto = request.Foto,
Id = request.Id,
IdEstatus = request.IdEstatus,
IdRol = request.IdRol,
Nombre = request.Nombre,
Telefono = request.Telefono,
UserName = request.Usuario,
Password = request.Password,
ZonaPaqueteria = request.ZonaPaqueteria
});
UsuarioResponse response = new UsuarioResponse {
Usuario = resultado.UserName,
ErrorMensaje = resultado.ErrorMensaje,
ErrorNumero = resultado.ErrorNumero,
Id = resultado.Id,
Nombre = resultado.Nombre,
Direccion = resultado.Direccion,
Password = resultado.Password,
Foto = resultado.Foto,
IdEstatus = resultado.IdEstatus,
IdRol = resultado.IdRol,
Telefono = resultado.Telefono,
ZonaPaqueteria = resultado.ZonaPaqueteria
};
return(response);
}
public UsuarioResponse Add(UsuarioRequest request)
{
Usuario entity = _repository.FindFirstOrDefault(x => x.Username == request.Username);
if (entity != null)
{
return(new UsuarioResponse($"El usuario {request.Username} ya existe", request.ToEntity()));
}
entity = request.ToEntity();
var rol = _rolService.GetRol(request.Rol);
if (rol == null)
{
return(new UsuarioResponse("Rol no existente"));
}
entity.Rol = rol;
entity.Estado = UsuarioEstado.Activo;
entity.Password = new PasswordHasher <Usuario>().HashPassword(entity, request.Password);
base.Add(entity);
if (entity.Id == 0)
{
return(new UsuarioResponse("No se pudo registrar el usuario"));
}
entity.Rol.Usuarios = null;
return(new UsuarioResponse("Usuario registrado", entity));
}
private void putUsuario(int id)
{
UsuarioRequest usuarioRequest = new UsuarioRequest()
{
Username = textBoxUsuario.Text,
IdEmpleado = this.idEmpleado,
IdRol = int.Parse(ComboBoxRole.SelectedValue.ToString()),
Password = textBoxPassword.Text
};
HttpResponseMessage response = HttpUtils.putUsuario(Settings.Default.Client, id, usuarioRequest);
string stringCR = response.Content.ReadAsStringAsync().Result;
var responseMessage = Newtonsoft.Json.JsonConvert.DeserializeObject <dynamic>(stringCR);
if (response.IsSuccessStatusCode)
{
DialogResult result = MessageBox.Show("Usuario actualizado con éxito!", "Wooh!", MessageBoxButtons.OK, MessageBoxIcon.Information);
if (result == DialogResult.OK)
{
okUpdate = true;
this.Dispose();
}
}
else
{
MessageBox.Show(this, (string)responseMessage.message, "Oops!", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public ResponseBase <bool> AlterarPerfil(int id, UsuarioRequest request)
{
ResponseBase <bool> br = new ResponseBase <bool>();
#region Validação
if (id == 0)
{
br.Mensagens.Add(BadRequest().ToString());
return(br);
}
#endregion
using (UsuarioAppService appService = new UsuarioAppService(_configuration, _contexto))
{
ResponseBase <UsuarioDTO> dto = ObterUsuarioRequest();
if (dto.Autorizado)
{
appService.UsuarioLogado = dto.Objeto;
br = appService.Editar(id, request);
}
else
{
br.Mensagens = dto.Mensagens;
}
br.Autorizado = dto.Autorizado;
br.TempoLevado = appService.swTempoRequisicao.Elapsed;
return(br);
}
}
public async Task <Respuesta> RegisterUserAsync(string urlBase,
string servicePrefix,
string controller,
UsuarioRequest peticion)
{
try
{
var request = JsonConvert.SerializeObject(peticion);
var content = new StringContent(request, Encoding.UTF8, "application/json");
var client = new HttpClient
{
BaseAddress = new Uri(urlBase)
};
var url = $"{servicePrefix}{controller}";
var response = await client.PostAsync(url, content);
var answer = await response.Content.ReadAsStringAsync();
var obj = JsonConvert.DeserializeObject <Respuesta>(answer);
return(obj);
}
catch (Exception ex)
{
return(new Respuesta
{
EsExitoso = false,
Mensaje = ex.Message,
});
}
}
public async Task <IActionResult> Atualizar([FromBody] UsuarioRequest request)
{
await _service.Atualizar(request.InjectAccount(LoggedLess,
nameof(request.ProprietarioId)));
return(Result(new { Message = "Atualizado." }));
}
public async Task <IActionResult> Administrativo([FromBody] UsuarioRequest param)
{
await _service.Registrar(param.InjectAccount(LoggedLess,
nameof(param.ProprietarioId)), Core.Enums.TipoUsuario.Administrativo);
return(Result(new { Message = "Registrado." }));
}
public UsuarioServicoTests()
{
_usuarioDominioFake = A.Fake <IUsuarioDominio>();
_usuarioServico = new UsuarioServico(_usuarioDominioFake);
_usuario = new AutoFaker <UsuarioRequest>().Generate();
}
public bool InsertDatosUsuario(UsuarioRequest data, string _operation)
{
bool response = false;
try
{
string nombreSp = "[api].[INSERT_DATOS_USUARIO]";
StoreProcedure sp = new StoreProcedure(nombreSp);
sp.AgregarParametro("@NOMBRE", data.nombre.ToUpper(), Direccion.Input);
sp.AgregarParametro("@CORREO_ELECTRONICO", data.correo_Electronico.ToUpper(), Direccion.Input);
sp.AgregarParametro("@CELULAR", data.celular, Direccion.Input);
sp.AgregarParametro("@USER", data.usuario.ToUpper(), Direccion.Input);
sp.AgregarParametro("@PASSWORD", data.password, Direccion.Input);
sp.EjecutarStoreProcedure(strConexion_wpp);
if (sp.Error.Trim() != String.Empty)
{
response = false;
throw new Exception("Procedimiento Almacenado: " + nombreSp + " Descripcion: " + sp.Error.Trim());
}
response = true;
}
catch (Exception ex)
{
Informacion.LogError(LogManager.GetCurrentClassLogger(), GerenteLog.GetObtenerMetodo(), ex);
}
return(response);
}
public UsuarioDTO ObtenerUsuario(UsuarioRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (string.IsNullOrEmpty(request.UsuarioId))
{
throw new ArgumentNullException(nameof(request.UsuarioId));
}
var usuario = _usuarioRepositorio.GetSingle(s => s.UsuarioId == request.UsuarioId);
if (usuario == null)
{
return new UsuarioDTO {
ValidationErrorMessage = "Usuario no existe"
}
}
;
return(new UsuarioDTO
{
UsuarioId = usuario.UsuarioId,
Nombre = usuario.Nombre
});
}
public ContentResult Register(UsuarioRequest req)
{
ContentResult response = new ContentResult {
ContentType = "application/json"
};
try
{
var checkIfExists = _service.FindByLogin(req.Login);
if (checkIfExists != null)
{
response.StatusCode = (int)HttpStatusCode.BadRequest;
response.Content = JsonConvert.SerializeObject("Usuario já existe");
return(response);
}
var result = _service.Create(req);
_uof.Commit();
response.StatusCode = (int)HttpStatusCode.OK;
response.Content = JsonConvert.SerializeObject(result);
return(response);
}
catch (Exception ex)
{
response.StatusCode = (int)HttpStatusCode.BadRequest;
response.Content = ex.Message;
return(response);
}
}
public async Task <UsuarioResponse> Adicionar(UsuarioRequest request)
{
var model = request.MapTo <Usuario>(_mapper);
var responseModel = await _usuarioService.Adicionar(model);
return(responseModel.MapTo <UsuarioResponse>(_mapper));
}
public Response AtualizarUsuario(UsuarioRequest request, Guid idUsuario)
{
if (request == null)
{
AddNotification("AtualizarTarefa", MSG.OBJETO_X0_E_OBRIGATORIO.ToFormat("RegistarVideoRequest"));
return(null);
}
//Cria value objects
Nome nome = new Nome(request.PrimeiroNome, request.UltimoNome);
Email email = new Email(request.Email);
Endereco endereco = new Endereco(request.Logradouro, request.NumeroResid, request.Bairro, request.Cidade, request.Estado, request.Pais, request.Cep);
var usuario = _repositoryUsuario.Obter(idUsuario);
if (usuario == null)
{
AddNotification("Usuario", MSG.X0_NAO_INFORMADO.ToFormat("Usuário"));
}
AddNotifications(usuario);
if (this.IsInvalid())
{
return(null);
}
usuario.AtualizarUsuario(nome, email, endereco);
_repositoryUsuario.Atualizar(usuario);
return((Response)usuario);
}
public IActionResult Delete(UsuarioRequest oUsuarioRequest)
{
Respuesta oResponse = new Respuesta();
try
{
using (TodoListContext db = new TodoListContext())
{
Usuario oUsuario = db.Usuario.Find(oUsuarioRequest.Id);
db.Usuario.Remove(oUsuario);
db.SaveChanges();
oResponse.Result = 1;
oResponse.Message = "Usuario eliminado exitosamente";
return(Ok(oResponse));
}
}
catch (Exception ex)
{
oResponse.Message = ex.Message;
}
return(Ok(oResponse));
}
public void IngresarTest()
{
var data = new List <Usuario>()
{
new Usuario {
Correo = "*****@*****.**", Clave = "sOnLaZjqkhZs2fMsS8eupA=="
}
}.AsQueryable();
var mockSet = new Mock <DbSet <Usuario> >();
mockSet.As <IQueryable <Usuario> >().Setup(x => x.Provider).Returns(data.Provider);
mockSet.As <IQueryable <Usuario> >().Setup(x => x.Expression).Returns(data.Expression);
_contextMock.SetupGet(x => x.Usuarios).Returns(mockSet.Object);
var request = new UsuarioRequest()
{
clave = "123", correo = "*****@*****.**"
};
var response = _biz.Ingresar(request);
Assert.IsTrue(response);
_contextMock.VerifyAll();
}
public IActionResult Edit(UsuarioRequest oUsuarioRequest)
{
Respuesta oResponse = new Respuesta();
try
{
using (TodoListContext db = new TodoListContext())
{
Usuario oUsuario = db.Usuario.Find(oUsuarioRequest.Id);
oUsuario.Nombre = oUsuarioRequest.Nombre;
oUsuario.Password = oUsuarioRequest.Password;
oUsuario.UserName = oUsuarioRequest.UserName;
db.Entry(oUsuario).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
db.SaveChanges();
oResponse.Result = 1;
oResponse.Message = "Usuario modificado exitosamente";
return(Ok(oResponse));
}
}
catch (Exception ex)
{
oResponse.Message = ex.Message;
}
return(Ok(oResponse));
}
public IActionResult EditCliente(UsuarioRequest model)
{
Respuesta <object> oRespuesta = new Respuesta <object>();
try
{
using (usuariosContext db = new usuariosContext())
{
Usuarios oUsuariosSec = db.Usuarios.Find(model.Cedula);
if (oUsuariosSec != null)
{
oRespuesta.Exito = 0;
oRespuesta.Mensaje = "El Usuario no existe";
return(Ok(oRespuesta));
}
Usuarios oUsuarios = new Usuarios();
oUsuarios.Cedula = model.Cedula;
oUsuarios.Nombre = model.Nombre;
oUsuarios.Apellido = model.Apellido;
oUsuarios.Correo = model.Correo;
db.Entry(oUsuarios).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
db.SaveChanges();
oRespuesta.Exito = 1;
}
}
catch (Exception ex)
{
oRespuesta.Mensaje = ex.Message;
}
oRespuesta.Mensaje = "Proceso Exitoso";
return(Ok(oRespuesta));
}
public void ObterInformacaoDoUsuarioLogado()
{
#region
string nome = "administrator";
string email = "root@localhost";
string language = "english";
string timezone = "Asia/Shanghai";
string nomeAcess = "administrator";
string label = "administrator";
string id = "me";
string status = "OK";
#endregion
UsuarioRequest usuarioRequest = new UsuarioRequest(Method.GET, id);
IRestResponse <dynamic> response = usuarioRequest.ExecuteRequest();
Assert.AreEqual(status, response.StatusCode.ToString());
Assert.Multiple(() => {
Assert.AreEqual(nome, response.Data["name"].ToString());
StringAssert.IsMatch("[A-Za-z0-9\\._]+@[A-Za-z]+", response.Data["email"].ToString());
Assert.AreEqual(email, response.Data["email"].ToString());
Assert.AreEqual(language, response.Data["language"].ToString());
Assert.AreEqual(timezone, response.Data["timezone"].ToString());
Assert.AreEqual(nomeAcess, response.Data["access_level"]["name"].ToString());
Assert.AreEqual(label, response.Data["access_level"]["label"].ToString());
});
}
public IActionResult Put(UsuarioRequest request)
{
Reply reply = new Reply();
try
{
using (XTECDigitalContext db = new XTECDigitalContext())
{
Usuario usuario = new Usuario();
usuario.IdRol = request.IdRol;
usuario.Id = request.Id;
db.Entry(usuario).State = Microsoft.EntityFrameworkCore.EntityState.Modified; //le dice a la base de datos que se ha modificado
db.SaveChanges();
reply.conexionSuccess = 1;
reply.message = "Usuario editado";
}
}
catch (Exception ex)
{
reply.conexionSuccess = 0;
reply.message = ex.Message;
}
return(Ok(reply));
}
public UsuarioViewModel GetUsuarioByID(int id, ref string error)
{
UsuarioViewModel resultado = null;
try
{
UsuarioResponse response;
var reqobj = new Usuario()
{
Id = id
};
var req = new UsuarioRequest()
{
Item = reqobj
};
using (var proxy = new ServicioClient())
{
response = proxy.UsuarioBuscarEntidad(req);
}
if (response.Item == null)
{
error = "Usuario no valido";
}
}
catch (Exception ex)
{
error = ex.Message;
}
return(resultado);
}
public IActionResult Authenticate([FromBody] UsuarioRequest usuario)
{
Usuario user = Service.Autenticar(usuario.Email, usuario.Senha);
if (user == null)
{
return(BadRequest(new { message = "Username or password is incorrect" }));
}
var tokenHandler = new JwtSecurityTokenHandler();
var key = config.Value.Secret;
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, user.ID.ToString()),
new Claim(ClaimTypes.Role, user.Perfil.ToString())
}),
Expires = DateTime.UtcNow.AddDays(7),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(Encoding.ASCII.GetBytes(key)), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
return(Ok(new { token = tokenHandler.WriteToken(token), user }));
}
public async Task <IActionResult> PutUsuario([FromRoute] int id, [FromBody] UsuarioRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != request.Id.Value)
{
return(BadRequest("Id para atualizar diferente id da Usuario"));
}
try
{
var response = _service.Atualizar(id, request);
if (!response)
{
return(NotFound("Usuario não cadastro."));
}
return(Ok(response));
}
catch (Exception e)
{
return(BadRequest(e));
}
return(NoContent());
}
public async Task Registrar(UsuarioRequest param, TipoUsuario tipo)
{
var usuario = new Usuario(param.Login, param.Senha, param.Email);
usuario.DefinirTipo(tipo);
var nick = _repoUsuario.Existe(m => m.Login
.Equals(param.Login, StringComparison.InvariantCultureIgnoreCase));
var email = _repoUsuario.Existe(m => m.Email
.Equals(param.Email, StringComparison.InvariantCultureIgnoreCase));
#region - validator -
_notify.When <ServiceUsuario>(nick,
"Login já esta cadastrado.");
_notify.When <ServiceUsuario>(email,
"Email já esta cadastrado.");
_notify.Validate(usuario, new UsuarioValidator());
#endregion
await _repoUsuario.Registrar(usuario);
}
public int InsertUserBL(UsuarioRequest userReq)
{
var usuarioEntity = _mapper.Map <UsuarioEntity>(userReq);
var idUsuario = _usuarioRepository.InserirUsuario(usuarioEntity);
return(idUsuario);
}
public ActionResult Editar(UsuarioRequest request)
{
var response = UsuarioModel.Editar(request);
return Json(response);
}
