public ActionResult editarVehiculo(string id)
{
EVehiculo ev = new EVehiculo();
ev.Matricula = id;
return(View(ev));
}
/*
* public List<EViaje> GetViajes(int IdSalida)
* {
* return iSalida.getSalidas(IdSalida).Viaje.ToList();
* }
*/
public List <int> GetAsientos(int fechaSelected)
{
EViaje viaje = iViaje.getViaje(fechaSelected);
ESalida salida = iSalida.getSalidas(viaje.IdSalida);
EVehiculo vehiculo = iVehiculo.getVehiculos(salida.IdVehiculo);
int cantidadDeAsientos = vehiculo.CantAsientos;
List <EPasaje> lstPasajes = viaje.Pasaje.ToList();
List <int> lstPasajesOcupados = new List <int>();
foreach (var pasaje in lstPasajes)
{
if (pasaje.Asientos != null)
{
lstPasajesOcupados.Add((int)pasaje.Asientos);
}
}
List <int> listaTotal = new List <int>();
for (int i = 1; i <= cantidadDeAsientos; i++)
{
listaTotal.Add(i);
}
List <int> asientosLibres = listaTotal.Except(lstPasajesOcupados).ToList();
return(asientosLibres);
}
//
//Creamos los métodos generales llenando y leyendo objetos
//
private void Guardar()
{
try
{
_vehiculo = null;
if (_vehiculo == null)
{
_vehiculo = new EVehiculo();
_vehiculo.Codigo = Convert.ToInt32(txtCodigo.Text);
_vehiculo.Descripcion = txtDescripcion.Text;
_vehiculo.Modelo = txtModelo.Text;
_vehiculo.Marca = txtMarca.Text;
_vehiculoBol.Registrar(_vehiculo);
if (_vehiculoBol.stringBuilder.Length != 0)
{
MessageBox.Show(_vehiculoBol.stringBuilder.ToString(), "Para continuar:");
}
else
{
MessageBox.Show("Vehiculo registrado/actualizado con éxito");
TraerTodos();
}
}
}
catch (Exception ex)
{
MessageBox.Show(string.Format("Error: {0}", ex.Message), "Error inesperado");
}
this.Controls.OfType <TextBox>().ToList().ForEach(o => o.Text = "");
return;
}
private double ObtenerPrecio(EVehiculo tipoVehiculo)
{
double valorAuto = 0;
double valorMoto = 0;
double valorTotal = 0;
foreach (Vehiculo vehiculo in this.vehiculos)
{
if (vehiculo is Auto)
{
valorAuto += (Single)(Auto)vehiculo;
}
else if (vehiculo is Moto)
{
valorMoto += (Moto)vehiculo;
}
}
switch (tipoVehiculo)
{
case EVehiculo.PrecioDeAutos:
valorTotal = valorAuto;
break;
case EVehiculo.PrecioDeMotos:
valorTotal = valorMoto;
break;
case EVehiculo.PrecioTotal:
valorTotal = valorAuto + valorMoto;
break;
}
return(valorTotal);
}
public EVehiculo getVehiculo(string matricula)
{
EVehiculo ev = iVehiculo.getVehiculos(matricula);
ev.Salida = new List <ESalida>();
return(ev);
}
public EVehiculo crearVehiculo(EVehiculo vehiculo, string tokenJWT)
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(Baseurl + "crear/vehiculo");
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", tokenJWT);
var postTask = client.PostAsJsonAsync <EVehiculo>("vehiculo", vehiculo);
postTask.Wait();
var result = postTask.Result;
}
return(vehiculo);
}
//
//Creamos nuestro método para Insertar un nuevo Producto, observe como este método tampoco valida los el contenido
//de las propiedades, sino que manda a llamar a una Función que tiene como tarea única hacer esta validación
//
public void Registrar(EVehiculo vechiculo)
{
if (ValidarVehiculo(vechiculo))
{
if (_vehiculoDal.GetBycodigo(vechiculo.Codigo) == null)
{
_vehiculoDal.Insert(vechiculo);
}
else
{
_vehiculoDal.Update(vechiculo);
}
}
}
public double ObtenerPrecio(EVehiculo tipovehiculo)
{
double precio = 0;
switch (tipovehiculo)
{
case EVehiculo.PrecioDeAutos:
foreach (Vehiculo a in this.vehiculos)
{
if (a is Auto)
{
precio += (Single)(Auto)a;
}
}
break;
case EVehiculo.PrecioDeMotos:
foreach (Vehiculo m in this.vehiculos)
{
if (m is Moto)
{
precio += (Moto)m;
}
}
break;
case EVehiculo.PrecioTotal:
foreach (Vehiculo a in this.vehiculos)
{
if (a is Auto)
{
precio += (Single)(Auto)a;
}
}
foreach (Vehiculo m in this.vehiculos)
{
if (m is Moto)
{
precio += (Moto)m;
}
}
break;
}
return(precio);
}
public IHttpActionResult editarVehiculos(string Matricula, [FromBody] EVehiculo vehiculo)
{
try
{
EVehiculo ev = cAdmin.editarVehiculos(vehiculo.Marca, vehiculo.Modelo, Matricula, vehiculo.CantAsientos);
if (ev != null)
{
return(Ok(ev));
}
return(Content(HttpStatusCode.NotFound, "La matricula ya existe"));
}
catch (Exception)
{
return(NotFound());
}
}
public EVehiculo editarVehiculo(EVehiculo vehiculo, string tokenJWT)
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(Baseurl);
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", tokenJWT);
var putTask = client.PutAsJsonAsync($"editar/vehiculo/{vehiculo.Matricula}", vehiculo);
putTask.Wait();
var result = putTask.Result;
if (result.IsSuccessStatusCode)
{
Console.WriteLine();
}
}
return(vehiculo);
}
static public Vehiculo evehiculoAVehiculo(EVehiculo ev)
{
Vehiculo v = new Vehiculo();
v.Matricula = ev.Matricula;
v.Modelo = ev.Modelo;
v.Marca = ev.Marca;
v.CantAsientos = ev.CantAsientos;
List <Salida> lst = new List <Salida>();
foreach (var s in ev.Salida)
{
lst.Add(esalidaASalida(s));
}
v.Salida = lst;
return(v);
}
static public EVehiculo vehiculoAEVehiculo(Vehiculo v)
{
EVehiculo ev = new EVehiculo();
ev.Matricula = v.Matricula;
ev.Modelo = v.Modelo;
ev.Marca = v.Marca;
ev.CantAsientos = v.CantAsientos;
List <ESalida> lst = new List <ESalida>();
foreach (var s in v.Salida)
{
lst.Add(salidaAESalida(s));
}
ev.Salida = lst;
return(ev);
}
private double ObtenerPrecio(EVehiculo tipoVehiculo)
{
double retorno;
if (tipoVehiculo == EVehiculo.PrecioDeAutos)
{
retorno = this.PrecioDeAutos;
}
else if (tipoVehiculo == EVehiculo.PrecioDeMotos)
{
retorno = this.PrecioDeMotos;
}
else
{
retorno = this.PrecioTotal;
}
return(retorno);
}
private double ObtenerPrecio(EVehiculo tipoVehiculo)
{
double retorno = 0;
switch (tipoVehiculo)
{
case EVehiculo.PrecioDeAutos:
retorno = PrecioDeAutos;
break;
case EVehiculo.PrecioDeMotos:
retorno = PrecioDeMotos;
break;
case EVehiculo.PrecioTotal:
retorno = PrecioTotal;
break;
}
return(retorno);
}
private double ObtenerPrecio(EVehiculo tipoVehiculo)
{
double acumulador = 0;
switch (tipoVehiculo)
{
case EVehiculo.PrecioDeAutos:
acumulador = this.PrecioDeAutos;
break;
case EVehiculo.PrecioDeMotos:
acumulador = this.PrecioDeMotos;
break;
case EVehiculo.PrecioTotal:
acumulador = this.PrecioTotal;
break;
}
return(acumulador);
}
private bool ValidarVehiculo(EVehiculo vehiculo)
{
stringBuilder.Clear();
if (string.IsNullOrEmpty(vehiculo.Descripcion))
{
stringBuilder.Append("El campo Descripción es obligatorio");
}
if (string.IsNullOrEmpty(vehiculo.Modelo))
{
stringBuilder.Append(Environment.NewLine + "El campo Modelo es obligatorio");
}
// if (producto.Precio <= 0) stringBuilder.Append(Environment.NewLine + "El campo Precio es obligatorio");
if (string.IsNullOrEmpty(vehiculo.Marca))
{
stringBuilder.Append(Environment.NewLine + "El campo Marca es obligatorio");
}
return(stringBuilder.Length == 0);
}
public double MostrarTotalFacturado(EVehiculo vehiculo)
{
double facturacion = 0;
foreach (Vehiculo item in this.Vehiculos)
{
if (item is Auto && vehiculo == EVehiculo.Auto)
{
facturacion += this.precioAuto;
}
else if (item is Camion && vehiculo == EVehiculo.Camion)
{
facturacion += this.precioCamion;
}
else if (item is Moto && vehiculo == EVehiculo.Moto)
{
facturacion += this.precioMoto;
}
}
return(facturacion);
}
public double MostrarTotalFacturado(EVehiculo v)
{
double resultAux = 0;;
foreach (Vehiculo element in this._vehiculos)
{
if (element is Auto && v == EVehiculo.Auto)
{
resultAux += this._precioAuto;
}
if (element is Camion && v == EVehiculo.Camion)
{
resultAux += this._precioCamion;
}
if (element is Moto && v == EVehiculo.Moto)
{
resultAux += this._precioMoto;
}
}
return(resultAux);
}
public EVehiculo getVehiculos(string matricula)
{
try
{
using (uybusEntities db = new uybusEntities())
{
Vehiculo v = db.Vehiculo.Find(matricula);
if (v == null)
{
return(null);
}
EVehiculo ev = new EVehiculo();
ev = Converter.vehiculoAEVehiculo(v);
return(ev);
}
}
catch (System.Exception ex)
{
throw ex;
}
}
private double ObtenerPrecio(EVehiculo tipoVehiculo)
{
double precioAutos = 0;
double precioMotos = 0;
double precio = 0;
foreach (Vehiculo item in this.vehiculos)
{
if (item is Auto)
{
precioAutos += (Single)(Auto)item;
}
else if (item is Moto)
{
precioMotos += (Single)(Moto)item;
}
}
switch (tipoVehiculo)
{
case EVehiculo.PrecioDeAutos:
precio = precioAutos;
break;
case EVehiculo.PrecioDeMotos:
precio = precioMotos;
break;
case EVehiculo.PrecioTotal:
precio = precioAutos + precioMotos;
break;
default:
break;
}
return(precio);
}
private double ObtenerPrecio(EVehiculo tipoVehiculo)
{
Single acumulador = 0;
switch (tipoVehiculo)
{
case EVehiculo.PrecioDeAutos:
foreach (Vehiculo actual in this.vehiculos)
{
if (actual is Auto)
{
acumulador += (Single)(Auto)actual;
}
}
break;
case EVehiculo.PrecioDeMotos:
foreach (Vehiculo actual in this.vehiculos)
{
if (actual is Moto)
{
acumulador += (Moto)actual;
}
}
break;
case EVehiculo.PrecioTotal:
acumulador = (float)(this.PrecioDeAutos + this.PrecioDeMotos);
break;
}
return(acumulador);
}
private void TraerPorCodigo(int Codigo)
{
try
{
_vehiculo = _vehiculoBol.TraerPorId(Codigo);
if (_vehiculo != null)
{
txtCodigo.Text = Convert.ToString(_vehiculo.Codigo);
txtDescripcion.Text = _vehiculo.Descripcion;
txtModelo.Text = _vehiculo.Modelo;
txtMarca.Text = _vehiculo.Marca;
}
else
{
MessageBox.Show("El Vehiculo solicitado no existe");
}
}
catch (Exception ex)
{
MessageBox.Show(string.Format("Error: {0}", ex.Message), "Error inesperado");
}
}
/// <summary>
/// Obitene el precio de vehiculos dentro de Concesionario que correspondan al tipo por parametro
/// </summary>
/// <param name="tipoVehiculo"></param>
/// <returns></returns>
private double ObtenerPrecio(EVehiculo tipoVehiculo)
{
switch (tipoVehiculo)
{
case EVehiculo.PrecioDeAutos:
{
return(this.PrecioDeAutos);
}
case EVehiculo.PrecioDeMotos:
{
return(this.PrecioDeMotos);
}
case EVehiculo.PrecioTotal:
{
return(this.PrecioTotal);
}
default:
return(0);
}
}
public IHttpActionResult crearVehiculos([FromBody] EVehiculo vehiculo)
{
try
{
if (String.IsNullOrEmpty(vehiculo.Marca) || String.IsNullOrEmpty(vehiculo.Modelo) || String.IsNullOrEmpty(vehiculo.Matricula))
{
return(Content(HttpStatusCode.BadRequest, "No se creó el nuevo vehiculo, parametros no validos."));
}
else
{
EVehiculo ev = cAdmin.crearVehiculos(vehiculo.Marca, vehiculo.Modelo, vehiculo.Matricula, vehiculo.CantAsientos);
if (ev != null)
{
return(Ok(ev));
}
return(Content(HttpStatusCode.NotFound, "La matricula ya existe"));
}
}
catch (Exception)
{
return(NotFound());
}
}
private double ObtenerPrecio(EVehiculo tipoVehiculo)
{
double ret;
switch (tipoVehiculo)
{
case EVehiculo.PrecioDeAuto:
ret = this.PrecioDeAuto;
break;
case EVehiculo.PrecioDeMoto:
ret = this.PrecioDeMoto;
break;
default:
ret = this.PrecioTotal;
break;
}
return(ret);
}
public double MostrarTotalFacturado(EVehiculo tipoVehiculo)
{
double ganancia = 0;
foreach (Vehiculo item in this._vehiculos)
{
switch (tipoVehiculo)
{
case EVehiculo.Auto:
if (item is Auto)
{
ganancia += _precioAuto;
}
break;
case EVehiculo.Camion:
if (item is Camion)
{
ganancia += _precioCamion;
}
break;
case EVehiculo.Moto:
if (item is Moto)
{
ganancia += _precioMoto;
}
break;
default:
break;
}
}
return(ganancia);
}
/// <summary>
/// retorna el precio del vehiculo
/// </summary>
/// <param name="tipoVehiculo"></param>
/// <returns></returns>
private double ObtenerPrecio(EVehiculo tipoVehiculo)
{
double retorno = 0;
foreach (Vehiculo x in this.vehiculos)
{
switch (tipoVehiculo)
{
case (EVehiculo.PrecioDeAutos):
if (x is Auto)
{
retorno += (Double)((Auto)x);
}
break;
case (EVehiculo.PrecioDeMotos):
if (x is Moto)
{
retorno += ((Moto)x);
}
break;
//case (EComercio.Ambos):
default:
if (x is Auto)
{
retorno += (Double)((Auto)x);
}
if (x is Moto)
{
retorno += ((Moto)x);
}
break;
}
}
return(retorno);
}
private double ObtenerPrecio(EVehiculo tipoVehiculo)
{
double total = 0;
switch (tipoVehiculo)
{
case EVehiculo.PrecioDeAutos:
total = this.PrecioDeAutos;
break;
case EVehiculo.PrecioDeMotos:
total = this.PrecioDeMotos;
break;
case EVehiculo.PrecioTotal:
total = this.PrecioTotal;
break;
default:
break;
}
return(total);
}
private double ObtenerPrecio(EVehiculo tipoVehiculo)
{
double retorno = 0;
foreach (Vehiculo item in this.vehiculos)
{
switch (tipoVehiculo)
{
case (EVehiculo.PrecioDeAutos):
if (item is Auto)
{
retorno += (Double)((Auto)item);
}
break;
case (EVehiculo.PrecioDeMotos):
if (item is Moto)
{
retorno += ((Moto)item);
}
break;
default:
if (item is Auto)
{
retorno += (Double)((Auto)item);
}
if (item is Moto)
{
retorno += ((Moto)item);
}
break;
}
}
return(retorno);
}
public List <EVehiculo> getAllVehiculos()
{
try
{
using (uybusEntities db = new uybusEntities())
{
List <EVehiculo> lstEv = new List <EVehiculo>();
var veics = db.Vehiculo;
foreach (var v in veics)
{
EVehiculo ev = new EVehiculo();
ev = Converter.vehiculoAEVehiculo(v);
lstEv.Add(ev);
}
return(lstEv);
}
}
catch (System.Exception ex)
{
throw ex;
}
}
