public async Task <IActionResult> Put(Guid AlquilerId, [FromBody] AlquilerDTO alquiler)
{
alquiler.AlquiId = AlquilerId;
await Service.Insert(alquiler);
return(Ok(true));
}
public ResponseReserva CreateReserva(AlquilerDTO reserva)
{
ValidateAlquilerDTO(reserva);
if (!reserva.FechaReserva.HasValue)
{
throw new ArgumentException("Fecha de Reserva es requerida como parametro.");
}
if (reserva.FechaReserva.Value < DateTime.Today)
{
throw new ArgumentException("Fecha de Reserva no valida.");
}
var entity = new Alquiler
{
FechaReserva = reserva.FechaReserva,
ClienteId = reserva.Cliente,
EstadoId = 1,
ISBN = reserva.ISBN
};
_repository.Add <Alquiler>(entity);
_libroRepository.LibroDiscountStock(reserva.ISBN);
return(new ResponseReserva
{
Id = entity.Id,
EstadoId = entity.EstadoId,
FechaReserva = entity.FechaReserva.Value,
Cliente = entity.Cliente,
Libro = entity.Libro
});
}
private void cargarDatos(int modo)
{
alquilerModif = gestionAlquileresViewModel.alquiler;
observableCollectionClientes.Add(gestionAlquileresViewModel.alquiler.cliente.nombre);
cmbCliente.SelectedIndex = 0;
txtNif.Text = gestionAlquileresViewModel.alquiler.cliente.nif;
DateTime dt = DateTime.ParseExact(gestionAlquileresViewModel.alquiler.fechaInicio, "dd/MM/yyyy", CultureInfo.InvariantCulture);
dtpInicioContrato.SelectedDate = dt;
DateTime dt2 = DateTime.ParseExact(gestionAlquileresViewModel.alquiler.fechaFin, "dd/MM/yyyy", CultureInfo.InvariantCulture);
dtpFinContrato.SelectedDate = dt2;
txtKilometros.Text = gestionAlquileresViewModel.alquiler.km.ToString();
cmbTipoKm.Text = gestionAlquileresViewModel.alquiler.tipoKm;
txtImporte.Text = gestionAlquileresViewModel.alquiler.importe.ToString();
observableCollectionMatriculas.Add(gestionAlquileresViewModel.alquiler.vehiculo.matricula);
cmbMatricula.SelectedIndex = 0;
txtModelo.Text = gestionAlquileresViewModel.alquiler.vehiculo.modelo;
ocultarMostrar(modo);
}
public ResponseAlquiler CreateAlquiler(AlquilerDTO alquiler)
{
ValidateAlquilerDTO(alquiler);
if (alquiler.FechaAlquiler.HasValue && alquiler.FechaAlquiler.Value < DateTime.Today)
{
throw new ArgumentException("Fecha de Alquiler no valida");
}
if (!alquiler.FechaAlquiler.HasValue)
{
alquiler.FechaAlquiler = DateTime.Now;
}
var entity = new Alquiler
{
FechaAlquiler = alquiler.FechaAlquiler,
ClienteId = alquiler.Cliente,
EstadoId = 2,
FechaDevolucion = alquiler.FechaAlquiler.Value.AddDays(7),
ISBN = alquiler.ISBN
};
_repository.Add <Alquiler>(entity);
_libroRepository.LibroDiscountStock(alquiler.ISBN);
return(new ResponseAlquiler
{
Id = entity.Id,
Cliente = entity.Cliente,
EstadoId = entity.EstadoId,
FechaAlquiler = entity.FechaAlquiler.Value,
FechaDevolucion = entity.FechaDevolucion.Value,
Libro = entity.Libro
});
}
private void ValidateAlquilerDTO(AlquilerDTO alquiler)
{
if (!_clienteQuery.ClienteExists(alquiler.Cliente))
{
throw new ArgumentException("Cliente no existente");
}
if (!_libroquery.LibroExists(alquiler.ISBN))
{
throw new ArgumentException("ISBN no válido");
}
if (!_libroquery.LibroHasStock(alquiler.ISBN))
{
throw new ArgumentException("Libro no tiene stock disponible");
}
}
public IActionResult Post(AlquilerDTO alquilerDTO)
{
try
{
ResponseBadRequest validar = alquilerService.ValidarAlquiler(alquilerDTO);
return(validar == null ? new JsonResult(alquilerService.CreateAlquiler(alquilerDTO))
{
StatusCode = 201
} : new JsonResult(validar)
{
StatusCode = 400
});
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public GenericCreatedResponseDTO CreateAlquiler(AlquilerDTO alquiler)
{
if (alquiler.FechaAlquiler.IsNullOrEmpty())
{
DateTime.TryParse(alquiler.FechaReserva, out DateTime fechaValidada);
var entity = new Alquiler
{
ClienteID = alquiler.ClienteID,
ISBN = alquiler.ISBN,
EstadoID = 1,
FechaReserva = fechaValidada
};
_repository.Add <Alquiler>(entity);
Libro libro = _query.GetLibro(alquiler.ISBN);
libro.Stock -= 1;
_repository.Update <Libro>(libro);
_repository.SaveChanges();
return(new GenericCreatedResponseDTO {
Entity = "Alquiler", Id = entity.AlquilerId.ToString()
});
}
else
{
DateTime.TryParse(alquiler.FechaAlquiler, out DateTime fechaValidada);
var entity = new Alquiler
{
ClienteID = alquiler.ClienteID,
ISBN = alquiler.ISBN,
EstadoID = 2,
FechaAlquiler = fechaValidada,
FechaDevolucion = fechaValidada.AddDays(7)
};
Libro libro = _query.GetLibro(alquiler.ISBN);
_repository.Add <Alquiler>(entity);
libro.Stock -= 1;
_repository.Update <Libro>(libro);
_repository.SaveChanges();
return(new GenericCreatedResponseDTO {
Entity = "Alquiler", Id = entity.AlquilerId.ToString()
});
}
}
private Alquileres Proceso(AlquilerDTO procesoDTO, bool descuento)
{
Alquileres alqui = new Alquileres();
{
alqui.Cliente = _clienteQuery.getClienteId(procesoDTO.DNI);
alqui.ISBN = procesoDTO.ISBN;
if (descuento)
{
_libroQuery.DescuentoStock(procesoDTO.ISBN);
}
else
{
_libroQuery.AumentoStock(procesoDTO.ISBN);
}
alqui.Estado = procesoDTO.Estado;
alqui.FechaAlquiler = procesoDTO.FechaAlquiler;
alqui.FechaReserva = procesoDTO.FechaReserva;
alqui.FechaDevolucion = procesoDTO.FechaDevolucion;
};
return(alqui);
}
/// <summary>
/// Parseo de DTO a Modelo
/// </summary>
/// <param name="alquilerDTO"></param>
/// <returns></returns>
private Alquiler transformAlquilerDTOToAlquiler(AlquilerDTO alquilerDTO)
{
Alquiler alquiler = new Alquiler();
try
{
alquiler.idVehiculo = alquilerDTO.idVehiculo;
alquiler.idCliente = alquilerDTO.idCliente;
alquiler.fechaInicio = alquilerDTO.fechaInicio;
alquiler.fechaFin = alquilerDTO.fechaFin;
alquiler.km = alquilerDTO.km;
alquiler.tipoKm = alquilerDTO.tipoKm;
alquiler.importe = alquilerDTO.importe;
alquiler.tipoImporte = alquilerDTO.tipoImporte;
}
catch (System.Exception)
{
alquiler = null;
}
return(alquiler);
}
public IActionResult Post(AlquilerDTO alquiler)
{
try
{
if (alquiler.FechaReserva.HasValue)
{
return(new JsonResult(_service.CreateReserva(alquiler))
{
StatusCode = 201
});
}
else
{
return(new JsonResult(_service.CreateAlquiler(alquiler))
{
StatusCode = 201
});
}
}
catch (Exception e)
{
return(BadRequest(new { error = true, message = e.Message }));
}
}
public ResponseBadRequest ValidarAlquiler(AlquilerDTO alquiler)
{
if (!_query.ExisteCliente(alquiler.ClienteID))
{
return new ResponseBadRequest {
CódigoError = 400, Error = "No existe un cliente registrado con el ID ingresado."
}
}
;
if (!_query.ExisteLibro(alquiler.ISBN))
{
return new ResponseBadRequest {
CódigoError = 400, Error = "No existe un libro registrado con el Isbn ingresado"
}
}
;
if (!_query.ExisteStock(alquiler.ISBN))
{
return new ResponseBadRequest {
CódigoError = 400, Error = "No existe stock del libro que desea alquilar o reservar"
}
}
;
if (alquiler.FechaAlquiler.IsNullOrEmpty() && alquiler.FechaReserva.IsNullOrEmpty())
{
return new ResponseBadRequest {
CódigoError = 400, Error = "No ingresó ninguna fecha. Recuerde ingresar la fecha correspondiente al tipo de registro que desea realizar: alquiler o reserva."
}
}
;
if (!alquiler.FechaAlquiler.IsNullOrEmpty() && !alquiler.FechaReserva.IsNullOrEmpty())
{
return new ResponseBadRequest {
CódigoError = 400, Error = "Solo se puede ingresar una fecha. Recuerde ingresar la fecha correspondiente al tipo de registro que desea realizar: alquiler o reserva."
}
}
;
if (alquiler.FechaAlquiler.IsNullOrEmpty())
{
if (!Validacion.ValidarFecha(alquiler.FechaReserva))
{
return new ResponseBadRequest {
CódigoError = 400, Error = "La fecha ingresada no se expresó en un formato válido. Recuerde utilizar el formato DD/MM/AAAA"
}
}
}
;
if (alquiler.FechaReserva.IsNullOrEmpty())
{
if (!Validacion.ValidarFecha(alquiler.FechaAlquiler))
{
new ResponseBadRequest {
CódigoError = 400, Error = "La fecha ingresada no se expresó en un formato válido. Recuerde utilizar el formato DD/MM/AAAA"
}
}
}
;
return(null);
}
public async Task <IActionResult> Post([FromBody] AlquilerDTO alquiler)
{
await Service.Insert(alquiler);
return(Ok(true));
}
public GestionAlquileresViewModel(AlquilerDTO alquilerDTO)
{
_alquiler = alquilerDTO;
}
/// <summary>
/// Con el id "null" guarda un nuevo objeto y, en caso contrario, modifica el objeto de la BD
/// </summary>
/// <param name="alquiler">objeto de BD</param>
/// <param name="id"></param>
/// <returns>ServerResponseAlquiler</returns>
public ServerResponseAlquiler Save(AlquilerDTO alquilerDTO, string id)
{
ServerResponseAlquiler serverResponseAlquiler;
try
{
OauthToken oauthToken = ServerService.obtenerToken();
if (null != oauthToken)
{
var url = Constantes.SERVIDOR + ALQUILER + "save/" + id;
var httpRequest = (HttpWebRequest)WebRequest.Create(url);
httpRequest.Method = "POST";
httpRequest.Headers["Authorization"] = "Bearer " + oauthToken.access_token;
httpRequest.ContentType = "application/json";
Alquiler alquiler = transformAlquilerDTOToAlquiler(alquilerDTO);
if (null != alquiler)
{
var data = JsonSerializer.Serialize <Alquiler>(alquiler);
using (var streamWriter = new StreamWriter(httpRequest.GetRequestStream()))
{
streamWriter.Write(data);
}
var httpResponse = (HttpWebResponse)httpRequest.GetResponse();
using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
{
var result = streamReader.ReadToEnd();
serverResponseAlquiler = JsonSerializer.Deserialize <ServerResponseAlquiler>(result);
}
//Console.WriteLine(httpResponse.StatusCode);
}
else
{
serverResponseAlquiler = new ServerResponseAlquiler();
ErrorBean error = new ErrorBean();
error.code = MessageExceptions.SERVER_ERROR;
error.message = MessageExceptions.MSSG_SERVER_ERROR;
serverResponseAlquiler.error = error;
}
}
else
{
serverResponseAlquiler = new ServerResponseAlquiler();
ErrorBean error = new ErrorBean();
error.code = MessageExceptions.SERVER_ERROR;
error.message = MessageExceptions.MSSG_SERVER_ERROR;
serverResponseAlquiler.error = error;
}
}
catch (System.Exception)
{
serverResponseAlquiler = new ServerResponseAlquiler();
ErrorBean error = new ErrorBean();
error.code = MessageExceptions.SERVER_ERROR;
error.message = MessageExceptions.MSSG_SERVER_ERROR;
serverResponseAlquiler.error = error;
}
return(serverResponseAlquiler);
}
public async Task Update(AlquilerDTO entityDTO)
{
var entity =
Builders.GenericBuilder.builderDTOEntity <TAlquiler, AlquilerDTO>(entityDTO);
await repository.Save(entity);
}
private void ocultarMostrar(int modo)
{
switch (modo)
{
case 1:
//panel.IsEnabled = false;
//gestionAlquileresViewModel.PanelLoading = true;
//Ocultar
btnModificar.Visibility = Visibility.Hidden;
btnVerCliente.Visibility = Visibility.Hidden;
btnVerVehiculo.Visibility = Visibility.Hidden;
//Por defecto
cmbTipoKm.SelectedIndex = 0;
alquilerModif = new AlquilerDTO();
observableCollectionClientes.Clear();
observableCollectionMatriculas.Clear();
cargaComboClientes();
cargaComboMatriculas();
//Thread t = new Thread(new ThreadStart(() =>
//{
// Dispatcher.Invoke(new Action(() => { gestionAlquileresViewModel.cargaComboClientes(); }));
// Dispatcher.Invoke(new Action(() => { gestionAlquileresViewModel.cargaComboMatriculas(); }));
// Dispatcher.Invoke(new Action(() => { cmbCliente.SelectedIndex = 0; }));
// Dispatcher.Invoke(new Action(() => { cmbMatricula.SelectedIndex = 0; }));
// Dispatcher.Invoke(new Action(() => { panel.IsEnabled = true; }));
// Dispatcher.Invoke(new Action(() => { gestionAlquileresViewModel.PanelLoading = false; }));
//}));
//t.Start();
break;
case 2:
//Ocultar
btnAceptarAlquileres.Visibility = Visibility.Hidden;
btnCancelarAlquileres.Visibility = Visibility.Hidden;
//Mostrar
btnModificar.Visibility = Visibility.Visible;
btnVerCliente.Visibility = Visibility.Visible;
btnVerVehiculo.Visibility = Visibility.Visible;
//Deshabilitar
cmbCliente.IsEnabled = false;
dtpInicioContrato.IsEnabled = false;
dtpFinContrato.IsEnabled = false;
txtKilometros.IsEnabled = false;
txtImporte.IsEnabled = false;
cmbMatricula.IsEnabled = false;
cmbTipoKm.IsEnabled = false;
break;
case 3:
//Ocultar
btnModificar.Visibility = Visibility.Hidden;
btnVerCliente.Visibility = Visibility.Hidden;
btnVerVehiculo.Visibility = Visibility.Hidden;
//Mostrar
btnAceptarAlquileres.Visibility = Visibility.Visible;
btnCancelarAlquileres.Visibility = Visibility.Visible;
//Habilitar
cmbCliente.IsEnabled = true;
dtpInicioContrato.IsEnabled = true;
dtpFinContrato.IsEnabled = true;
txtKilometros.IsEnabled = true;
txtImporte.IsEnabled = true;
cmbMatricula.IsEnabled = true;
cmbTipoKm.IsEnabled = true;
break;
}
}
public ResponseDTO Insertar(AlquilerDTO alquiler)
{
using (db = new Contexto())
{
try
{
// preparar el cliente para guardar
Alquiler nuevo = new Alquiler();
nuevo.AlquilerId = alquiler.AlquilerId;
nuevo.Direccion = alquiler.Direccion;
nuevo.nombreCliente = alquiler.nombreCliente;
nuevo.Telefono = alquiler.Telefono;
nuevo.fechaFinal = alquiler.fechaFinal;
nuevo.fechaInicial = alquiler.fechaInicial;
// String x = DateTime.Now.ToString();
// Separando el string con los tipos de equipos
String[] tiposEquipo = alquiler.equipos.Split(new Char[] { ',' });
int[] cantidadTipo = new int[3];
foreach (String tipo in tiposEquipo)
{
if (tipo != "")
{
if (tipo == "Proyector")
{
cantidadTipo[0] = cantidadTipo[0] + 1;
}
else if (tipo == "Luces")
{
cantidadTipo[1] = cantidadTipo[0] + 1;
}
else if (tipo == "Sonido")
{
cantidadTipo[2] = cantidadTipo[0] + 1;
}
}
}
List <Equipos> listadoProyectores = Disponibles(alquiler.fechaInicial, alquiler.fechaFinal, "Proyector");
List <Equipos> listadoLuces = Disponibles(alquiler.fechaInicial, alquiler.fechaFinal, "Luces");
List <Equipos> listadoSonido = Disponibles(alquiler.fechaInicial, alquiler.fechaFinal, "Sonido");
if (cantidadTipo[0] > listadoProyectores.Count)
{
response.Mensaje = "No hay Proyectores Disponibles";
response.FilasAfectadas = 0;
response.Error.Add(new ErrorDTO()
{
Menssage = "No hay Proyectores Disponibles"
});
return(response);
}
else if (cantidadTipo[1] > listadoLuces.Count)
{
response.Mensaje = "No hay Luces Disponibles";
response.FilasAfectadas = 0;
response.Error.Add(new ErrorDTO()
{
Menssage = "No hay Proyectores Disponibles"
});
return(response);
}
else if (cantidadTipo[2] > listadoSonido.Count)
{
response.Mensaje = "No hay Sonido Disponibles";
response.FilasAfectadas = 0;
response.Error.Add(new ErrorDTO()
{
Menssage = "No hay Proyectores Disponibles"
});
return(response);
}
for (var i = 0; i < cantidadTipo[0]; i++)
{
listadoProyectores[i].Alquilers.Add(nuevo);
}
for (var i = 0; i < cantidadTipo[1]; i++)
{
listadoLuces[i].Alquilers.Add(nuevo);
}
for (var i = 0; i < cantidadTipo[2]; i++)
{
listadoSonido[i].Alquilers.Add(nuevo);
}
// db.Alquiler.Add(nuevo);
// preparar la respuesta
response.Mensaje = "Alquiler Insertado";
response.FilasAfectadas = db.SaveChanges();
}
catch (System.Data.Entity.Validation.DbEntityValidationException ex)
{
response.Mensaje = ex.Message;
response.FilasAfectadas = 0;
}
catch (Exception ex)
{
response.Mensaje = ex.Message;
response.FilasAfectadas = 0;
}
return(response);
}
}
public string RegistrarProceso(AlquilerDTO procesoDTO)
{
if (_clienteQuery.ExisteCliente(procesoDTO.DNI) && _libroQuery.ExisteIsbn(procesoDTO.ISBN))
{
switch (procesoDTO.Estado)
{
case 1:
if (_libroQuery.ExisteStock(procesoDTO.ISBN))
{
Alquileres alquiler = Proceso(procesoDTO, true);
_repository.Add <Alquileres>(alquiler);
return("El alquiler se registro exitosamente");
}
else
{
return("No contamos con stock para realizar el alquiler");
}
case 2:
if (_libroQuery.ExisteStock(procesoDTO.ISBN))
{
Alquileres reserva = Proceso(procesoDTO, true);
_repository.Add <Alquileres>(reserva);
return("La reserva se registro exitosamente");
}
else
{
return("No contamos con stock para realizar la reserva");
}
case 3:
if (_alquileresQuery.ExisteReserva(_clienteQuery.getClienteId(procesoDTO.DNI), procesoDTO.ISBN))
{
Alquileres cancelacion = Proceso(procesoDTO, false);
int id = _alquileresQuery.getIdReservaAntigua(_clienteQuery.getClienteId(procesoDTO.DNI), procesoDTO.ISBN);
_alquileresQuery.ModificarReserva(id, cancelacion);
return("Se cancelo la reserva");
}
else
{
return("El cliente y el libro no tienen reserva asociada para cancelar");
}
default:
return("Ocurrio un error inesperado vuelva a intentarlo por favor");
}
}
else
{
if (!_clienteQuery.ExisteCliente(procesoDTO.DNI))
{
return("El dni ingresado no pertence a ningun cliente registrado");
}
if (!_libroQuery.ExisteIsbn(procesoDTO.ISBN))
{
return("El isbn ingresado no pertence a ningun libro registrado");
}
else
{
return("Ocurrio un error inesperado vuelva a intentarlo por favor");
}
}
}
