/// <summary>
/// PRE: la clase debe estar inicializada
/// POST:Devuelve un presupuesto reyenandolo con los datos que hay en los textBox, sin comprobar que estos sean datos correctos.
/// </summary>
/// <returns></returns>
internal Presupuesto devolverPresupuesto()
//se usa cunado los formatos ya se saben que son correctos
{
Cliente c = LNCliente.LogicaNegocioCliente.Buscar(new Cliente(this.cCliente.SelectedItem.ToString()));
DateTime fecha;
DateTime.TryParse(this.tbFecha.Text, out fecha);
CheckedItemCollection l = this.clbVehiculos.CheckedItems;
List <Vehiculo> vehiculos = new List <Vehiculo>();
foreach (String i in l)
{
string [] t = i.ToString().Split('-');
Vehiculo v2 = new VehiculoNuevo(t[0]);
v2 = LNVehiculo.LogicaNegocioVehiculo.buscar(v2);
vehiculos.Add(v2);
}
Object p = this.cVehiculoComprado.SelectedItem;
Vehiculo v = null;
if (p != null)
{
string[] r = this.cVehiculoComprado.SelectedItem.ToString().Split('-');
v = new VehiculoNuevo(r[0]);
v = LNVehiculo.LogicaNegocioVehiculo.buscar(v);
}
return(new Presupuesto(this.tbIdentificador.Text, c, fecha, this.tbEstado.Text, vehiculos, v));
}
/// <summary>
/// PRE:la clase que se pasa como parametro debe de estar incializada
/// POST: Dado un VehiculoNuevo (Del que solo se utilizara la clave), obtendremos un vehiculoNuevo con todos sus campos, no se contempla el caso en el que el VehiculoNuevo no esta en la BD
/// </summary>
/// <param name="v1"></param>
/// <returns></returns>
public static VehiculoNuevo Buscar(VehiculoNuevo v1)
{
VNuevoDatos v = new VNuevoDatos(v1.NumBastidor, v1.Marca, v1.Modelo, v1.Potencia, v1.PvRecomendado);
VNuevoDatos dev = BD.SelectVNuevo(v);
return(new VehiculoNuevo(dev.NumBastidor, dev.Potencia, dev.Modelo, dev.Marca, dev.PvRecomendado));
}
/// <summary>
/// Pre: la clase debe estar inicializada
/// Post: Si el vehiculo existe se actualizan los datos, si no existe se pregunta si se quiere introducir otro.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void actualizaDatosVehiculoToolStripMenuItem_Click(object sender, EventArgs e)
{
bool continuar = false;
while (!continuar)
{
FClaveVehiculo f = new FClaveVehiculo();
DialogResult dr = f.ShowDialog();
if (dr.Equals(DialogResult.OK))
{
Vehiculo v1 = f.devolverVehiculo();
if (!LNVehiculo.LogicaNegocioVehiculo.existeYa(v1))
{
DialogResult aviso = MessageBox.Show("¿Quieres introducir otro?", "No existe un vehiculo con dicho numero de bastidor", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (aviso.Equals(DialogResult.No))
{
f.Dispose();
continuar = true;
}
else
{
f.Dispose();
}
}
else
{
continuar = true;
RestoDatosVehiculo actualizar = new RestoDatosVehiculo(v1.NumBastidor);
actualizar.Text = "Actualizar un vehiculo";
DialogResult drActualizar = actualizar.ShowDialog();
if (drActualizar.Equals(DialogResult.OK))
{
Vehiculo v = actualizar.devVehiculo();
VehiculoNuevo nuevo = v as VehiculoNuevo;
if (nuevo != null)
{
LNVehiculo.LogicaNegocioVehiculo.actualizar(nuevo);
}
else
{
LNVehiculo.LogicaNegocioVehiculo.actualizar(v as VehiculoSegundaMano);
}
MessageBox.Show("El vehiculo se ha actualizado correctamente", "Informacion", MessageBoxButtons.OK, MessageBoxIcon.Information);
actualizar.Dispose();
}
else
{
actualizar.Dispose();
}
}
}
else
{
f.Dispose();
continuar = true;
}
}
}
//----------------------------VEHICULO----------------------------//
/// <summary>
/// Pre: la clase debe estar inicializada
/// Post: Si el vehiculo ya existe preguna si quieres introducir otro. Si no existe se añade el vehiculo.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void añadirUnVehiculoToolStripMenuItem_Click(object sender, EventArgs e)
{
bool continuar = false;
while (!continuar)
{
FClaveVehiculo f = new FClaveVehiculo();
DialogResult dr = f.ShowDialog();
if (dr.Equals(DialogResult.OK)) //caso en el que se puede introducir
{
Vehiculo vehiculo1 = f.devolverVehiculo();
if (LNVehiculo.LogicaNegocioVehiculo.existeYa(vehiculo1))
{
DialogResult aviso = MessageBox.Show("¿Quieres introducir otro?", "Ya existe un vehiculo con dicho bastidor", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (aviso.Equals(DialogResult.No))
{
f.Dispose();
continuar = true;
}
else
{
f.Dispose();
}
}
else
{
continuar = true;
RestoDatosVehiculo alta = new RestoDatosVehiculo(f.devolverVehiculo().NumBastidor);
alta.Text = "Dar de alta un vehiculo";
DialogResult drAlta = alta.ShowDialog();
if (drAlta.Equals(DialogResult.OK))
{
Vehiculo vehiculo = alta.devVehiculo();
VehiculoNuevo v = vehiculo as VehiculoNuevo;
if (v != null)
{
LNVehiculo.LogicaNegocioVehiculo.añadir(v);
}
else
{
LNVehiculo.LogicaNegocioVehiculo.añadir(vehiculo as VehiculoSegundaMano);
}
MessageBox.Show("El vehiculo se ha añadido correctamente", "Informacion", MessageBoxButtons.OK, MessageBoxIcon.Information);
alta.Dispose();
}
else
{
alta.Dispose();
}
}
}
else
{
f.Dispose();
continuar = true;
}
}
}
/// <summary>
/// PRE: v puede contener solo la clave, debe estar incializado
/// POST:comprueba que existe y si es asi lo borra y devuelve true y en cualquier otro caso false
/// </summary>
/// <param name="v"></param>
/// <returns></returns>
public static bool eliminar(VehiculoNuevo v)
{
bool eliminar = false;
if (existeYa(v))
{
Persistencia.Borrar(v);
}
return(eliminar);
}
/// <summary>
/// PRE: v debe de estar incializado
/// POST: en caso de existir lo busca y lo devuelve y si no existe devuelve null
/// </summary>
/// <param name="v"></param>
/// <returns></returns>
public static VehiculoNuevo buscar(VehiculoNuevo v)
{
VehiculoNuevo dev = null;
if (existeYa(v))
{
dev = Persistencia.Buscar(v);
}
return(dev);
}
//--------------------------------------METODOS VEHICULO NUEVO---------------------------------------
/// <summary>
/// PRE: v debe de estar inicializado
/// POST: comprueba que no esta añadido y si no esta lo añade, en caso de añadirlo devuelve true y falso en cualquier otro caso
/// </summary>
/// <param name="v"></param>
/// <returns></returns>
public static bool añadir(VehiculoNuevo v)
{
bool añadido = false;
if (!existeYa(v))
{
Persistencia.Añadir(v);
añadido = true;
}
return(añadido);
}
/// <summary>
/// PRE:ambos parametros deben estar incializados
/// POST:devuelve true si se ha consegido añadir el extra al vehiculo y falso en cualquier otro caso, comprueba que tanto el vehiculo como el extra existen y que este no lo tiene ya agregado
/// </summary>
/// <param name="v"></param>
/// <param name="e"></param>
/// <returns></returns>
public static bool añadirExtra(VehiculoNuevo v, Extra e)
{
bool añadido = false;
if (existeYa(v) && Persistencia.Existe(e) && !v.Extras.Contains(e)) //comprobamos que existan en nuestra bd y que no este el extra ya añadido
{
v.anadirExtra(e); //añadimos el extra al vehiculo y lo actualizamos
actualizar(v);
añadido = true;
}
return(añadido);
}
/// <summary>
/// PRE:v debe de estar incializado y debe contener los datos actualizados del vehiculo que se quiere actualizar(tienen en mismo numBatidor)
/// POST:comprueba que existe un vehiculo con dicho numBastidor y si es asi lo actualiza y devuelve true y false en cualquier otro caso
/// </summary>
/// <param name="v"></param>
/// <returns></returns>
public static bool actualizar(VehiculoNuevo v)
{
bool actualizado = false;
if (existeYa(v))
{
Persistencia.Actualizar(v);
actualizado = true;
}
return(actualizado);
}
/// <summary>
/// PRE:ambos parametros deben estar incializados
/// POST:devuelve true si se ha consegido quitar el extra y falso en cualquier otro caso(aunque dicho coche no tenga ese extra), comprueba que tanto el vehiculo como el extra existen y que este lo tiene agregado
/// </summary>
/// <param name="v"></param>
/// <param name="e"></param>
/// <returns></returns>
public static bool quitarExtra(VehiculoNuevo v, Extra e)
{
bool quitado = false;
if (existeYa(v) && Persistencia.Existe(e) && v.Extras.Contains(e)) //comprobamos que existan en nuestra bd y que el vehiculo tenga dicho extra
{
v.eliminarExtra(e);
actualizar(v);
quitado = true;
}
return(quitado);
}
/// <summary>
/// Devuelve la lista de todos los vehiculos que posee el concesionario construidos como vehiculos nuevos
/// </summary>
/// <returns></returns>
public static List <Vehiculo> listaVehiculos()
{
List <Vehiculo> lista = new List <Vehiculo>();
int tam = BD.Vehiculos.Count;
for (int i = 0; i < tam; i++)
{
VehiculoDatos v = BD.Vehiculos[i];
Vehiculo v1 = new VehiculoNuevo(v.NumBastidor, v.Potencia, v.Modelo, v.Marca, v.PvRecomendado);
lista.Add(v1);
}
return(lista);
}
//--------------------------------------------------------------------------------------------------------
//------------------------------------------------VEHICULO NUEVO------------------------------------------
//--------------------------------------------------------------------------------------------------------
/// <summary>
/// PRE:el parametro debe de estar incializado
/// POST: Dado un VehiculoNuevo, se añade a la BD (Sin comprobar si ya existe), (Los extras que este vehiculo tiene asociados deben de ser añadidos explicitamente antes)
/// </summary>
/// <param name="v"></param>
public static void Añadir(VehiculoNuevo v)
{
VNuevoDatos v1 = new VNuevoDatos(v.NumBastidor, v.Marca, v.Modelo, v.Potencia, v.PvRecomendado);
BD.InsertVNuevos(v1);
if (v.Extras.Count != 0)
{
foreach (Extra e in v.Extras)
{
BD.InsertVNuevo_Extra(new VNuevoExtrasDatos(new VNuevoExtrasClave(v.NumBastidor, e.Nombre)));
}
}
}
/// <summary>
/// Solo se puede llamar si la clase esta incializada y si el numero de bastidor cumple el formato
/// Devuelve un objeto vehiculo con la clave iniciada
/// </summary>
/// <returns></returns>
internal Vehiculo devolverVehiculo()
{
Vehiculo ve = new VehiculoNuevo(this.tbIdentificador.Text);
Vehiculo nuevo = LNVehiculo.LogicaNegocioVehiculo.buscar(ve);
if (nuevo != null)
{
return(ve);
}
else
{
return(new VehiculoSegundaMano(this.tbIdentificador.Text));
}
}
/// <summary>
/// PRE:la clase que se pasa como parametro debe de estar incializada
/// POST:Dado un VehiculoNuevo (Puede ser que solo contenga la clave), se borrara sin comprobar si existe o no, su aparicion en la bd
/// </summary>
/// <param name="v"></param>
public static void Borrar(VehiculoNuevo v)
{
//Como el objeto que recibimos puede tener solo la clave, primero obtenemos los extras de ese vehiculo:
VehiculoNuevo vehiculo = Persistencia.Buscar(v);
foreach (Extra e in vehiculo.Extras) //borramos las referencias en la tabla intermedia (VehiculoExtras)
{
BD.DeleteVNuevo_Extra(new VNuevoExtrasDatos(new VNuevoExtrasClave(v.NumBastidor, e.Nombre)));
}
VNuevoDatos v1 = new VNuevoDatos(v.NumBastidor, v.Marca, v.Modelo, v.Potencia, v.PvRecomendado);
BD.DeleteVNuevos(v1);
}
/// <summary>
/// Devuelve la lista de todos los presupuestos del concesionario
/// </summary>
/// <returns></returns>
public static List <Presupuesto> listaPresupuesto()
{
List <Presupuesto> lista = new List <Presupuesto>();
int tam = BD.Presupuestos.Count;
for (int i = 0; i < tam; i++)
{
List <Vehiculo> vehiculos = new List <Vehiculo>();
PresupuestosDato pd = BD.Presupuestos[i];
Cliente c = new Cliente(pd.Cliente);
c = Buscar(c);
VehiculoNuevo vnuevo = new VehiculoNuevo(pd.VehiculoComprado);
Vehiculo v = null;
if (Existe(vnuevo))
{
if (ExisteVehiculoNuevo(vnuevo))
{
v = Buscar(vnuevo);
}
else
{
v = Buscar(new VehiculoSegundaMano(pd.VehiculoComprado));
}
}
int t = BD.Presupuesto_vehiculos.Count;
for (int i2 = 0; i2 < t; i2++)
{
Presupuesto_VehiculosDato pvd = BD.Presupuesto_vehiculos[i2];
if (pd.Id.Equals(pvd.Clave.Id))
{
VehiculoNuevo vn = new VehiculoNuevo(pvd.Clave.Vehiculo);
if (ExisteVehiculoNuevo(vn))
{
vehiculos.Add(Buscar(vn));
}
else
{
VehiculoSegundaMano vs = new VehiculoSegundaMano(pvd.Clave.Vehiculo);
vehiculos.Add(Buscar(vs));
}
}
}
Presupuesto p = new Presupuesto(pd.Id, c, pd.FechaRealizacion, pd.Estado, vehiculos, v);
lista.Add(p);
}
return(lista);
}
//--------------------------------------METODOS VARIOS---------------------------------------
/// <summary>
/// PRE: v puede contener solo la clave, debe estar incializado
/// POST:comprueba que existe y si es asi lo borra y devuelve true y en cualquier otro caso false
/// </summary>
/// <param name="v"></param>
/// <returns></returns>
public static bool eliminar(Vehiculo v)
{
if (existeYa(v))
{// Existe:
VehiculoNuevo busquedaNuevo = v as VehiculoNuevo;
if (busquedaNuevo != null)
{ //Se trata de un v nuevo
Persistencia.Borrar(busquedaNuevo);
return(true);
}
else
{ //Se trata de un v de segunda mano
VehiculoSegundaMano busquedaSegundaMano = v as VehiculoSegundaMano;
Persistencia.Borrar(busquedaSegundaMano);
return(true);
}
}
return(false);
}
/// <summary>
/// PRE: la clase debe de estar inicializada
/// POST: metodo de respuesta al evento CurrentItemChanged de BindingSource, actualiza los textBox para mostrar el vehiculo correspondiente
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void cambio(Object sender, EventArgs e)
{
Vehiculo v = LNVehiculo.LogicaNegocioVehiculo.buscar(this.bindingSource.Current as Vehiculo);
VehiculoNuevo nuevo = v as VehiculoNuevo;
if (nuevo != null)
{
this.rbtNuevo.Checked = true;
this.noMostrarSegundaDatos();
this.asignarDatos();
}
else
{
VehiculoSegundaMano segunda = v as VehiculoSegundaMano;
this.rbtSegundaMano.Checked = true;
this.mostrarSegundaDatos();
this.asignarDatos();
this.tbMatricula.Text = segunda.Matricula;
this.tbFechaMatricula.Text = segunda.FechaMatriculacion.ToShortDateString();
}
}
/// <summary>
/// PRE:la clase que se pasa como parametro debe de estar incializada
/// POST: Dado un VehiculoNuevo (Del que solo se utilizara la clave), devuelve true si existe un vehiculo cuya clave coincida con v1, false en caso contrario
/// </summary>
/// <param name="v1"></param>
/// <returns></returns>
public static bool ExisteVehiculoNuevo(VehiculoNuevo v1)
{
VNuevoDatos v = new VNuevoDatos(v1.NumBastidor, v1.Marca, v1.Modelo, v1.Potencia, v1.PvRecomendado);
return(BD.ExistsVehiculoNuevo(v));
}
/// <summary>
/// PRE:la clase que se pasa como parametro debe de estar incializada
/// POST:Dado un VehiculoNuevo, se actualizara el vehiculo cuya clave coincida con v1 (No se contempla el caso en el que no existe ningun vehiculo con dicha clave), cambiando todos sus campos a los valores que trae v1
/// </summary>
/// <param name="v1"></param>
public static void Actualizar(VehiculoNuevo v1)
{
Persistencia.Borrar(v1);
Persistencia.Añadir(v1);
}
/// <summary>
/// PRE: v debe de estar inicializado
/// POST: devuelve true si dicho vehiculo estan en nuestra coleccion y falso en caso contrario
/// </summary>
/// <param name="v"></param>
/// <returns></returns>
public static bool existeYa(VehiculoNuevo v)
{
return(Persistencia.Existe(v));
}
