public void regresarAlquiler(int id)
{
Alquiler al = mostrarAlquilerConID(id);
Cliente c = clienteRepo.getClienteConID(al.clienteCodigo);
Producto p = productoRepo.getProductoConID(al.productoCodigo);
TimeSpan dateSpan = DateTime.Now - al.fechaDeAlquiler;
if (al.estado == AlquilerEstado.Extraviado)
{
p.regresarExtraviado();
}
else
{
p.regresarAlquiler();
}
if ((dateSpan.Days - al.tiempoDeAlquiler) >= 1)
{
al.tiempoDeAlquiler += (dateSpan.Days - al.tiempoDeAlquiler);
al.totalPago = calcularPago(p, al);
}
al.estado = AlquilerEstado.Regresado;
if (c.estado == ClienteEstado.Bloqueado)
{
c.estado = ClienteEstado.Activo;
}
actualizarAlquiler(al, al.alquilerCodigo);
clienteRepo.actualizarCliente(c, al.clienteCodigo);
informarAProductoRepo(p, al.productoCodigo);
}
public async Task <IActionResult> Edit(long id, [Bind("AlquilerId,Precio,Inicio,Fin,InquilinoId,InmuebleId")] Alquiler alquiler)
{
if (id != alquiler.AlquilerId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(alquiler);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AlquilerExists(alquiler.AlquilerId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["InmuebleId"] = new SelectList(_context.Inmueble, "InmuebleId", "Direccion", alquiler.InmuebleId);
ViewData["InquilinoId"] = new SelectList(_context.Inquilino, "InquilinoId", "InquilinoId", alquiler.InquilinoId);
return(View(alquiler));
}
public ActionResult Edit(int id, Alquiler alquiler)
{
//var miPropietario = repositorio.ObtenerPorId(id);
if (id != alquiler.AlquilerId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
repositorio.Modificacion(alquiler);
}
catch (Exception ex)
{
ViewBag.Error = ex.Message;
ViewBag.StackTrate = ex.StackTrace;
return(View());
}
return(RedirectToAction(nameof(Index)));
}
return(View());
}
public async Task <IActionResult> Edit(Guid id, [Bind("Id,PeliculaId,ClienteId,FechaAlta,FechaVencimiento,PrecioOriginal,DevolucionId")] Alquiler alquiler)
{
if (id != alquiler.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(alquiler);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AlquilerExists(alquiler.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["ClienteId"] = new SelectList(_context.Clientes, "Id", "Apellido", alquiler.ClienteId);
ViewData["DevolucionId"] = new SelectList(_context.Devoluciones, "Id", "Id", alquiler.DevolucionId);
ViewData["PeliculaId"] = new SelectList(_context.Peliculas, "Id", "Id", alquiler.PeliculaId);
return(View(alquiler));
}
public ActionResult Create(IFormCollection collection)
{
try
{
// TODO: Add insert logic here
AlquilerData alquilerData = new AlquilerData();
System.Diagnostics.Debug.WriteLine("COMPLETO 0.5: " + Request.Query["IdAlquiler"]);
System.Diagnostics.Debug.WriteLine("COMPLETOOOOO" + Request.Form["IdAlquiler"].ToString());
Alquiler alquiler = alquilerData.obtenerAlquiler(Convert.ToInt32(Request.Form["IdAlquiler"]));
System.Diagnostics.Debug.WriteLine("IDDDDDDDDDDDDD: " + Convert.ToInt32(Request.Form["IdAlquiler"]));
System.Diagnostics.Debug.WriteLine("COMPLETO 1");
Pagos pago = new Pagos {
NroPago = new PagosData().obtenerNumerosDePagos(Convert.ToInt32(Request.Form["IdAlquiler"])) + 1,
Fecha = Convert.ToDateTime(Request.Form["Fecha"]),
Importe = Convert.ToDouble(Request.Form["Importe"]),
Alquiler = alquiler,
};
System.Diagnostics.Debug.WriteLine("COMPLETO 2");
PagosData pagosData = new PagosData();
pagosData.crear(pago);
System.Diagnostics.Debug.WriteLine("COMPLETO 3");
return(RedirectToAction(nameof(Index), "Pagos", new { IdAlquiler = Convert.ToInt32(Request.Form["IdAlquiler"]) }));
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine("EXCEPCION :" + e.Message);
return(View());
}
}
public static Alquiler GetAlquilerByID(int AlquilerId)
{
if (AlquilerId <= 0)
{
throw new ArgumentException("El AlquilerId debe ser mayor a 0");
}
AlquilerTableAdapter adapter = new AlquilerTableAdapter();
Alquiler_DS.AlquilerDataTable table = adapter.GetAlquilerByID(AlquilerId);
if (table.Rows.Count == 0)
{
return(null);
}
Alquiler_DS.AlquilerRow row = table[0];
Alquiler obj = new Alquiler()
{
AlquilerId = row.AlquilerId,
TotalPago = row.totalPago,
FechaAlqui = row.fechaAlqui,
FechaDevol = row.fechaDevol,
TarjetaCredito = row.tarjetaCredito,
CodigoTarjeta = row.codigoTarjeta,
Estado = row.estado,
UserId = row.UserId,
PeliculaId = row.peliculaId
};
return(obj);
}
public bool verificarVideo(Alquiler alquiler)
{
var lista = new List <Alquiler>();
var sql = "SELECT ID, UserId ,VideoId FROM dbo.Alquileres WHERE UserId = @userid AND VideoId = @videoid";
var cmd = new SqlCommand(sql);
cmd.Parameters.AddWithValue("@userid", alquiler.UserId);
cmd.Parameters.AddWithValue("@videoid", alquiler.VideoId);
using (var sqlConnection = new SqlConnection(ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString.ToString()))
{
cmd.Connection = sqlConnection;
sqlConnection.Open();
var reader = cmd.ExecuteReader();
if (reader.Read())
{
var p = new Alquiler();
p.ID = reader.GetInt32(0);
p.UserId = reader.GetString(1);
p.VideoId = reader.GetInt32(2);
return(true);
}
sqlConnection.Close();
return(false);
}
}
public ActionResult Create(Alquiler alquiler)
{
try
{
if (ModelState.IsValid)
{
repositorio.Alta(alquiler);
TempData["Id"] = "Contrato de alquiler agregado correctamente";
return(RedirectToAction(nameof(Index)));
}
else
{
ViewBag.inmueble = repoInmueble.BuscarDisponibles();
ViewBag.inquilino = repoInquilino.ObtenerTodos();
return(View());
}
//}
//else
//{
// TempData["Mensaje"] = "Inmueble y/o Inquilino inexistente";
// return RedirectToAction(nameof(Index));
//}
}
catch (Exception ex)
{
ViewBag.inmueble = repoInmueble.BuscarDisponibles();
ViewBag.inquilino = repoInquilino.ObtenerTodos();
ViewBag.Error = "Inmueble y/o Inquilino inexistente";
ViewBag.StackTrate = ex.StackTrace;
return(View());
}
}
private void btnGuardar_Click(object sender, EventArgs e)
{
lblMensaje.Text = "";
abo = new AlquilerBO();
Alquiler a = new Alquiler();
a.Nombre = txtNombre.Text.Trim();
a.Fecha = Fecha.Value.ToString("yyyy-MM-dd");
a.Lugar = txtLugar.Text.Trim();
a.Telefono = Int32.Parse(txtTelefono.Text.Trim());
a.Mesas = Int32.Parse(txtMesa.Text.Trim());
a.Sillas = Int32.Parse(txtSilla.Text.Trim());
a.Manteles = Int32.Parse(txtMantel.Text.Trim());
a.Lasos = Int32.Parse(txtLasos.Text.Trim());
a.Cobertores = Int32.Parse(txtCobertores.Text.Trim());
a.SobreMantel = Int32.Parse(txtSobreM.Text.Trim());
a.SillasVerdes = Int32.Parse(txtSillaV.Text.Trim());
a.SillasBlancas = Int32.Parse(txtSillaB.Text.Trim());
a.Total = Int32.Parse(lblmsj.Text.Trim());
abo.Registrar(a);
lblMensaje.Text = "Alquiler registrado exitosamente";
btnGuardar.Enabled = false;
txtNombre.Text = "";
txtLugar.Text = "";
txtTelefono.Text = "";
txtMantel.Text = "";
txtSilla.Text = "";
txtSillaB.Text = "";
txtSillaV.Text = "";
txtMesa.Text = "";
txtLasos.Text = "";
txtCobertores.Text = "";
txtSobreM.Text = "";
lblmsj.Text = "";
}
public int anadirAlquiler(int productoID, int clienteID, DateTime fecha, int tiempo)
{
Cliente c = clienteRepo.getClienteConID(clienteID);
Producto p = productoRepo.getProductoConID(productoID);
if (c.estado == ClienteEstado.Activo)
{
if (p.disponible > 0)
{
Alquiler al = new Alquiler();
al.clienteCodigo = clienteID;
al.productoCodigo = productoID;
al.fechaDeAlquiler = fecha;
al.tiempoDeAlquiler = tiempo;
al.descuento = calcularDescuento(c);
al.totalPago = calcularPago(p, al);
al.estado = AlquilerEstado.Alquilado;
p.anadirAlquiler();
informarAProductoRepo(p, al.productoCodigo);
return(alquilerRepo.anadirAlquiler(al));
}
else
{
throw new Exception("Este producto no esta disponible.");
}
}
else
{
throw new Exception("Este cliente esta bloqueado.");
}
}
public ActionResult Create(Alquiler alquiler)
{
try
{
repoInmueble.CambioDisponible(alquiler.IdInmueble, "NO");
if (ModelState.IsValid)
{
repositorio.Alta(alquiler);
TempData["Alta"] = "Contrato de alquiler agregado correctamente";
return(RedirectToAction(nameof(Index)));
}
else
{
repoInmueble.CambioDisponible(alquiler.IdInmueble, "SI");
ViewBag.inmueble = repoInmueble.ObtenerTodos();
ViewBag.inquilino = repoInquilino.ObtenerTodos();
return(View());
}
}
catch (Exception ex)
{
ViewBag.inmueble = repoInmueble.ObtenerTodos();
ViewBag.inquilino = repoInquilino.ObtenerTodos();
ViewBag.Error = ex.Message;
ViewBag.StackTrate = ex.StackTrace;
return(View());
}
}
public async Task <bool> Crear(Alquiler alquiler)
{
string peticion = "INSERT INTO alquileres " +
"VALUES (default, @matricula, @dni, @fechaInicio, @fechaFin, @importe)";
var conexion = ContextoBD.GetInstancia().GetConexion();
conexion.Open();
MySqlCommand command = new MySqlCommand(peticion, conexion);
command.Parameters.AddWithValue("@matricula", alquiler.Vehiculo.Matricula);
command.Parameters.AddWithValue("@dni", alquiler.Cliente.Dni);
command.Parameters.AddWithValue("@fechaInicio", alquiler.FechaInicio);
command.Parameters.AddWithValue("@fechaFin", alquiler.FechaFin);
command.Parameters.AddWithValue("@importe", alquiler.Importe);
command.Prepare();
try
{
int result = await command.ExecuteNonQueryAsync();
}
catch (DbException ex)
{
throw ex;
}
finally
{
conexion.Close();
}
return(true);
}
public static Alquiler GetTransactionAlq(int UserId, int PeliculaId)
{
AlquilerTableAdapter adapter = new AlquilerTableAdapter();
Alquiler_DS.AlquilerDataTable table = adapter.ExistAlquiler(UserId, PeliculaId);
if (table.Rows.Count == 0)
{
return(null);
}
Alquiler_DS.AlquilerRow row = table[0];
Alquiler obj = new Alquiler()
{
AlquilerId = row.AlquilerId,
TotalPago = row.totalPago,
FechaAlqui = row.fechaAlqui,
FechaDevol = row.fechaDevol,
TarjetaCredito = row.tarjetaCredito,
CodigoTarjeta = row.codigoTarjeta,
Estado = row.estado,
UserId = row.UserId,
PeliculaId = row.peliculaId
};
return(obj);
}
public static List <Alquiler> GetAllAlquileres()
{
AlquilerTableAdapter adapter = new AlquilerTableAdapter();
Alquiler_DS.AlquilerDataTable table = adapter.GetAlquileres();
List <Alquiler> result = new List <Alquiler>();
Alquiler temp;
foreach (var row in table)
{
temp = new Alquiler();
temp.AlquilerId = row.AlquilerId;
temp.TotalPago = row.totalPago;
temp.FechaAlqui = row.fechaAlqui;
temp.FechaDevol = row.fechaDevol;
temp.TarjetaCredito = row.tarjetaCredito;
temp.CodigoTarjeta = row.codigoTarjeta;
temp.Estado = row.estado;
temp.UserId = row.UserId;
UserCLI userTemp = UserCLI_BRL.getUserById(row.UserId);
temp.Email = userTemp.Email;
temp.PeliculaId = row.peliculaId;
Pelicula moviesTemp = Pelicula_BRL.GetPeliculaByID(row.peliculaId);
temp.NombrePelicula = moviesTemp.Nombre;
result.Add(temp);
}
return(result);
}
public static List <Alquiler> GetAlquileresByUserId(int UserId)
{
if (UserId <= 0)
{
throw new ArgumentException("El UserId debe ser mayor a 0");
}
AlquilerTableAdapter adapter = new AlquilerTableAdapter();
Alquiler_DS.AlquilerDataTable table = adapter.GetAlquileresByUserID(UserId);
List <Alquiler> result = new List <Alquiler>();
Alquiler temp;
foreach (var row in table)
{
temp = new Alquiler()
{
AlquilerId = row.AlquilerId,
TotalPago = row.totalPago,
FechaAlqui = row.fechaAlqui,
FechaDevol = row.fechaDevol,
TarjetaCredito = row.tarjetaCredito,
CodigoTarjeta = row.codigoTarjeta,
Estado = row.estado,
UserId = row.UserId,
PeliculaId = row.peliculaId
};
result.Add(temp);
}
return(result);
}
public ActionResult Alquilar(FormCollection values)
{
if (values == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
try
{
int id = int.Parse(values["PeliculaID"]);
Pelicula pelicula = db.Peliculas.Find(id);
Alquiler auxAlquiler = new Alquiler();
auxAlquiler.PickUpate = DateTime.Parse(values["Alquiler.PickUpate"]);
auxAlquiler.DateOfReturn = DateTime.Parse(values["Alquiler.DateOfReturn"]);
auxAlquiler.Cost = pelicula.Price;
pelicula.Alquiler = auxAlquiler;
auxAlquiler.Peliculas.Add(pelicula);
db.Alquileres.Add(auxAlquiler);
db.SaveChanges();
return(RedirectToAction("Index"));
}
catch
{
return(View("Index"));
}
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
public ActionResult CreateAlquiler(Alquiler Alquiler)
{
db.Alquilers.Add(Alquiler);
db.SaveChanges();
return(RedirectToAction("Alquiler"));
}
private void EditarAlquiler_Load(object sender, EventArgs e)
{
AlquilerDAO rec = new AlquilerDAO();
alquiler = rec.SelectId(Id);
try
{
lblMensaje.Text = "";
if (alquiler.Id > 0)
{
Fecha.Text = alquiler.Fecha;
txtNombre.Text = alquiler.Nombre;
txtLugar.Text = alquiler.Lugar;
txtTelefono.Text = alquiler.Telefono.ToString();
txtMesa.Text = alquiler.Mesas.ToString();
txtSilla.Text = alquiler.Sillas.ToString();
txtMantel.Text = alquiler.Manteles.ToString();
txtLasos.Text = alquiler.Lasos.ToString();
txtCobertores.Text = alquiler.Cobertores.ToString();
txtSobreM.Text = alquiler.SobreMantel.ToString();
txtSillaV.Text = alquiler.SillasVerdes.ToString();
txtSillaB.Text = alquiler.SillasBlancas.ToString();
}
}
catch (Exception ex)
{
lblMensaje.Text = ex.Message.Replace("[0-9]*", "");
}
}
public static void Confirmar_Alquiler(Alquiler unAl)
{
SqlConnection oConexion = new SqlConnection(Conexion.STR);
SqlCommand oComando = new SqlCommand("Confirmar_Alquiler ", oConexion);
oComando.CommandType = CommandType.StoredProcedure;
oComando.Parameters.AddWithValue("@matricula", unAl.Vehiculo.Matricula);
oComando.Parameters.AddWithValue("@cedula", unAl.Cliente.Cedula);
oComando.Parameters.AddWithValue("@fechainicio", unAl.FechaInicio.Date);
oComando.Parameters.AddWithValue("@fechafin", unAl.FechaFin.Date);
oComando.Parameters.AddWithValue("@costo", unAl.Costo);
SqlParameter oRetorno = new SqlParameter("@Retorno", SqlDbType.Int);
oRetorno.Direction = ParameterDirection.ReturnValue;
oComando.Parameters.Add(oRetorno);
try
{
oConexion.Open();
oComando.ExecuteNonQuery();
int oAfectados = (int)oComando.Parameters["@Retorno"].Value;
if (oAfectados == -1)
{
throw new Exception("La matrícula ingresada no existe en la base de datos");
}
else if (oAfectados == -2)
{
throw new Exception("El cliente ingresado no existe en la base de datos");
}
else if (oAfectados == -3)
{
throw new Exception("La fecha de inicio no puede ser anterior al día de hoy");
}
else if (oAfectados == -4)
{
throw new Exception("La fecha de fin debe ser mayor a la fecha de inicio");
}
else if (oAfectados == -5)
{
throw new Exception("El vehículo ya se encuentra alquilado en esas fechas");
}
else if (oAfectados == -6)
{
throw new Exception("Error en la base de datos");
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
oConexion.Close();
}
}
/// <summary>
/// Elimina un alquiler
/// </summary>
/// <param name="alquiler">Alquiler a eliminar</param>
public void EliminarAlquiler(Alquiler alquiler)
{
EntidadesDataContext dc = GetDC();
dc.Alquilers.Attach(alquiler);
dc.Alquilers.DeleteOnSubmit(alquiler);
dc.SubmitChanges();
}
public ActionResult Create(int id)
{
Alquiler uno = Alquileres.ObtenerPorId(id);
ViewBag.ultimo = pagos.maxPago(id);
ViewBag.alquiler = uno;
return(View());
}
public FrmNuevoAlquiler(InmobiliariaDesktopContext dbRecibido)
{
InitializeComponent();
db = dbRecibido;
cargarComboInquilino(0);
cargarComboInmueble(0);
alquiler = new Alquiler();
}
public Int32 BuscaNumeroAlquiler(Alquiler alq)
{
using (var context = new InmobiliariaEntities())
{
Alquiler a = context.Alquileres.First(i => i.cod_unidad == alq.cod_unidad && i.nro_inquilino == alq.nro_inquilino && i.estado == "habilitado");
return(a.nro_alquiler);
}
}
public ActionResult DeleteConfirmed(int id)
{
Alquiler alquiler = db.Alquilers.Find(id);
db.Alquilers.Remove(alquiler);
db.SaveChanges();
return(RedirectToAction("Index"));
}
private void recogerButton_Click(object sender, EventArgs e)
{
Alquiler alquiler = (Alquiler)alquilerBindingSource.Current;
ConnectionHelper.ServiceClient.RecogerPelicula(alquiler.Usuario.NIF, alquiler.Pelicula.CodBarras);
MessageBox.Show("Se realizó la recogida correctamente", "MSDN Video", MessageBoxButtons.OK, MessageBoxIcon.Information);
Refrescar();
}
public FrmNuevoAlquiler(InmobiliariaDesktopContext dbRecibido, int idSeleccionado)
{
InitializeComponent();
db = dbRecibido;
alquiler = db.Alquileres.Find(idSeleccionado);
cargarElementoModificable();
cargarComboInquilino(alquiler.InquilinoId);
cargarComboInmueble(alquiler.InmuebleId);
}
public AlquilerViewModel(Alquiler alq, Cliente cl, List <Equipo> eqs)
{
Inicio = alq.Inicio;
Final = alq.Final;
Cliente = cl;
Tiempo = (Inicio - Final).TotalDays;
Equipos = eqs;
Valor = Tiempo * CalcularValor(eqs);
}
private void mostrarInfo(Alquiler al)
{
productoIdOTitulo.Text = al.productoCodigo.ToString();
clienteIdONIF.Text = al.clienteCodigo.ToString();
fechaDeAlquiler.SelectedDate = al.fechaDeAlquiler;
tiempoDeAlquiler.Text = al.tiempoDeAlquiler.ToString();
descuento.Text = al.descuento.ToString();
pago.Text = al.totalPago.ToString();
}
public ActionResult Create(IFormCollection collection)
{
try
{
System.Diagnostics.Debug.WriteLine("AAA1");
// TODO: Add insert logic here
InquilinoData inquilinoData = new InquilinoData();
Inquilino inquilinoACrear = new Inquilino {
Dni = Request.Form["Dni"].ToString(),
Apellido = Request.Form["Apellido"].ToString(),
Nombre = Request.Form["Nombre"].ToString(),
Direccion = Request.Form["Direccion"].ToString(),
Telefono = Request.Form["Telefono"].ToString(),
};
System.Diagnostics.Debug.WriteLine("AAA2");
int idInquilino = inquilinoData.crear(inquilinoACrear);
System.Diagnostics.Debug.WriteLine("ID INQUILINO: " + idInquilino);
System.Diagnostics.Debug.WriteLine("AAA3");
Inquilino inquilino = inquilinoData.obtenerInquilino(idInquilino);
System.Diagnostics.Debug.WriteLine("AAA4");
InmueblesData inmuebleData = new InmueblesData();
int idInmueble = Convert.ToInt32(collection["IdInmueble"]);
System.Diagnostics.Debug.WriteLine("ID INMUEBLE: " + idInmueble);
Inmueble inmueble = inmuebleData.obtenerInmueble(idInmueble);
inmuebleData.marcarComoAlquilado(idInmueble);
System.Diagnostics.Debug.WriteLine("AAA5");
Alquiler a = new Alquiler
{
Precio = Double.Parse(Request.Form["Precio"].ToString()),
FechaInicio = Convert.ToDateTime(Request.Form["FechaInicio"].ToString()),
FechaFin = Convert.ToDateTime(Request.Form["FechaFin"].ToString()),
Inquilino = inquilino,
Inmueble = inmueble,
};
System.Diagnostics.Debug.WriteLine("AAA6");
AlquilerData alquilerData = new AlquilerData();
alquilerData.crear(a);
System.Diagnostics.Debug.WriteLine("AAA7");
return(RedirectToAction(nameof(Index)));
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine("EXCEPCION: " + e.Message);
return(View());
}
}
public async Task <Alquiler> Actualizar(Alquiler alquiler, string token)
{
HttpClient httpClient = GetClient(token);
var response = await httpClient.PutAsync(Url,
new StringContent(JsonConvert.SerializeObject(alquiler),
Encoding.UTF8, "application/json"));
return(JsonConvert.DeserializeObject <Alquiler>(await response.Content.ReadAsStringAsync()));
}
/// <summary>
/// Método para consultar alquileres según el id
/// </summary>
/// <param name="alquiler"></param>
/// <returns></returns>
public DataTable ConsultarAlquileresId(Alquiler alquiler)
{
Database db = DatabaseFactory.CreateDatabase("Desarrollo");
string sqlCommand = "dbo.[consultar_alquileres_id]";
DbCommand dbCommand = db.GetStoredProcCommand(sqlCommand);
try {
db.AddInParameter(dbCommand, "@INTid_alquiler", DbType.Int32, Utilerías.Utilerías.ObtenerValor(alquiler.Id));
db.AddOutParameter(dbCommand, "@nStatus", DbType.Int16, 2);
db.AddOutParameter(dbCommand, "@strMessage", DbType.String, 250);
DataTable dtResultado = db.ExecuteDataSet(dbCommand).Tables[0];
if (int.Parse(db.GetParameterValue(dbCommand, "@nStatus").ToString()) > 0)
throw new Exception(db.GetParameterValue(dbCommand, "@strMessage").ToString());
return (dtResultado);
} catch (Exception ex) { throw new Exception(ex.Message); }
}
/// <summary>
/// Método para consultar los informes de alquileres
/// </summary>
/// <param name="DatosA"></param>
/// <param name="CodSocio"></param>
/// <returns></returns>
public DataTable ConsultarAlquileresFechas(Alquiler DatosA, int CodSocio)
{
Database db = DatabaseFactory.CreateDatabase("Desarrollo");
string sqlCommand = "dbo.[consultar_alquileres_fecha]";
DbCommand dbCommand = db.GetStoredProcCommand(sqlCommand);
try
{
db.AddInParameter(dbCommand, "@DTfecha_ini", DbType.DateTime, Utilerías.Utilerías.ObtenerValor(DatosA.Fecha));
db.AddInParameter(dbCommand, "@DTfecha_fin", DbType.DateTime, Utilerías.Utilerías.ObtenerValor(DatosA.Entrega));
db.AddInParameter(dbCommand, "@INTsocio", DbType.Int32, Utilerías.Utilerías.ObtenerValor(CodSocio));
db.AddOutParameter(dbCommand, "@nStatus", DbType.Int16, 2);
db.AddOutParameter(dbCommand, "@strMessage", DbType.String, 250);
DataTable dtResultado = db.ExecuteDataSet(dbCommand).Tables[0];
if (int.Parse(db.GetParameterValue(dbCommand, "@nStatus").ToString()) > 0)
throw new Exception(db.GetParameterValue(dbCommand, "@strMessage").ToString());
return (dtResultado);
}
catch (Exception ex) { throw new Exception(ex.Message); }
}
/// <summary>
/// Método definido para registrar los datos de los alquileres
/// </summary>
/// <param name="DatosA"></param>
/// <param name="PelisAlquiladas"></param>
public void RegistrarAlquileres(Alquiler DatosA, DataTable PelisAlquiladas)
{
Database db = DatabaseFactory.CreateDatabase("Desarrollo");
string sqlCommand = "dbo.[insertar_alquileres]";
DbCommand dbCommand = db.GetStoredProcCommand(sqlCommand);
using (DbConnection conn = db.CreateConnection()) // conexion para la transaccion
{
conn.Open(); //abrimos la conexion
DbTransaction tranRegistro = conn.BeginTransaction(); //iniciamos la transaccion
if (PelisAlquiladas.Rows.Count == 0)
{
throw new Exception("No se han seleccionado películas");
}
try
{
db.AddInParameter(dbCommand, "@INTsocio", DbType.Int32, Utilerías.Utilerías.ObtenerValor(DatosA.Socio));
db.AddInParameter(dbCommand, "@DTfecha", DbType.DateTime, Utilerías.Utilerías.ObtenerValor(DatosA.Fecha));
db.AddInParameter(dbCommand, "@DTentrega", DbType.DateTime, Utilerías.Utilerías.ObtenerValor(DatosA.Entrega));
db.AddInParameter(dbCommand, "@INTcosto", DbType.Int32, Utilerías.Utilerías.ObtenerValor(DatosA.Costo));
db.AddInParameter(dbCommand, "@INTplazo", DbType.Int32, Utilerías.Utilerías.ObtenerValor(DatosA.Plazo));
db.AddInParameter(dbCommand, "@CHARdevuelto", DbType.Boolean, Utilerías.Utilerías.ObtenerValor(DatosA.Devuelto));
db.AddOutParameter(dbCommand, "@nStatus", DbType.Int16, 2);
db.AddOutParameter(dbCommand, "@strMessage", DbType.String, 250);
db.AddOutParameter(dbCommand, "@INTid_alquiler", DbType.Int32, 4);
db.ExecuteNonQuery(dbCommand, tranRegistro);
if (int.Parse(db.GetParameterValue(dbCommand, "@nStatus").ToString()) > 0)
throw new Exception(db.GetParameterValue(dbCommand, "@strMessage").ToString());
// Se registra la informacion del auto, un vez ingresados los datos personales
int idAlquiler = int.Parse(db.GetParameterValue(dbCommand, "@INTid_alquiler").ToString());
for (int i = 0; i < PelisAlquiladas.Rows.Count; i++)
{
AlquilerPelícula DatosAP = new AlquilerPelícula();
DatosAP.Alquiler = idAlquiler;
DatosAP.Película = Convert.ToInt32(PelisAlquiladas.Rows[i]["idPelículas"].ToString());
DatosAP.TotalDVD = Convert.ToInt32(PelisAlquiladas.Rows[i]["cantDVD"].ToString());
DatosAP.TotalBlueRay = Convert.ToInt32(PelisAlquiladas.Rows[i]["cantBlueRay"].ToString());
DatosAP.TotalHD = Convert.ToInt32(PelisAlquiladas.Rows[i]["cantHD"].ToString());
RegistrarAlquilerPelículas(DatosAP, tranRegistro, db);
}
tranRegistro.Commit();
}
catch (Exception ex)
{
tranRegistro.Rollback();
throw new Exception(ex.Message);
}
finally
{
conn.Close(); // cerrar la conexion
}
}
}
/// <summary>
/// Método para registrar los alquileres y las películas que se asignan a este.
/// </summary>
/// <param name="DatosA"></param>
/// <param name="pelisAlquiladas"></param>
public void RegistrarAlquiler(Alquiler DatosA, DataTable pelisAlquiladas)
{
try { this.Registro.RegistrarAlquileres(DatosA, pelisAlquiladas); }
catch (Exception ex) { throw new Exception(ex.Message); }
}
/// <summary>
/// Método para cancelar los alquileres editando su dato
/// </summary>
/// <param name="alquiler"></param>
public void DevolverAlquiler(Alquiler alquiler)
{
try { this.insEdicionesDAL.DevolverAlquiler(alquiler); }
catch (Exception ex) { throw new Exception(ex.Message); }
}
/// <summary>
/// Método para consultar los alquileres qu se dieron en fechas determinadas
/// </summary>
/// <param name="DatosA"></param>
/// <param name="codSocio"></param>
/// <returns></returns>
public DataTable ConsultarAlquilerFecha(Alquiler DatosA, int codSocio)
{
try { return this.consulta.ConsultarAlquileresFechas(DatosA, codSocio); }
catch (Exception ex) { throw new Exception(ex.Message); }
}
/// <summary>
/// Método para consultar las películas que estan asociadas a un alquiler
/// </summary>
/// <param name="alquiler"></param>
/// <returns></returns>
public DataTable ConsultarAlquileresPelículas(Alquiler alquiler)
{
try { return this.consulta.ConsultarAlquileresPelículas(alquiler); } catch (Exception ex) { throw new Exception(ex.Message); }
}