Example #1
0
        public HttpResponseMessage Put(int usuarioId, [FromBody] UsuarioUpdateDto usuario)
        {
            if (usuario == null)
            {
                return(Request.CreateResponse(HttpStatusCode.BadRequest));
            }

            if (usuario.Nome == usuario.Sobrenome)
            {
                ModelState.AddModelError("Sobrenome", "O sobrenome informado deverá ser diferente do nome...");
            }

            if (!ModelState.IsValid)
            {
                return(Request.CreateResponse(HttpStatusCode.BadRequest));
            }

            if (!_usuarioRepository.UsuarioExiste(usuarioId))
            {
                return(Request.CreateResponse(HttpStatusCode.NotFound));
            }

            var usuarioEntity = _usuarioRepository.GetUsuario(usuarioId);

            if (usuarioEntity == null)
            {
                return(Request.CreateResponse(HttpStatusCode.NotFound));
            }

            AutoMapper.Mapper.Map(usuario, usuarioEntity);

            if (!_usuarioRepository.Save())
            {
                return(Request.CreateResponse(HttpStatusCode.InternalServerError, "Ocorreu um problema com a sua solicitação..."));
            }

            if (!_usuarioRepository.DetalheExiste(usuarioId))
            {
                _usuarioRepository.AddDetalheUsuario(usuarioEntity.Id, new Entities.DetalheUsuario()
                {
                    UsuarioId = usuarioEntity.Id, Telefone = usuario.Telefone, Endereco = usuario.Endereco
                });
            }
            else
            {
                var DetalheEntity = _usuarioRepository.GetDetalhe(usuarioId);
                _usuarioRepository.DeleteDetalhe(DetalheEntity);
                _usuarioRepository.AddDetalheUsuario(usuarioEntity.Id, new Entities.DetalheUsuario()
                {
                    UsuarioId = usuarioEntity.Id, Telefone = usuario.Telefone, Endereco = usuario.Endereco
                });
            }

            if (!_usuarioRepository.Save())
            {
                return(Request.CreateResponse(HttpStatusCode.InternalServerError, "Ocorreu um problema com a sua solicitação..."));
            }

            return(Request.CreateResponse(HttpStatusCode.NoContent));
        }
Example #2
0
        public IActionResult Update([FromBody] UsuarioUpdateDto dto)
        {
            if (dto == null)
            {
                return(BadRequest(StatusCodes.Status406NotAcceptable));
            }

            if (repository.Exist(x => x.UsuarioVar == dto.UsuarioVar && x.UsuarioIdInt != dto.UsuarioIdInt))
            {
                return(BadRequest(this.response.ResponseValues(StatusCodes.Status406NotAcceptable, null, "El Usuario Ya Existe!!")));
            }

            var usuario = mapper.Map <Usuario>(dto);
            var update  = repository.GetByValues(x => x.UsuarioIdInt == dto.UsuarioIdInt).FirstOrDefault();

            usuario.FechaAltaDate = update.FechaAltaDate;

            if (!repository.Update(usuario, usuario.UsuarioIdInt))
            {
                return(BadRequest(this.response.ResponseValues(StatusCodes.Status500InternalServerError, null, $"Algo salió mal al actualizar el registro: {dto.NombreVar}")));
            }


            return(Ok(
                       response.ResponseValues(this.Response.StatusCode,
                                               mapper.Map <Usuario>(repository.GetById(usuario.UsuarioIdInt))
                                               )
                       ));
        }
        public UsuarioUpdateDto Update(string Dni, UsuarioUpdateDto UsuarioUpdateDto)
        {
            var entry = _context.Usuarios.Single(x => x.Dni == Dni);

            if (CorreoValido(UsuarioUpdateDto.Correo) == false)
            {
                throw new EmailWrongFormatException();
            }
            if (UsuarioUpdateDto.NuevaContrasena != UsuarioUpdateDto.RepetirContrasena)
            {
                throw new NewPasswordNotMatchException();
            }
            if (Encriptar(UsuarioUpdateDto.Contrasena) != entry.Contrasena)
            {
                throw new ActualPasswordNotMatchException();
            }
            if (UsuarioUpdateDto.Contrasena != null)
            {
                if (UsuarioUpdateDto.Correo != null)
                {
                    entry.Correo = UsuarioUpdateDto.Correo;
                }
                if (UsuarioUpdateDto.NuevaContrasena != null)
                {
                    entry.Contrasena = Encriptar(UsuarioUpdateDto.NuevaContrasena);
                }
            }

            _context.SaveChanges();
            return(UsuarioUpdateDto);
        }
        public IActionResult ActualizarUsuario(int usuarioId, [FromBody] UsuarioUpdateDto UsuarioDto)
        {
            try {
                if (UsuarioDto == null || usuarioId != UsuarioDto.idusuario)
                {
                    return(BadRequest(ModelState));//400 Bad Request. El servidor no puede o no va a procesar el request por un error de sintaxis del cliente.
                }

                var usuario = new Usuario {
                    idusuario     = UsuarioDto.idusuario,
                    usuario_user  = UsuarioDto.usuario_user,
                    nombrefoto    = UsuarioDto.nombrefoto,
                    idtipousuario = UsuarioDto.idtipousuario
                };

                var usuarioUpdate = _userRepo.ActualizarUsuario(usuario, UsuarioDto.usuario_clave);//devuelve true si todo esta bien

                if (usuarioUpdate == false)
                {
                    ModelState.AddModelError("", $"Algo salio mal, actualizano el registro{usuario.idusuario}");
                    //return StatusCode(500, ModelState);
                }
                return(NoContent()); //204 No Content. El request se ha procesado correctamente, pero no devuelve ningún contenido.
            }
            catch (Exception)
            {
                return(StatusCode(StatusCodes.Status500InternalServerError, "Error interno en el servidor.")); //500 Internal Server Error. Error genérico, cuando se ha dado una condición no esperada y no se puede concretar el mensaje.
            }
        }
Example #5
0
        public void Update(string id, UsuarioUpdateDto dto)
        {
            if (id != dto.Id)
            {
                throw new Exception(Messages.InconsistencyRequest);
            }

            ValidateDocumentHelper.ValidateCpf(dto.Cpf);

            if (ExistsUsuario(id))
            {
                var db = _uow.UsuarioRepository.GetById(id);

                db.Nome          = dto.Nome;
                db.Sobrenome     = dto.Sobrenome;
                db.Sexo          = dto.Sexo;
                db.Rg            = dto.Rg;
                db.Cpf           = dto.Cpf;
                db.Cep           = dto.Cep;
                db.Logradouro    = dto.Logradouro;
                db.Bairro        = dto.Bairro;
                db.Numero        = dto.Numero;
                db.Nacionalidade = dto.Nacionalidade;
                db.Telefone      = dto.Telefone;
                db.Celular       = dto.Celular;

                _uow.UsuarioRepository.Edit(db);
                _uow.SaveChanges();
            }
            else
            {
                throw new Exception(Messages.NotExistsUser);
            }
        }
Example #6
0
        public async void Update(UsuarioUpdateDto usr)
        {
            var Usuario = _mapp.Map <Usuario>(usr);

            _usuarioRepository.Update(Usuario);
            await _unit.Commit();
        }
        public async Task Update(int id, UsuarioUpdateDto model)
        {
            var entry = await _context.Usuarios.SingleAsync(x => x.UsuarioId == id);

            entry.Nombre          = model.Nombre;
            entry.ApellidoPaterno = model.ApellidoPaterno;
            entry.ApellidoMaterno = model.ApellidoMaterno;
            entry.DNI             = model.DNI;
            entry.RUC             = model.RUC;

            await _context.SaveChangesAsync();
        }
 public ActionResult Update(string Dni, UsuarioUpdateDto UsuarioUpdateDto)
 {
     try
     {
         return(Ok(_usuarioService.Update(Dni, UsuarioUpdateDto)));
     }
     catch (NewPasswordNotMatchException NewPasswordNotMatch) {
         return(BadRequest(NewPasswordNotMatch.ExceptionDto));
     }
     catch (ActualPasswordNotMatchException ActualPasswordNotMatch)
     {
         return(BadRequest(ActualPasswordNotMatch.ExceptionDto));
     }
     catch (EmailWrongFormatException EmailWrongFormat)
     {
         return(BadRequest(EmailWrongFormat.ExceptionDto));
     }
 }
Example #9
0
 public IActionResult Put(string id, [FromBody] UsuarioUpdateDto dto)
 {
     _business.Update(id, dto);
     return(Ok(true));
 }
Example #10
0
        public async Task <ActionResult> Update(int id, UsuarioUpdateDto model)
        {
            await _usuarioService.Update(id, model);

            return(NoContent());
        }