Exemple #1
0
        // PRE: p != null.
        // POS: devuelve un objeto de tipo MD.Presupuesto, creado a partir de un objeto de tipo PresupuestoDato.
        private static MD.Presupuesto presupuestoDatoAPresupuesto(PresupuestoDato pDato)
        {
            Dictionary <MD.Vehiculo, double> valoraciones = new Dictionary <MD.Vehiculo, double>();

            foreach (KeyValuePair <VehiculoDato, double> kvp in pDato.Valoraciones)
            {
                valoraciones.Add(PersistenciaVehiculo.VehiculoDatoAVehiculo(kvp.Key), kvp.Value);
            }

            MD.Estado estado = MD.Estado.Pendiente;

            switch (pDato.Estado)
            {
            case EstadoDato.Aceptado:
                estado = MD.Estado.Aceptado;
                break;

            case EstadoDato.Desestimado:
                estado = MD.Estado.Desestimado;
                break;
            }

            MD.Presupuesto presupuesto = new MD.Presupuesto(pDato.FechaRealizacion, Persistencia.PersistenciaCliente.CambioACliente(pDato.Cliente), valoraciones);
            presupuesto.Vehiculo = Persistencia.PersistenciaVehiculo.VehiculoDatoAVehiculo(pDato.Vehiculo);
            presupuesto.Estado   = estado;
            return(presupuesto);
        }
Exemple #2
0
 // PRE: p != null.
 // POS: devuelve un objeto de tipo MD.Presupuesto si p es encontrado en la BD, null en caso contrario.
 public static MD.Presupuesto Buscar(MD.Presupuesto p)
 {
     if (BD.Presupuestos != null)
     {
         PresupuestoDato pd  = presupuestoAPresupuestoDato(p);
         PresupuestoDato res = BD.SELECTPresupuesto(pd);
         if (res != null)
         {
             Dictionary <MD.Vehiculo, double> valoraciones = new Dictionary <MD.Vehiculo, double>();
             foreach (KeyValuePair <VehiculoDato, double> kvp in res.Valoraciones)
             {
                 valoraciones.Add(PersistenciaVehiculo.VehiculoDatoAVehiculo(kvp.Key), kvp.Value);
             }
             return(new MD.Presupuesto(res.FechaRealizacion, Persistencia.PersistenciaCliente.CambioACliente(res.Cliente), valoraciones));
         }
         else
         {
             return(null);
         }
     }
     else
     {
         return(null);
     }
 }
Exemple #3
0
        public static List <Alquiler> Listar_Alquileres_Por_Vehiculo(Vehiculo V)
        {
            List <Alquiler> Listado = new List <Alquiler>();;
            SqlDataReader   oReader;

            SqlConnection oConexion = new SqlConnection(Conexion.STR);
            SqlCommand    oComando  = new SqlCommand("Listado_Alquileres_Por_Vehiculo", oConexion);

            oComando.CommandType = CommandType.StoredProcedure;
            oComando.Parameters.AddWithValue("@vehiculo", V.Matricula);

            try
            {
                oConexion.Open();
                oReader = oComando.ExecuteReader();

                if (oReader.HasRows)
                {
                    while (oReader.Read())
                    {
                        Alquiler A = new Alquiler(PersistenciaCliente.Buscar(Convert.ToInt32(oReader["cliente"])),
                                                  PersistenciaVehiculo.Buscar(oReader["vehiculo"].ToString()),
                                                  Convert.ToDateTime(oReader["fechainicio"]),
                                                  Convert.ToDateTime(oReader["fechafin"]),
                                                  Convert.ToInt32(oReader["costo"]), false);

                        Listado.Add(A);
                    }
                }

                oReader.Close();
            }

            catch (Exception ex)
            {
                throw new ApplicationException("Problemas con la base de datos:" + ex.Message);
            }
            finally
            {
                oConexion.Close();
            }

            return(Listado);
        }
Exemple #4
0
        // PRE: p != null.
        // POS: devuelve un objeto de tipo PresupuestoDato, creado a partir de un objeto de tipo MD.Presupuesto.
        private static PresupuestoDato presupuestoAPresupuestoDato(MD.Presupuesto p)
        {
            Dictionary <VehiculoDato, double> valoraciones = new Dictionary <VehiculoDato, double>();

            foreach (KeyValuePair <MD.Vehiculo, double> kvp in p.Valoracion)
            {
                valoraciones.Add(PersistenciaVehiculo.VehiculoAVehiculoDato(kvp.Key), kvp.Value);
            }

            EstadoDato estado = EstadoDato.Pendiente;

            switch (p.Estado)
            {
            case MD.Estado.Aceptado:
                estado = EstadoDato.Aceptado;
                break;

            case MD.Estado.Desestimado:
                estado = EstadoDato.Desestimado;
                break;
            }

            return(new PresupuestoDato(p.FechaRealizacion, Persistencia.PersistenciaCliente.CambioAClienteDato(p.Cliente), Persistencia.PersistenciaVehiculo.VehiculoAVehiculoDato(p.Vehiculo), estado, valoraciones));
        }