mira, tengo este proyecto para hacer: Proyecto Final V1 Construcción de app para la…
- User
mira, tengo este proyecto para hacer:
Proyecto Final V1
Construcción de app para la gestión de una terminal de transportes.
El proyecto que aquí se describe será una versión inicial y puede verse sujeta a cambios en la medida que se terminan los temas de clase, por otro lado, se diferenciará el alcance de lo que será para estructuras de datos, ya que se dejarán subrayados los requerimientos que aplican para este espacio, lo que no esté subrayado aplica de manera conjunta o solo para el espacio de lenguaje de programación. Para los estudiantes que ven ambos cursos conmigo, la nota será conjunta.
El sistema de gestión que se quiere construir tendrá varios tipos de usuarios que podrán ingresar a la aplicación a través de un login y cada uno tendrá operaciones específicas de su rol.
A continuación listo roles y los requerimientos que debe incluir:
Administrador Terminal.
- Gestión de casetas de transporte. (Una caseta es el espacio establecido para que una empresa de transporte particular tenga su lugar de comando de flota) a) Las casetas estarán pre establecidas de manera visual en forma de matriz, la ilustración se dará más adelante en el documento. b) Al dar clic sobre una caseta disponible podrá ingresar la información de un Administrador de Flota, encargado de la empresa de transporte que se asignará a tal puesto, adicionalmente indicará información como el nit, el nombre de la empresa de transporte, valor por canon de arrendamiento de la caseta y cantidad de plazas de estacionamiento. No tenga en cuenta el numeral c. c) Se podrá dar gestión completa de las empresas de transporte (debe incluir un listado visible de ellas) d) Un administrador de flota solo puede trabajar para una empresa a la vez, así mismo, no se puede registrar dos veces la misma empresa transportadora en la terminal.
Administrador de Flota
- Gestiona los buses de la empresa a. No puede repetirse la placa de un bus entre las demás empresas de transporte. b. Podrá registrar tantos vehículos como plazas de estacionamiento se hayan descrito para la empresa de transporte. c. Un vehículo al registrarse cuenta con una cantidad fija de puestos disponibles para los viajes.
- Gestiona los viajes: a. Un viaje tiene origen (debe ser fija la ciudad de la terminal), destino, hora de salida, fecha y hora de llegada a destino, debe tener la fecha de la creación (Esta debe ser tomada del sistema), el vehículo que se usará y el valor unitario por el viaje. i. Durante el tiempo del viaje, el vehículo se encontrará inhabilitado para estar en otro viaje, volverá a estar habilitado un día después de la fecha de llegada de cualquiera de sus viajes. ii. Tenga en cuenta que un vehículo puede estar programado para diferentes viajes de la empresa.
- Venta de tiquetes de viaje a. Podrá vender tiquetes de un viaje específico, siempre que el vehículo aún tenga puestos disponibles. Debe especificar la cantidad de tiquetes que quiere comprar el cliente, el cliente que los comprará, la fecha de compra. i. El cliente acumulará 3 puntos por cada 30000. iii. Si el viaje se encuentra lleno, el cliente podrá acceder a una cola de espera, al desocuparse la cantidad de tiquetes que tiene pendientes por compra, se le asignarán automáticamente y le dejará un mensaje tipo notificación en el cliente. Quedarán como reservas activas para que el cliente las haga efectivas.
- Hará efectivas las reservas de los clientes (Hacer efectiva una reserva equivale a convertirla en un tiquete vendido)
- Podrá devolver el dinero de la compra de un tiquete a. Esto dejará el espacio disponible en el viaje, pero descontará los puntos que el cliente adquirió con la compra. b. Se desea llevar un historial de las devoluciones que se han realizado.
Cliente
- Podrá registrarse desde la ventana de login
- Al ingresar podrá ver un menú general de sus acciones: a. Resumen de su información b. Resumen de los puntos acumulados e historial de redención de puntos. c. Resumen de devoluciones que haya tenido d. Podrá reservar un tiquete: i. Verá la lista de viajes disponibles y podrá filtrarlos por fecha, destino o incluso ambos al tiempo. ii. Al seleccionar uno podrá generar una reserva iii. Podrá cancelar sus reservas activas iv. Tenga en cuenta que las reservas cuentan como ocupación dentro de la cantidad de puestos del viaje hasta que sean efectivas con la compra o canceladas. e. Notificaciones (Los mensajes que recibe al asignarse la posibilidad de un tiquete)
Distribución visual casetas (Imagen de la matriz de casetas)
Notas:
- Debe hacer uso de las estructuras de datos que construyó durante el curso
- Construir una aplicación en Java dando uso a todos los conceptos que conoce y sean necesarios, incluyendo buenas prácticas.
NECESITO QUE SOLAMENTE ME AYUDES A SACAR TODO LO QUE TENGA QUE VER CON VIAJE, TODO EL MODELO CON LOS METODOS Y EL CONTROLADOR, ES EN JAVA Y CON NETTBEANS, POR EL MOMENTO SOLAMENTE LLEVO ESTO:
Folder Structure:
ProyectoFinal/ ├─ model/ │ model/ │ ├─ Bus.java │ ├─ Usuario.java │ ├─ Viaje.java │ ├─ AdministradorFlota.java │ ├─ EmpresaTransporte.java │ ├─ AdministradorTerminal.java │ ├─ Notificacion.java │ ├─ Tiquete.java │ ├─ Cliente.java │ ├─ Devolucion.java │ ├─ Reserva.java │ └─ Caseta.java ├─ controller/ │ controller/ │ ├─ ControladorLogin.java │ ├─ ControladorAdministradorTerminal.java │ ├─ ControladorCliente.java │ └─ ControladorAdministradorFlota.java ├─ Main.java ├─ .git/ │ .git/ │ ├─ info/ │ │ info/ │ │ └─ exclude │ ├─ description │ ├─ logs/ │ │ logs/ │ │ ├─ HEAD │ │ └─ refs/ │ │ refs/ │ │ ├─ heads/ │ │ │ heads/ │ │ │ └─ main │ │ └─ remotes/ │ │ remotes/ │ │ └─ origin/ │ │ origin/ │ │ └─ main │ ├─ index │ ├─ COMMIT_EDITMSG │ ├─ hooks/ │ │ hooks/ │ │ ├─ update.sample │ │ ├─ prepare-commit-msg.sample │ │ ├─ applypatch-msg.sample │ │ ├─ pre-merge-commit.sample │ │ ├─ push-to-checkout.sample │ │ ├─ commit-msg.sample │ │ ├─ post-update.sample │ │ ├─ pre-rebase.sample │ │ ├─ sendemail-validate.sample │ │ ├─ pre-push.sample │ │ ├─ fsmonitor-watchman.sample │ │ ├─ pre-commit.sample │ │ ├─ pre-receive.sample │ │ └─ pre-applypatch.sample │ ├─ HEAD │ ├─ config │ ├─ objects/ │ │ objects/ │ │ ├─ d5/ │ │ │ d5/ │ │ │ └─ b3ee75bec1f4f6c520b2de2336bb3afc438f13 │ │ ├─ 99/ │ │ │ 99/ │ │ │ └─ 9fddae54733938714b2d3448cbdd8323bf2014 │ │ ├─ 15/ │ │ │ 15/ │ │ │ └─ f48955fc09125fb077fa705f19ba5f8c1b3e70 │ │ ├─ 23/ │ │ │ 23/ │ │ │ └─ 6c7c0d510bb534264004e6a44396ca6890df7a │ │ ├─ 2c/ │ │ │ 2c/ │ │ │ └─ c4c73a263df6062f8e3ab4a2595a3c70b663f3 │ │ ├─ a5/ │ │ │ a5/ │ │ │ └─ 4f5e85e49bf719d0d368b4036074c9ad1a5595 │ │ ├─ fe/ │ │ │ fe/ │ │ │ └─ e07de4ff480f9e0227ca2fa3d691e39cc5d002 │ │ ├─ 90/ │ │ │ 90/ │ │ │ └─ 1ae6f4011415a9cddc725fd1d572588fc1737b │ │ ├─ fc/ │ │ │ fc/ │ │ │ └─ ed66f138ee5fa193e7788e77b8bb6caff61307 │ │ ├─ 16/ │ │ │ 16/ │ │ │ └─ 8797414cc54d8bdf9fd5e7e1a2dc6fd6bc1e91 │ │ ├─ d3/ │ │ │ d3/ │ │ │ └─ 130ee47e51bd701677655dd7a7886ffdaa6ab5 │ │ ├─ 28/ │ │ │ 28/ │ │ │ └─ 9da24ac57d9b456617d79dbaf8719118e64fad │ │ ├─ 08/ │ │ │ 08/ │ │ │ └─ 5f54d075da27f49b2796b47cca1453035eaf6b │ │ ├─ 2f/ │ │ │ 2f/ │ │ │ └─ 10f5e458fc3cdffa3194763594c150a1161ebd │ │ ├─ 46/ │ │ │ 46/ │ │ │ └─ 33927cb0f39fe89fa2626b3c4a841687972255 │ │ ├─ cf/ │ │ │ cf/ │ │ │ └─ a478d1579d14acaa400f4762f4acf02924cdc3 │ │ ├─ e1/ │ │ │ e1/ │ │ │ └─ d44b6f2e3bcda4366516516d3b4ec9e95ff8cb │ │ ├─ 4c/ │ │ │ 4c/ │ │ │ └─ 2a0ec81968b9cfc14ad4854f792a45660e6237 │ │ ├─ c7/ │ │ │ c7/ │ │ │ └─ 5b330c87ebc84e1b44d1184ea4a72258b6d8b4 │ │ ├─ d6/ │ │ │ d6/ │ │ │ └─ 0435f5721b1e71349a9f3115acb12d56c98cf1 │ │ ├─ 1e/ │ │ │ 1e/ │ │ │ └─ fe0a80df9b72065c43c0fa949ca4056e28aa82 │ │ ├─ a8/ │ │ │ a8/ │ │ │ └─ 6820b35e31f43ed7709ad95df105c9b7f5197c │ │ ├─ 13/ │ │ │ 13/ │ │ │ └─ f09577431a2373ce175ad736d501b810d589e2 │ │ ├─ d8/ │ │ │ d8/ │ │ │ └─ 027820e01a0aef29646238df66f42ca69efca7 │ │ └─ f9/ │ │ f9/ │ │ └─ e5e037f9cfa7ba27b6c4618f1c9f1a228599af │ └─ refs/ │ refs/ │ ├─ heads/ │ │ heads/ │ │ └─ main │ └─ remotes/ │ remotes/ │ └─ origin/ │ origin/ │ └─ main └─ util/ util/ ├─ ListaEnlazada.java ├─ Cola.java └─ Nodo.java
File Contents:
File: ProyectoFinal/model/Bus.java
// src/model/Bus.java package model;
import util.ListaEnlazada;
/**
-
Clase que representa un bus. */ public class Bus { private String placa; private int puestosDisponibles; private ListaEnlazada viajesProgramados;
// Constructor public Bus(String placa, int puestosDisponibles) { this.placa = placa; this.puestosDisponibles = puestosDisponibles; this.viajesProgramados = new ListaEnlazada<>(); }
// Getters y Setters public String getPlaca() { return placa; }
public void setPlaca(String placa) { this.placa = placa; }
public int getPuestosDisponibles() { return puestosDisponibles; }
public void setPuestosDisponibles(int puestosDisponibles) { this.puestosDisponibles = puestosDisponibles; }
public ListaEnlazada getViajesProgramados() { return viajesProgramados; }
public void setViajesProgramados(ListaEnlazada viajesProgramados) { this.viajesProgramados = viajesProgramados; }
// Métodos específicos
/**
- Agrega un viaje programado al bus. */ public void agregarViaje(Viaje viaje) { this.viajesProgramados.agregar(viaje); } }
File: ProyectoFinal/model/Usuario.java
package model;
/**
-
Clase abstracta que representa un usuario en el sistema. */ public abstract class Usuario { protected String usuario; protected String contraseña; protected String nombre; protected String apellido;
// Constructor public Usuario(String usuario, String contraseña, String nombre, String apellido) { this.usuario = usuario; this.contraseña = contraseña; this.nombre = nombre; this.apellido = apellido; }
// Getters y Setters public String getUsuario() { return usuario; }
public void setUsuario(String usuario) { this.usuario = usuario; }
public String getContraseña() { return contraseña; }
public void setContraseña(String contraseña) { this.contraseña = contraseña; }
public String getNombre() { return nombre; }
public void setNombre(String nombre) { this.nombre = nombre; }
public String getApellido() { return apellido; }
public void setApellido(String apellido) { this.apellido = apellido; } }
File: ProyectoFinal/model/Viaje.java
package model;
import util.Cola; import java.time.LocalDateTime; import java.time.LocalTime;
/**
-
Clase que representa un viaje. */ public class Viaje { private String origen; private String destino; private LocalTime horaSalida; private LocalDateTime fechaLlegada; private LocalDateTime fechaCreacion; private Bus busAsignado; private double valorUnitario; private int capacidad; private int tiquetesVendidos; private Cola colaEspera;
// Constructor public Viaje(String origen, String destino, LocalTime horaSalida, LocalDateTime fechaLlegada, Bus busAsignado, double valorUnitario) { this.origen = origen; this.destino = destino; this.horaSalida = horaSalida; this.fechaLlegada = fechaLlegada; this.fechaCreacion = LocalDateTime.now(); this.busAsignado = busAsignado; this.valorUnitario = valorUnitario; this.capacidad = busAsignado.getPuestosDisponibles(); this.tiquetesVendidos = 0; this.colaEspera = new Cola<>(); }
// Getters y Setters public String getOrigen() { return origen; }
public void setOrigen(String origen) { this.origen = origen; }
public String getDestino() { return destino; }
public void setDestino(String destino) { this.destino = destino; }
public LocalTime getHoraSalida() { return horaSalida; }
public void setHoraSalida(LocalTime horaSalida) { this.horaSalida = horaSalida; }
public LocalDateTime getFechaLlegada() { return fechaLlegada; }
public void setFechaLlegada(LocalDateTime fechaLlegada) { this.fechaLlegada = fechaLlegada; }
public LocalDateTime getFechaCreacion() { return fechaCreacion; }
public void setFechaCreacion(LocalDateTime fechaCreacion) { this.fechaCreacion = fechaCreacion; }
public Bus getBusAsignado() { return busAsignado; }
public void setBusAsignado(Bus busAsignado) { this.busAsignado = busAsignado; }
public double getValorUnitario() { return valorUnitario; }
public void setValorUnitario(double valorUnitario) { this.valorUnitario = valorUnitario; }
public int getCapacidad() { return capacidad; }
public void setCapacidad(int capacidad) { this.capacidad = capacidad; }
public int getTiquetesVendidos() { return tiquetesVendidos; }
public void setTiquetesVendidos(int tiquetesVendidos) { this.tiquetesVendidos = tiquetesVendidos; }
public Cola getColaEspera() { return colaEspera; }
public void setColaEspera(Cola colaEspera) { this.colaEspera = colaEspera; }
// Métodos específicos
/**
- Vende tiquetes si hay disponibilidad. */ public boolean venderTiquete(int cantidad) { if (tiquetesVendidos + cantidad <= capacidad) { tiquetesVendidos += cantidad; return true; } return false; }
/**
- Agrega un cliente a la cola de espera. */ public void agregarACola(Cliente cliente) { this.colaEspera.encolar(cliente); }
/**
- Procesa la cola de espera y asigna tiquetes si hay disponibilidad. */ public void procesarCola() { while (!colaEspera.estaVacia() && tiquetesVendidos < capacidad) { Cliente cliente = colaEspera.desencolar(); // Asume que el cliente desea comprar una reserva pendiente // Aquí deberías implementar la lógica para notificar al cliente y asignar tiquetes cliente.agregarNotificacion(new Notificacion("Tu reserva para el viaje a " + destino + " está disponible.")); } } }
File: ProyectoFinal/model/AdministradorFlota.java
package model;
import util.ListaEnlazada; import java.time.LocalDateTime; import java.time.LocalTime;
/**
-
Clase que representa al administrador de flota. */ public class AdministradorFlota extends Usuario { private EmpresaTransporte empresa;
// Constructor public AdministradorFlota(String usuario, String contraseña, String nombre, String apellido, EmpresaTransporte empresa) { super(usuario, contraseña, nombre, apellido); this.empresa = empresa; }
// Getters y Setters public EmpresaTransporte getEmpresa() { return empresa; }
public void setEmpresa(EmpresaTransporte empresa) { this.empresa = empresa; }
// Métodos específicos
/**
- Registra un nuevo bus en la empresa. */ public boolean registrarBus(String placa, int puestos, ListaEnlazada todasLasEmpresas) { // Verifica si la placa ya existe en otras empresas for (EmpresaTransporte emp : todasLasEmpresas) { for (Bus bus : emp.getBuses()) { if (bus.getPlaca().equalsIgnoreCase(placa)) { return false; // Placa ya existente } } } Bus nuevoBus = new Bus(placa, puestos); empresa.agregarBus(nuevoBus); return true; }
/**
- Crea un nuevo viaje. */ public boolean crearViaje(String destino, LocalTime horaSalida, LocalDateTime fechaLlegada, Bus bus, double valorUnitario) { // Verifica si el bus está disponible for (Viaje viaje : bus.getViajesProgramados()) { if (viaje.getFechaLlegada().isAfter(LocalDateTime.now())) { // Puedes agregar lógica adicional para verificar si las fechas se solapan // Por simplicidad, asumimos que si la fecha de llegada es después de ahora, el bus está ocupado return false; } } Viaje nuevoViaje = new Viaje("Ciudad Terminal", destino, horaSalida, fechaLlegada, bus, valorUnitario); empresa.agregarViaje(nuevoViaje); bus.agregarViaje(nuevoViaje); return true; }
/**
- Vende tiquetes para un viaje específico. */ public boolean venderTiquete(Viaje viaje, Cliente cliente, int cantidad) { if (viaje.venderTiquete(cantidad)) { Tiquete tiquete = new Tiquete(viaje, cliente, cantidad); cliente.acumularPuntos(viaje.getValorUnitario() * cantidad); empresa.agregarTiquete(tiquete); return true; } else { viaje.agregarACola(cliente); return false; // Viaje lleno, se agrega a la cola de espera } }
/**
- Procesa la cola de espera de un viaje. */ public void procesarColaEsperas(Viaje viaje) { viaje.procesarCola(); }
/**
- Devuelve un tiquete y actualiza los puntos del cliente. */ public boolean devolverTiquete(Tiquete tiquete) { Cliente cliente = tiquete.getCliente(); cliente.reducirPuntos(tiquete.getMontoInvertido() / 10000 * 3); // Asumiendo que 3 puntos por cada $10,000 empresa.eliminarTiquete(tiquete); double monto = tiquete.getCantidad() * tiquete.getViaje().getValorUnitario(); Devolucion devolucion = new Devolucion(tiquete, monto); cliente.agregarDevolucion(devolucion); return true; } }
File: ProyectoFinal/model/EmpresaTransporte.java
package model;
import util.ListaEnlazada;
/**
-
Clase que representa a una empresa de transporte. */ public class EmpresaTransporte { private String nit; private String nombreEmpresa; private double canonArrendamiento; private int plazasEstacionamiento; private ListaEnlazada buses; private ListaEnlazada viajes; private ListaEnlazada tiquetesVendidos;
// Constructor public EmpresaTransporte(String nit, String nombreEmpresa, double canonArrendamiento, int plazasEstacionamiento) { this.nit = nit; this.nombreEmpresa = nombreEmpresa; this.canonArrendamiento = canonArrendamiento; this.plazasEstacionamiento = plazasEstacionamiento; this.buses = new ListaEnlazada<>(); this.viajes = new ListaEnlazada<>(); this.tiquetesVendidos = new ListaEnlazada<>(); }
// Getters y Setters public String getNit() { return nit; }
public void setNit(String nit) { this.nit = nit; }
public String getNombreEmpresa() { return nombreEmpresa; }
public void setNombreEmpresa(String nombreEmpresa) { this.nombreEmpresa = nombreEmpresa; }
public double getCanonArrendamiento() { return canonArrendamiento; }
public void setCanonArrendamiento(double canonArrendamiento) { this.canonArrendamiento = canonArrendamiento; }
public int getPlazasEstacionamiento() { return plazasEstacionamiento; }
public void setPlazasEstacionamiento(int plazasEstacionamiento) { this.plazasEstacionamiento = plazasEstacionamiento; }
public ListaEnlazada getBuses() { return buses; }
public void setBuses(ListaEnlazada buses) { this.buses = buses; }
public ListaEnlazada getViajes() { return viajes; }
public void setViajes(ListaEnlazada viajes) { this.viajes = viajes; }
public ListaEnlazada getTiquetesVendidos() { return tiquetesVendidos; }
public void setTiquetesVendidos(ListaEnlazada tiquetesVendidos) { this.tiquetesVendidos = tiquetesVendidos; }
// Métodos específicos
/**
- Agrega un bus a la empresa. */ public void agregarBus(Bus bus) { this.buses.agregar(bus); }
/**
- Agrega un viaje a la empresa. */ public void agregarViaje(Viaje viaje) { this.viajes.agregar(viaje); }
/**
- Agrega un tiquete a la lista de tiquetes vendidos. */ public void agregarTiquete(Tiquete tiquete) { this.tiquetesVendidos.agregar(tiquete); }
/**
- Elimina un tiquete de la lista de tiquetes vendidos. */ public boolean eliminarTiquete(Tiquete tiquete) { return this.tiquetesVendidos.eliminar(t -> t.equals(tiquete)); } }
File: ProyectoFinal/model/AdministradorTerminal.java
package model;
import util.ListaEnlazada;
/**
-
Clase que representa al administrador de la terminal. */ public class AdministradorTerminal extends Usuario { // Lista de casetas en la terminal private ListaEnlazada casetas;
// Constructor public AdministradorTerminal(String usuario, String contraseña, String nombre, String apellido) { super(usuario, contraseña, nombre, apellido); this.casetas = new ListaEnlazada<>(); }
// Getters y Setters public ListaEnlazada getCasetas() { return casetas; }
public void setCasetas(ListaEnlazada casetas) { this.casetas = casetas; }
// Métodos específicos
/**
- Asigna una empresa a una caseta específica. */ public boolean asignarCaseta(int fila, int columna, EmpresaTransporte empresa) { Caseta caseta = buscarCaseta(fila, columna); if (caseta != null && caseta.isDisponible()) { caseta.setEmpresaAsignada(empresa); return true; } return false; // Caseta no disponible o no encontrada }
/**
- Busca una caseta por su fila y columna. */ public Caseta buscarCaseta(int fila, int columna) { for (Caseta caseta : casetas) { if (caseta.getFila() == fila && caseta.getColumna() == columna) { return caseta; } } return null; }
/**
- Retorna una lista de todas las empresas asignadas a las casetas. */ public ListaEnlazada listarEmpresas() { ListaEnlazada empresas = new ListaEnlazada<>(); for (Caseta caseta : casetas) { if (caseta.getEmpresaAsignada() != null) { empresas.agregar(caseta.getEmpresaAsignada()); } } return empresas; }
/**
- Lista todas las casetas disponibles. */ public ListaEnlazada listarCasetasDisponibles() { ListaEnlazada disponibles = new ListaEnlazada<>(); for (Caseta caseta : casetas) { if (caseta.isDisponible()) { disponibles.agregar(caseta); } } return disponibles; }
/**
- Verifica si una empresa ya está registrada en alguna caseta. */ public boolean empresaRegistrada(String nit) { for (Caseta caseta : casetas) { EmpresaTransporte empresa = caseta.getEmpresaAsignada(); if (empresa != null && empresa.getNit().equals(nit)) { return true; } } return false; } }
File: ProyectoFinal/model/Notificacion.java
package model;
import java.time.LocalDateTime;
/**
-
Clase que representa una notificación para el cliente. */ public class Notificacion { private String mensaje; private LocalDateTime fecha; private boolean leida;
// Constructor public Notificacion(String mensaje) { this.mensaje = mensaje; this.fecha = LocalDateTime.now(); this.leida = false; }
// Getters y Setters public String getMensaje() { return mensaje; }
public void setMensaje(String mensaje) { this.mensaje = mensaje; }
public LocalDateTime getFecha() { return fecha; }
public void setFecha(LocalDateTime fecha) { this.fecha = fecha; }
public boolean isLeida() { return leida; }
public void setLeida(boolean leida) { this.leida = leida; }
// Métodos específicos
/**
- Marca la notificación como leída. */ public void marcarComoLeida() { this.leida = true; } }
File: ProyectoFinal/model/Tiquete.java
package model;
import java.time.LocalDate;
/**
-
Clase que representa un tiquete de viaje. */ public class Tiquete { private Viaje viaje; private Cliente cliente; private int cantidad; private LocalDate fechaCompra;
// Constructor public Tiquete(Viaje viaje, Cliente cliente, int cantidad) { this.viaje = viaje; this.cliente = cliente; this.cantidad = cantidad; this.fechaCompra = LocalDate.now(); }
// Getters y Setters public Viaje getViaje() { return viaje; }
public void setViaje(Viaje viaje) { this.viaje = viaje; }
public Cliente getCliente() { return cliente; }
public void setCliente(Cliente cliente) { this.cliente = cliente; }
public int getCantidad() { return cantidad; }
public void setCantidad(int cantidad) { this.cantidad = cantidad; }
public LocalDate getFechaCompra() { return fechaCompra; }
public void setFechaCompra(LocalDate fechaCompra) { this.fechaCompra = fechaCompra; }
/**
- Retorna el monto invertido en el tiquete. */ public double getMontoInvertido() { return cantidad * viaje.getValorUnitario(); }
@Override public boolean equals(Object obj) { if (this == obj) return true; if (!(obj instanceof Tiquete)) return false; Tiquete other = (Tiquete) obj; return this.viaje.equals(other.viaje) && this.cliente.equals(other.cliente) && this.cantidad == other.cantidad && this.fechaCompra.equals(other.fechaCompra); } }
File: ProyectoFinal/model/Cliente.java
package model;
import util.ListaEnlazada;
/**
-
Clase que representa a un cliente. */ public class Cliente extends Usuario { private int puntos; private ListaEnlazada reservas; private ListaEnlazada notificaciones; private ListaEnlazada historialDevoluciones;
// Constructor public Cliente(String usuario, String contraseña, String nombre, String apellido) { super(usuario, contraseña, nombre, apellido); this.puntos = 0; this.reservas = new ListaEnlazada<>(); this.notificaciones = new ListaEnlazada<>(); this.historialDevoluciones = new ListaEnlazada<>(); }
// Getters y Setters public int getPuntos() { return puntos; }
public void setPuntos(int puntos) { this.puntos = puntos; }
public ListaEnlazada getReservas() { return reservas; }
public void setReservas(ListaEnlazada reservas) { this.reservas = reservas; }
public ListaEnlazada getNotificaciones() { return notificaciones; }
public void setNotificaciones(ListaEnlazada notificaciones) { this.notificaciones = notificaciones; }
public ListaEnlazada getHistorialDevoluciones() { return historialDevoluciones; }
public void setHistorialDevoluciones(ListaEnlazada historialDevoluciones) { this.historialDevoluciones = historialDevoluciones; }
// Métodos específicos
/**
- Acumula puntos basados en el valor invertido. */ public void acumularPuntos(double valorInvertido) { this.puntos += (int) ((valorInvertido / 10000) * 3); }
/**
- Canjea puntos por un tiquete. */ public boolean canjearPuntos(int puntosACanjear) { if (this.puntos >= puntosACanjear) { this.puntos -= puntosACanjear; // Lógica para canjear puntos por tiquete return true; } return false; }
/**
- Añade una reserva a la lista de reservas. */ public void agregarReserva(Reserva reserva) { this.reservas.agregar(reserva); }
/**
- Añade una notificación a la lista de notificaciones. */ public void agregarNotificacion(Notificacion notificacion) { this.notificaciones.agregar(notificacion); }
/**
- Añade una devolución al historial de devoluciones. */ public void agregarDevolucion(Devolucion devolucion) { this.historialDevoluciones.agregar(devolucion); }
/**
- Reduce los puntos del cliente (usado en devoluciones). */ public void reducirPuntos(double puntosAReducir) { this.puntos -= puntosAReducir; if (this.puntos < 0) { this.puntos = 0; } }
/**
- Retorna el historial de reservas activas. */ public ListaEnlazada listarReservasActivas() { ListaEnlazada activas = new ListaEnlazada<>(); for (Reserva reserva : reservas) { if (!reserva.isEfectiva()) { activas.agregar(reserva); } } return activas; }
/**
- Cancela una reserva activa. */ public boolean cancelarReserva(Reserva reserva) { return this.reservas.eliminar(r -> r.equals(reserva)); } }
File: ProyectoFinal/model/Devolucion.java
package model;
import java.time.LocalDate;
/**
-
Clase que representa una devolución realizada por un cliente. */ public class Devolucion { private Tiquete tiquete; private double monto; private LocalDate fechaDevolucion;
// Constructor public Devolucion(Tiquete tiquete, double monto) { this.tiquete = tiquete; this.monto = monto; this.fechaDevolucion = LocalDate.now(); }
// Getters y Setters public Tiquete getTiquete() { return tiquete; }
public void setTiquete(Tiquete tiquete) { this.tiquete = tiquete; }
public double getMonto() { return monto; }
public void setMonto(double monto) { this.monto = monto; }
public LocalDate getFechaDevolucion() { return fechaDevolucion; }
public void setFechaDevolucion(LocalDate fechaDevolucion) { this.fechaDevolucion = fechaDevolucion; } }
File: ProyectoFinal/model/Reserva.java
package model;
import java.time.LocalDate;
/**
-
Clase que representa una reserva de tiquetes. */ public class Reserva { private Viaje viaje; private Cliente cliente; private int cantidad; private LocalDate fechaReserva; private boolean efectiva;
// Constructor public Reserva(Viaje viaje, Cliente cliente, int cantidad) { this.viaje = viaje; this.cliente = cliente; this.cantidad = cantidad; this.fechaReserva = LocalDate.now(); this.efectiva = false; }
// Getters y Setters public Viaje getViaje() { return viaje; }
public void setViaje(Viaje viaje) { this.viaje = viaje; }
public Cliente getCliente() { return cliente; }
public void setCliente(Cliente cliente) { this.cliente = cliente; }
public int getCantidad() { return cantidad; }
public void setCantidad(int cantidad) { this.cantidad = cantidad; }
public LocalDate getFechaReserva() { return fechaReserva; }
public void setFechaReserva(LocalDate fechaReserva) { this.fechaReserva = fechaReserva; }
public boolean isEfectiva() { return efectiva; }
public void setEfectiva(boolean efectiva) { this.efectiva = efectiva; }
@Override public boolean equals(Object obj) { if (this == obj) return true; if (!(obj instanceof Reserva)) return false; Reserva other = (Reserva) obj; return this.viaje.equals(other.viaje) && this.cliente.equals(other.cliente) && this.cantidad == other.cantidad && this.fechaReserva.equals(other.fechaReserva) && this.efectiva == other.efectiva; } }
File: ProyectoFinal/model/Caseta.java
package model;
/**
-
Clase que representa una caseta en la terminal. */ public class Caseta { private int fila; private int columna; private boolean disponible; private EmpresaTransporte empresaAsignada;
// Constructor public Caseta(int fila, int columna, EmpresaTransporte empresaAsignada) { this.fila = fila; this.columna = columna; this.empresaAsignada = empresaAsignada; this.disponible = (empresaAsignada == null); }
// Getters y Setters public int getFila() { return fila; }
public void setFila(int fila) { this.fila = fila; }
public int getColumna() { return columna; }
public void setColumna(int columna) { this.columna = columna; }
public boolean isDisponible() { return disponible; }
public void setDisponible(boolean disponible) { this.disponible = disponible; }
public EmpresaTransporte getEmpresaAsignada() { return empresaAsignada; }
public void setEmpresaAsignada(EmpresaTransporte empresaAsignada) { this.empresaAsignada = empresaAsignada; this.disponible = (empresaAsignada == null); } }
File: ProyectoFinal/controller/ControladorLogin.java
// src/controller/ControladorLogin.java package controller;
import model.Usuario; import model.Cliente; import model.EmpresaTransporte; import model.AdministradorTerminal; import model.AdministradorFlota; import util.ListaEnlazada;
/**
-
Controlador que gestiona las operaciones de inicio de sesión y registro de usuarios. */ public class ControladorLogin { private ListaEnlazada usuarios; private ListaEnlazada empresasTransporte;
// Constructor public ControladorLogin() { this.usuarios = new ListaEnlazada<>(); this.empresasTransporte = new ListaEnlazada<>(); inicializarUsuarios(); }
/**
-
Inicializa algunos usuarios predefinidos (opcional). */ private void inicializarUsuarios() { // Puedes agregar usuarios predefinidos aquí si lo deseas. // Ejemplo: AdministradorTerminal adminTerminal = new AdministradorTerminal("adminTerminal", "1234", "Admin", "Terminal"); usuarios.agregar(adminTerminal);
// Las empresas pueden ser agregadas a través del controlador del AdministradorTerminal. }
// Getters y Setters public ListaEnlazada getUsuarios() { return usuarios; }
public void setUsuarios(ListaEnlazada usuarios) { this.usuarios = usuarios; }
public ListaEnlazada getEmpresasTransporte() { return empresasTransporte; }
public void setEmpresasTransporte(ListaEnlazada empresasTransporte) { this.empresasTransporte = empresasTransporte; }
// Métodos específicos
/**
- Autentica un usuario con las credenciales proporcionadas. */ public Usuario autenticar(String usuario, String contraseña) { return usuarios.buscar(u -> u.getUsuario().equals(usuario) && u.getContraseña().equals(contraseña)); }
/**
- Registra un nuevo cliente en el sistema. */ public boolean registrarCliente(String usuario, String contraseña, String nombre, String apellido) { if (usuarios.buscar(u -> u.getUsuario().equals(usuario)) != null) { return false; // Usuario ya existe } Cliente nuevoCliente = new Cliente(usuario, contraseña, nombre, apellido); usuarios.agregar(nuevoCliente); return true; }
/**
- Registra un nuevo administrador de flota. */ public boolean registrarAdministradorFlota(String usuario, String contraseña, String nombre, String apellido, EmpresaTransporte empresa) { if (usuarios.buscar(u -> u.getUsuario().equals(usuario)) != null) { return false; // Usuario ya existe } AdministradorFlota nuevoAdminFlota = new AdministradorFlota(usuario, contraseña, nombre, apellido, empresa); usuarios.agregar(nuevoAdminFlota); return true; }
/**
- Agrega una nueva empresa de transporte al sistema. */ public boolean agregarEmpresaTransporte(EmpresaTransporte empresa) { if (empresasTransporte.buscar(e -> e.getNit().equals(empresa.getNit())) != null) { return false; // Empresa ya existe } empresasTransporte.agregar(empresa); return true; } }
-
File: ProyectoFinal/controller/ControladorAdministradorTerminal.java
package controller;
import model.AdministradorTerminal; import model.Caseta; import model.EmpresaTransporte; import util.ListaEnlazada;
/**
-
Controlador que gestiona las operaciones del Administrador de la Terminal. */ public class ControladorAdministradorTerminal { private AdministradorTerminal adminTerminal;
// Constructor public ControladorAdministradorTerminal(AdministradorTerminal adminTerminal) { this.adminTerminal = adminTerminal; }
// Métodos específicos
/**
- Asigna una empresa a una caseta específica. */ public boolean asignarEmpresaACaseta(int fila, int columna, EmpresaTransporte empresa) { if (adminTerminal.empresaRegistrada(empresa.getNit())) { return false; // La empresa ya está registrada en alguna caseta } return adminTerminal.asignarCaseta(fila, columna, empresa); }
/**
- Crea y agrega una nueva empresa de transporte. */ public boolean crearEmpresaTransporte(String nit, String nombreEmpresa, double canon, int plazasEstacionamiento) { if (adminTerminal.listarEmpresas().buscar(e -> e.getNit().equals(nit)) != null) { return false; // Empresa ya existe } EmpresaTransporte nuevaEmpresa = new EmpresaTransporte(nit, nombreEmpresa, canon, plazasEstacionamiento); adminTerminal.listarEmpresas().agregar(nuevaEmpresa); return true; }
/**
- Lista todas las empresas asignadas a las casetas. */ public ListaEnlazada obtenerListaEmpresas() { return adminTerminal.listarEmpresas(); }
/**
- Lista todas las casetas disponibles. */ public ListaEnlazada obtenerCasetasDisponibles() { return adminTerminal.listarCasetasDisponibles(); } }
File: ProyectoFinal/controller/ControladorCliente.java
package controller;
import model.Cliente; import model.Devolucion; import model.Notificacion; import model.Reserva; import model.Tiquete; import model.Viaje; import util.ListaEnlazada;
/**
-
Controlador que gestiona las operaciones del Cliente. */ public class ControladorCliente { private Cliente cliente;
// Constructor public ControladorCliente(Cliente cliente) { this.cliente = cliente; }
// Métodos específicos
/**
- Reserva tiquetes para un viaje específico. */ public boolean reservarTiquete(Viaje viaje, int cantidad) { if (viaje.venderTiquete(cantidad)) { Reserva reserva = new Reserva(viaje, cliente, cantidad); reserva.setEfectiva(true); cliente.agregarReserva(reserva); return true; } else { viaje.agregarACola(cliente); Reserva reserva = new Reserva(viaje, cliente, cantidad); cliente.agregarReserva(reserva); return false; // Reserva en cola de espera } }
/**
- Canjea puntos del cliente por un tiquete. */ public boolean canjearPuntos(int puntosACanjear) { return cliente.canjearPuntos(puntosACanjear); }
/**
- Cancela una reserva activa. */ public boolean cancelarReserva(Reserva reserva) { boolean eliminado = cliente.cancelarReserva(reserva); if (eliminado) { // Implementar lógica para actualizar la disponibilidad del viaje // Por ejemplo, incrementar tiquetes disponibles Viaje viaje = reserva.getViaje(); viaje.setTiquetesVendidos(viaje.getTiquetesVendidos() - reserva.getCantidad()); return true; } return false; }
/**
- Devuelve un tiquete y actualiza los puntos del cliente. */ public boolean devolverTiquete(Tiquete tiquete) { return cliente.getReservas().eliminar(r -> r.getViaje().equals(tiquete.getViaje()) && r.getCliente().equals(tiquete.getCliente()) && r.getCantidad() == tiquete.getCantidad()); // Implementar lógica adicional según sea necesario }
/**
- Obtiene el resumen de la información del cliente. */ public String obtenerResumenInformacion() { return "Nombre: " + cliente.getNombre() + " " + cliente.getApellido() + "\nUsuario: " + cliente.getUsuario() + "\nPuntos Acumulados: " + cliente.getPuntos(); }
/**
- Obtiene el historial de devoluciones del cliente. */ public ListaEnlazada obtenerHistorialDevoluciones() { return cliente.getHistorialDevoluciones(); }
/**
- Obtiene las notificaciones del cliente. */ public ListaEnlazada obtenerNotificaciones() { return cliente.getNotificaciones(); }
/**
- Marca una notificación como leída. */ public void marcarNotificacionComoLeida(Notificacion notificacion) { notificacion.marcarComoLeida(); }
/**
- Obtiene las reservas efectivas del cliente. */ public ListaEnlazada obtenerReservasEfectivas() { return cliente.listarReservasEfectivas(); }
/**
- Obtiene las reservas activas del cliente. */ public ListaEnlazada obtenerReservasActivas() { return cliente.listarReservasActivas(); } }
File: ProyectoFinal/controller/ControladorAdministradorFlota.java
package controller;
import java.time.LocalDateTime; import java.time.LocalTime;
import model.AdministradorFlota; import model.Bus; import model.Cliente; import model.EmpresaTransporte; import model.Viaje; import model.Tiquete; import util.ListaEnlazada;
/**
-
Controlador que gestiona las operaciones del Administrador de Flota. */ public class ControladorAdministradorFlota { private AdministradorFlota adminFlota; private ListaEnlazada todasLasEmpresas;
// Constructor public ControladorAdministradorFlota(AdministradorFlota adminFlota, ListaEnlazada todasLasEmpresas) { this.adminFlota = adminFlota; this.todasLasEmpresas = todasLasEmpresas; }
// Métodos específicos
/**
- Registra un nuevo bus en la empresa asignada. */ public boolean registrarBus(String placa, int puestos) { return adminFlota.registrarBus(placa, puestos, todasLasEmpresas); }
/**
- Crea un nuevo viaje para un bus específico. */ public boolean crearViaje(String destino, LocalTime horaSalida, LocalDateTime fechaLlegada, Bus bus, double valorUnitario) { return adminFlota.crearViaje(destino, horaSalida, fechaLlegada, bus, valorUnitario); }
/**
- Vende tiquetes para un viaje específico a un cliente. */ public boolean venderTiquete(Viaje viaje, Cliente cliente, int cantidad) { return adminFlota.venderTiquete(viaje, cliente, cantidad); }
/**
- Procesa la cola de espera de un viaje. */ public void procesarColaEsperas(Viaje viaje) { adminFlota.procesarColaEsperas(viaje); }
/**
- Devuelve un tiquete y actualiza los puntos del cliente. */ public boolean devolverTiquete(Tiquete tiquete) { return adminFlota.devolverTiquete(tiquete); } }
File: ProyectoFinal/Main.java
import controller.ControladorLogin; import controller.ControladorAdministradorTerminal; import controller.ControladorCliente; import controller.ControladorAdministradorFlota; import model.AdministradorTerminal; import model.EmpresaTransporte; import model.AdministradorFlota; import model.Bus; import model.Cliente; import model.Viaje; import util.ListaEnlazada;
public class Main { public static void main(String[] args) { // Inicializar el controlador de login ControladorLogin controladorLogin = new ControladorLogin();
// Crear y registrar una empresa de transporte EmpresaTransporte empresa1 = new EmpresaTransporte("123456789-0", "Transporte Express", 500000.0, 10); controladorLogin.agregarEmpresaTransporte(empresa1); // Registrar un Administrador de Flota para la empresa controladorLogin.registrarAdministradorFlota("adminFlota1", "passFlota1", "Carlos", "Pérez", empresa1); // Obtener el Administrador Terminal registrado AdministradorTerminal adminTerminal = (AdministradorTerminal) controladorLogin.getUsuarios().buscar(u -> u instanceof AdministradorTerminal); // Crear un controlador para el Administrador Terminal ControladorAdministradorTerminal controladorAdminTerminal = new ControladorAdministradorTerminal(adminTerminal); // Asignar la empresa a una caseta específica boolean asignado = controladorAdminTerminal.asignarEmpresaACaseta(0, 0, empresa1); if (asignado) { System.out.println("Empresa asignada a la caseta correctamente."); } else { System.out.println("Error al asignar la empresa a la caseta."); } // Crear un controlador para el Administrador de Flota AdministradorFlota adminFlota = (AdministradorFlota) controladorLogin.getUsuarios().buscar(u -> u instanceof AdministradorFlota); ControladorAdministradorFlota controladorAdminFlota = new ControladorAdministradorFlota(adminFlota, controladorLogin.getEmpresasTransporte()); // Registrar un nuevo bus boolean busRegistrado = controladorAdminFlota.registrarBus("ABC123", 50); if (busRegistrado) { System.out.println("Bus registrado exitosamente."); } else { System.out.println("Error al registrar el bus (placa duplicada)."); } // Crear un nuevo viaje ListaEnlazada<Bus> buses = empresa1.getBuses(); Bus bus = buses.buscar(b -> b.getPlaca().equals("ABC123")); if (bus != null) { boolean viajeCreado = controladorAdminFlota.crearViaje("Ciudad B", java.time.LocalTime.of(8, 0), java.time.LocalDateTime.of(2023, 12, 25, 12, 0), bus, 50000.0); if (viajeCreado) { System.out.println("Viaje creado exitosamente."); } else { System.out.println("Error al crear el viaje (bus no disponible)."); } } // Registrar un cliente boolean clienteRegistrado = controladorLogin.registrarCliente("cliente1", "passCliente1", "Ana", "García"); if (clienteRegistrado) { System.out.println("Cliente registrado exitosamente."); } else { System.out.println("Error al registrar el cliente (usuario duplicado)."); } // Autenticar al cliente model.Usuario usuarioAutenticado = controladorLogin.autenticar("cliente1", "passCliente1"); if (usuarioAutenticado != null && usuarioAutenticado instanceof Cliente) { Cliente cliente = (Cliente) usuarioAutenticado; ControladorCliente controladorCliente = new ControladorCliente(cliente); // Realizar una reserva ListaEnlazada<Viaje> viajes = empresa1.getViajes(); Viaje viaje = viajes.buscar(v -> v.getDestino().equals("Ciudad B")); if (viaje != null) { boolean reservaExitosa = controladorCliente.reservarTiquete(viaje, 2); if (reservaExitosa) { System.out.println("Reserva realizada exitosamente."); } else { System.out.println("Reserva agregada a la cola de espera."); } } } else { System.out.println("Error en la autenticación del cliente."); } }}
File: ProyectoFinal/.git/info/exclude
Contenido binario o no legible.
File: ProyectoFinal/.git/description
Contenido binario o no legible.
File: ProyectoFinal/.git/logs/HEAD
Contenido binario o no legible.
File: ProyectoFinal/.git/logs/refs/heads/main
Contenido binario o no legible.
File: ProyectoFinal/.git/logs/refs/remotes/origin/main
Contenido binario o no legible.
File: ProyectoFinal/.git/index
Contenido binario o no legible.
File: ProyectoFinal/.git/COMMIT_EDITMSG
Contenido binario o no legible.
File: ProyectoFinal/.git/hooks/update.sample
Contenido binario o no legible.
File: ProyectoFinal/.git/hooks/prepare-commit-msg.sample
Contenido binario o no legible.
File: ProyectoFinal/.git/hooks/applypatch-msg.sample
Contenido binario o no legible.
File: ProyectoFinal/.git/hooks/pre-merge-commit.sample
Contenido binario o no legible.
File: ProyectoFinal/.git/hooks/push-to-checkout.sample
Contenido binario o no legible.
File: ProyectoFinal/.git/hooks/commit-msg.sample
Contenido binario o no legible.
File: ProyectoFinal/.git/hooks/post-update.sample
Contenido binario o no legible.
File: ProyectoFinal/.git/hooks/pre-rebase.sample
Contenido binario o no legible.
File: ProyectoFinal/.git/hooks/sendemail-validate.sample
Contenido binario o no legible.
File: ProyectoFinal/.git/hooks/pre-push.sample
Contenido binario o no legible.
File: ProyectoFinal/.git/hooks/fsmonitor-watchman.sample
Contenido binario o no legible.
File: ProyectoFinal/.git/hooks/pre-commit.sample
Contenido binario o no legible.
File: ProyectoFinal/.git/hooks/pre-receive.sample
Contenido binario o no legible.
File: ProyectoFinal/.git/hooks/pre-applypatch.sample
Contenido binario o no legible.
File: ProyectoFinal/.git/HEAD
Contenido binario o no legible.
File: ProyectoFinal/.git/config
Contenido binario o no legible.
File: ProyectoFinal/.git/objects/d5/b3ee75bec1f4f6c520b2de2336bb3afc438f13
Contenido binario o no legible.
File: ProyectoFinal/.git/objects/99/9fddae54733938714b2d3448cbdd8323bf2014
Contenido binario o no legible.
File: ProyectoFinal/.git/objects/15/f48955fc09125fb077fa705f19ba5f8c1b3e70
Contenido binario o no legible.
File: ProyectoFinal/.git/objects/23/6c7c0d510bb534264004e6a44396ca6890df7a
Contenido binario o no legible.
File: ProyectoFinal/.git/objects/2c/c4c73a263df6062f8e3ab4a2595a3c70b663f3
Contenido binario o no legible.
File: ProyectoFinal/.git/objects/a5/4f5e85e49bf719d0d368b4036074c9ad1a5595
Contenido binario o no legible.
File: ProyectoFinal/.git/objects/fe/e07de4ff480f9e0227ca2fa3d691e39cc5d002
Contenido binario o no legible.
File: ProyectoFinal/.git/objects/90/1ae6f4011415a9cddc725fd1d572588fc1737b
Contenido binario o no legible.
File: ProyectoFinal/.git/objects/fc/ed66f138ee5fa193e7788e77b8bb6caff61307
Contenido binario o no legible.
File: ProyectoFinal/.git/objects/16/8797414cc54d8bdf9fd5e7e1a2dc6fd6bc1e91
Contenido binario o no legible.
File: ProyectoFinal/.git/objects/d3/130ee47e51bd701677655dd7a7886ffdaa6ab5
Contenido binario o no legible.
File: ProyectoFinal/.git/objects/28/9da24ac57d9b456617d79dbaf8719118e64fad
Contenido binario o no legible.
File: ProyectoFinal/.git/objects/08/5f54d075da27f49b2796b47cca1453035eaf6b
Contenido binario o no legible.
File: ProyectoFinal/.git/objects/2f/10f5e458fc3cdffa3194763594c150a1161ebd
Contenido binario o no legible.
File: ProyectoFinal/.git/objects/46/33927cb0f39fe89fa2626b3c4a841687972255
Contenido binario o no legible.
File: ProyectoFinal/.git/objects/cf/a478d1579d14acaa400f4762f4acf02924cdc3
Contenido binario o no legible.
File: ProyectoFinal/.git/objects/e1/d44b6f2e3bcda4366516516d3b4ec9e95ff8cb
Contenido binario o no legible.
File: ProyectoFinal/.git/objects/4c/2a0ec81968b9cfc14ad4854f792a45660e6237
Contenido binario o no legible.
File: ProyectoFinal/.git/objects/c7/5b330c87ebc84e1b44d1184ea4a72258b6d8b4
Contenido binario o no legible.
File: ProyectoFinal/.git/objects/d6/0435f5721b1e71349a9f3115acb12d56c98cf1
Contenido binario o no legible.
File: ProyectoFinal/.git/objects/1e/fe0a80df9b72065c43c0fa949ca4056e28aa82
Contenido binario o no legible.
File: ProyectoFinal/.git/objects/a8/6820b35e31f43ed7709ad95df105c9b7f5197c
Contenido binario o no legible.
File: ProyectoFinal/.git/objects/13/f09577431a2373ce175ad736d501b810d589e2
Contenido binario o no legible.
File: ProyectoFinal/.git/objects/d8/027820e01a0aef29646238df66f42ca69efca7
Contenido binario o no legible.
File: ProyectoFinal/.git/objects/f9/e5e037f9cfa7ba27b6c4618f1c9f1a228599af
Contenido binario o no legible.
File: ProyectoFinal/.git/refs/heads/main
Contenido binario o no legible.
File: ProyectoFinal/.git/refs/remotes/origin/main
Contenido binario o no legible.
File: ProyectoFinal/util/ListaEnlazada.java
package util;
import java.util.Iterator; import java.util.NoSuchElementException; import java.util.function.Predicate;
/**
-
Implementación genérica de una lista enlazada simple. */ public class ListaEnlazada implements Iterable { private Nodo cabeza;
public ListaEnlazada() { this.cabeza = null; }
/**
- Agrega un elemento al final de la lista. */ public void agregar(T dato) { Nodo nuevoNodo = new Nodo<>(dato); if (cabeza == null) { cabeza = nuevoNodo; } else { Nodo actual = cabeza; while (actual.getSiguiente() != null) { actual = actual.getSiguiente(); } actual.setSiguiente(nuevoNodo); } }
/**
- Busca el primer elemento que cumple con el criterio. */ public T buscar(Predicate criterio) { for (T elemento : this) { if (criterio.test(elemento)) { return elemento; } } return null; }
/**
-
Elimina el primer elemento que cumple con el criterio. */ public boolean eliminar(Predicate criterio) { if (cabeza == null) return false;
if (criterio.test(cabeza.getDato())) { cabeza = cabeza.getSiguiente(); return true; }
Nodo actual = cabeza; while (actual.getSiguiente() != null) { if (criterio.test(actual.getSiguiente().getDato())) { actual.setSiguiente(actual.getSiguiente().getSiguiente()); return true; } actual = actual.getSiguiente(); } return false; }
/**
- Retorna un iterador para la lista enlazada. */ @Override public Iterator iterator() { return new IteratorEnlazada(); }
/**
-
Clase interna para la implementación del iterador. */ private class IteratorEnlazada implements Iterator { private Nodo actual;
public IteratorEnlazada() { this.actual = cabeza; }
@Override public boolean hasNext() { return actual != null; }
@Override public T next() { if (actual == null) { throw new NoSuchElementException(); } T dato = actual.getDato(); actual = actual.getSiguiente(); return dato; } } }
File: ProyectoFinal/util/Cola.java
package util;
import java.util.Iterator; import java.util.NoSuchElementException;
/**
-
Implementación genérica de una cola (FIFO). */ public class Cola implements Iterable { private Nodo frente; private Nodo fin;
public Cola() { this.frente = this.fin = null; }
/**
- Encola un elemento al final de la cola. */ public void encolar(T dato) { Nodo nuevoNodo = new Nodo<>(dato); if (fin != null) { fin.setSiguiente(nuevoNodo); } fin = nuevoNodo; if (frente == null) { frente = fin; } }
/**
- Desencola un elemento del frente de la cola. */ public T desencolar() { if (frente == null) return null; T dato = frente.getDato(); frente = frente.getSiguiente(); if (frente == null) { fin = null; } return dato; }
/**
- Verifica si la cola está vacía. */ public boolean estaVacia() { return frente == null; }
/**
- Retorna un iterador para la cola. */ @Override public Iterator iterator() { return new IteratorCola(); }
/**
-
Clase interna para la implementación del iterador de la cola. */ private class IteratorCola implements Iterator { private Nodo actual;
public IteratorCola() { this.actual = frente; }
@Override public boolean hasNext() { return actual != null; }
@Override public T next() { if (actual == null) { throw new NoSuchElementException(); } T dato = actual.getDato(); actual = actual.getSiguiente(); return dato; } } }
File: ProyectoFinal/util/Nodo.java
package util;
/**
-
Clase genérica Nodo para implementar estructuras de datos enlazadas. */ public class Nodo { private T dato; private Nodo siguiente;
public Nodo(T dato) { this.dato = dato; this.siguiente = null; }
// Getters y Setters public T getDato() { return dato; }
public void setDato(T dato) { this.dato = dato; }
public Nodo getSiguiente() { return siguiente; }
public void setSiguiente(Nodo siguiente) { this.siguiente = siguiente; } }
- Assistant
¡Hola! Entiendo que necesitas ayuda para desarrollar la parte relacionada con los Viajes (Viaje) en tu proyecto de gestión de una terminal de transportes. A continuación, te proporcionaré una implementación completa del modelo
Viajey un controladorControladorViajeen Java, siguiendo los requerimientos que mencionaste. Además, te ofreceré explicaciones detalladas sobre cada componente para asegurarnos de que todo funcione correctamente dentro de tu estructura de proyecto actual.1. Modelo
ViajePrimero, revisemos y ampliemos la clase
Viajepara asegurar que cumpla con todos los requerimientos funcionales. Añadiremos métodos para manejar la disponibilidad del bus, la venta de tiquetes, la gestión de la cola de espera y otras operaciones necesarias.Archivo:
ProyectoFinal/model/Viaje.java// src/model/Viaje.java package model; import util.Cola; import java.time.LocalDateTime; import java.time.LocalTime; /** * Clase que representa un viaje. */ public class Viaje { private String origen; // Fijo: "Ciudad Terminal" private String destino; private LocalTime horaSalida; private LocalDateTime fechaLlegada; private LocalDateTime fechaCreacion; private Bus busAsignado; private double valorUnitario; private int capacidad; // Total de tiquetes disponibles private int tiquetesVendidos; private Cola<Cliente> colaEspera; // Constructor public Viaje(String destino, LocalTime horaSalida, LocalDateTime fechaLlegada, Bus busAsignado, double valorUnitario) { this.origen = "Ciudad Terminal"; this.destino = destino; this.horaSalida = horaSalida; this.fechaLlegada = fechaLlegada; this.fechaCreacion = LocalDateTime.now(); this.busAsignado = busAsignado; this.valorUnitario = valorUnitario; this.capacidad = busAsignado.getPuestosDisponibles(); this.tiquetesVendidos = 0; this.colaEspera = new Cola<>(); } // Getters y Setters public String getOrigen() { return origen; } public String getDestino() { return destino; } public void setDestino(String destino) { this.destino = destino; } public LocalTime getHoraSalida() { return horaSalida; } public void setHoraSalida(LocalTime horaSalida) { this.horaSalida = horaSalida; } public LocalDateTime getFechaLlegada() { return fechaLlegada; } public void setFechaLlegada(LocalDateTime fechaLlegada) { this.fechaLlegada = fechaLlegada; } public LocalDateTime getFechaCreacion() { return fechaCreacion; } public Bus getBusAsignado() { return busAsignado; } public void setBusAsignado(Bus busAsignado) { this.busAsignado = busAsignado; } public double getValorUnitario() { return valorUnitario; } public void setValorUnitario(double valorUnitario) { this.valorUnitario = valorUnitario; } public int getCapacidad() { return capacidad; } public int getTiquetesVendidos() { return tiquetesVendidos; } public void setTiquetesVendidos(int tiquetesVendidos) { this.tiquetesVendidos = tiquetesVendidos; } public Cola<Cliente> getColaEspera() { return colaEspera; } // Métodos específicos /** * Vende tiquetes si hay disponibilidad. * * @param cantidad Cantidad de tiquetes a vender * @return true si la venta fue exitosa, false si se debe agregar a la cola de espera */ public boolean venderTiquete(int cantidad) { if (tiquetesVendidos + cantidad <= capacidad) { tiquetesVendidos += cantidad; return true; } return false; } /** * Agrega un cliente a la cola de espera. * * @param cliente Cliente a agregar */ public void agregarACola(Cliente cliente) { this.colaEspera.encolar(cliente); } /** * Procesa la cola de espera y asigna tiquetes si hay disponibilidad. */ public void procesarCola() { while (!colaEspera.estaVacia() && tiquetesVendidos < capacidad) { Cliente cliente = colaEspera.desencolar(); // Supongamos que cada cliente de la cola quiere comprar una reserva pendiente // Puedes adaptar esta lógica según tus necesidades int cantidad = 1; // Puedes integrar una lógica para determinar la cantidad solicitada if (venderTiquete(cantidad)) { // Crear y asignar el tiquete al cliente Tiquete tiquete = new Tiquete(this, cliente, cantidad); cliente.acumularPuntos(tiquete.getMontoInvertido()); cliente.agregarReserva(new Reserva(this, cliente, cantidad, true)); cliente.agregarNotificacion(new Notificacion("Tu reserva para el viaje a " + destino + " ha sido confirmada.")); // También deberías agregar el tiquete a la empresa correspondiente busAsignado.getEmpresa().agregarTiquete(tiquete); } else { // Si aún no hay disponibilidad, re-agregar al cliente a la cola agregarACola(cliente); break; } } } /** * Verifica si el bus está disponible para este viaje. * * @return true si el bus está disponible, false de lo contrario */ public boolean isBusDisponible() { // Un bus está disponible si no tiene viajes programados que se solapen con este viaje for (Viaje viajeProgramado : busAsignado.getViajesProgramados()) { if (viajeProgramado.equals(this)) { continue; // Ignorar el viaje actual } // Verificar si las fechas se solapan if (this.fechaSalida().isBefore(viajeProgramado.fechaLeyenda()) && viajeProgramado.fechaSalida().isBefore(this.fechaLlegada.plusDays(1))) { return false; } } return true; } /** * Retorna la fecha y hora de salida completa. */ public LocalDateTime fechaSalida() { return fechaLlegada.minusHours(busAsignado.getTiempoEstimadoViaje()); // Asumiendo que el bus tiene un tiempo estimado de viaje } /** * Retorna la fecha y hora de llegada completa. */ public LocalDateTime fechaLeyenda() { return fechaLlegada; } }Explicaciones y Mejoras
-
Origen Fijo: El origen del viaje está fijo en
"Ciudad Terminal", según el requerimiento. -
Método
isBusDisponible: Este método verifica si el bus asignado está disponible para un nuevo viaje, asegurando que no tenga viajes programados que se solapen con el nuevo viaje. Esto cumple con el requisito de que un vehículo no pueda estar en más de un viaje al mismo tiempo y que vuelva a estar disponible un día después de la llegada. -
Métodos de Fechas:
fechaSalida: Calcula la fecha y hora de salida completa del viaje. Asumo que tienes un métodogetTiempoEstimadoViajeen la claseBusque retorna la duración estimada del viaje en horas. Puedes ajustar esta lógica según tus necesidades.fechaLeyenda: Retorna la fecha y hora de llegada.
-
Método
procesarCola: Este método gestiona la cola de espera, intentando asignar tiquetes a los clientes en espera cuando hay disponibilidad. Actualiza los puntos del cliente y añade reservas efectivas. -
Relacionamiento con Empresa: He asumido que la clase
Bustiene un métodogetEmpresa()para obtener la empresa de transporte asociada, lo cual es necesario para agregar tiquetes vendidos a la lista correspondiente.
2. Controlador
ControladorViajeAhora, vamos a crear un controlador dedicado para gestionar los viajes, que interactúe con el modelo
Viajey realice las operaciones necesarias como crear viajes, vender tiquetes, procesar la cola de espera, etc.Archivo:
ProyectoFinal/controller/ControladorViaje.java// src/controller/ControladorViaje.java package controller; import model.Bus; import model.Cliente; import model.EmpresaTransporte; import model.Notificacion; import model.Reserva; import model.Tiquete; import model.Viaje; import util.ListaEnlazada; import java.time.LocalDateTime; import java.time.LocalTime; /** * Controlador que gestiona las operaciones relacionadas con los viajes. */ public class ControladorViaje { private ListaEnlazada<Viaje> viajes; private ListaEnlazada<EmpresaTransporte> empresasTransporte; // Constructor public ControladorViaje(ListaEnlazada<EmpresaTransporte> empresasTransporte) { this.viajes = new ListaEnlazada<>(); this.empresasTransporte = empresasTransporte; } // Getters y Setters public ListaEnlazada<Viaje> getViajes() { return viajes; } public void setViajes(ListaEnlazada<Viaje> viajes) { this.viajes = viajes; } /** * Crea y agrega un nuevo viaje. * * @param destino Destino del viaje * @param horaSalida Hora de salida * @param fechaLlegada Fecha y hora de llegada * @param busAsignado Bus asignado al viaje * @param valorUnitario Valor unitario por tiquete * @return true si el viaje fue creado exitosamente, false de lo contrario */ public boolean crearViaje(String destino, LocalTime horaSalida, LocalDateTime fechaLlegada, Bus busAsignado, double valorUnitario) { // Verificar disponibilidad del bus Viaje nuevoViaje = new Viaje(destino, horaSalida, fechaLlegada, busAsignado, valorUnitario); if (nuevoViaje.isBusDisponible()) { viajes.agregar(nuevoViaje); busAsignado.agregarViaje(nuevoViaje); return true; } return false; } /** * Vende tiquetes para un viaje específico. * * @param viaje Viaje al que se le venderán tiquetes * @param cliente Cliente que compra los tiquetes * @param cantidad Cantidad de tiquetes a vender * @return true si la venta fue exitosa, false si se añadió a la cola de espera */ public boolean venderTiquete(Viaje viaje, Cliente cliente, int cantidad) { boolean ventaExitosa = viaje.venderTiquete(cantidad); if (ventaExitosa) { Tiquete tiquete = new Tiquete(viaje, cliente, cantidad); cliente.acumularPuntos(tiquete.getMontoInvertido()); cliente.agregarReserva(new Reserva(viaje, cliente, cantidad, true)); viaje.getBusAsignado().getEmpresa().agregarTiquete(tiquete); return true; } else { viaje.agregarACola(cliente); cliente.agregarReserva(new Reserva(viaje, cliente, cantidad, false)); cliente.agregarNotificacion(new Notificacion("Reserva en espera para el viaje a " + viaje.getDestino() + ".")); return false; } } /** * Procesa la cola de espera de un viaje, asignando tiquetes a los clientes en espera. * * @param viaje Viaje cuyo espera será procesado */ public void procesarColaEsperas(Viaje viaje) { viaje.procesarCola(); } /** * Devuelve un tiquete y actualiza los puntos del cliente. * * @param tiquete Tiquete a devolver * @return true si la devolución fue exitosa, false de lo contrario */ public boolean devolverTiquete(Tiquete tiquete) { Cliente cliente = tiquete.getCliente(); Viaje viaje = tiquete.getViaje(); // Actualizar tiquetes vendidos viaje.setTiquetesVendidos(viaje.getTiquetesVendidos() - tiquete.getCantidad()); // Agregar a la cola de espera si hay clientes esperando procesarColaEsperas(viaje); // Actualizar puntos del cliente double montoInvertido = tiquete.getMontoInvertido(); int puntosAEliminar = (int) ((montoInvertido / 10000) * 3); cliente.reducirPuntos(puntosAEliminar); // Añadir historial de devoluciones cliente.agregarDevolucion(new Devolucion(tiquete, montoInvertido)); // Remover reserva y tiquete cliente.cancelarReservaPorViaje(viaje); viaje.getBusAsignado().getEmpresa().eliminarTiquete(tiquete); return true; } /** * Busca un viaje por destino y fecha de salida. * * @param destino Destino del viaje * @param fechaSalida Fecha y hora de salida * @return Viaje encontrado o null si no existe */ public Viaje buscarViaje(String destino, LocalDateTime fechaSalida) { return viajes.buscar(v -> v.getDestino().equalsIgnoreCase(destino) && v.fechaSalida().equals(fechaSalida)); } }Explicaciones y Mejoras
-
Constructor del Controlador: El controlador
ControladorViajerecibe una lista de todas las empresas de transporte para gestionar los tiquetes y asegurar que se agreguen correctamente a la empresa correspondiente. -
Método
crearViaje: Verifica la disponibilidad del bus antes de crear y agregar un nuevo viaje. Si el bus está disponible, agrega el viaje tanto a la lista de viajes del controlador como a la lista de viajes programados del bus. -
Método
venderTiquete: Intenta vender tiquetes para un viaje específico. Si hay disponibilidad, vende los tiquetes y actualiza los puntos y reservas del cliente. Si no hay disponibilidad, agrega al cliente a la cola de espera y crea una reserva no efectiva. -
Método
procesarColaEsperas: Llama al métodoprocesarColadel modeloViajepara asignar automáticamente tiquetes a los clientes en espera cuando se desocupan puestos. -
Método
devolverTiquete: Gestiona la devolución de un tiquete, actualizando los tiquetes vendidos, puntos del cliente, historial de devoluciones y procesando la cola de espera para asignar tiquetes liberados. -
Método
buscarViaje: Permite buscar un viaje específico por destino y fecha de salida, lo que es útil para operaciones de venta y reserva. -
Integridad de Datos: Asegura que todas las operaciones mantengan la integridad de los datos, como evitar la venta de tiquetes excediendo la capacidad y manejando correctamente las devoluciones y la cola de espera.
3. Integración con Otras Clases
Para que todo funcione correctamente, debemos asegurarnos de que las clases
Bus,EmpresaTransporte,Cliente,Tiquete,ReservayDevoluciontengan los métodos necesarios que se están utilizando en el modelo y el controlador deViaje. A continuación, revisaré y ajustaré algunas de estas clases para garantizar una correcta integración.Archivo:
ProyectoFinal/model/Bus.javaAsegurémonos de que la clase
Bustenga métodos para gestionar los viajes programados y obtener la empresa de transporte asociada.// src/model/Bus.java package model; import util.ListaEnlazada; /** * Clase que representa un bus. */ public class Bus { private String placa; private int puestosDisponibles; private ListaEnlazada<Viaje> viajesProgramados; private EmpresaTransporte empresa; // Empresa a la que pertenece el bus // Constructor public Bus(String placa, int puestosDisponibles, EmpresaTransporte empresa) { this.placa = placa; this.puestosDisponibles = puestosDisponibles; this.viajesProgramados = new ListaEnlazada<>(); this.empresa = empresa; } // Getters y Setters public String getPlaca() { return placa; } public void setPlaca(String placa) { this.placa = placa; } public int getPuestosDisponibles() { return puestosDisponibles; } public void setPuestosDisponibles(int puestosDisponibles) { this.puestosDisponibles = puestosDisponibles; } public ListaEnlazada<Viaje> getViajesProgramados() { return viajesProgramados; } public void agregarViaje(Viaje viaje) { this.viajesProgramados.agregar(viaje); } public EmpresaTransporte getEmpresa() { return empresa; } public void setEmpresa(EmpresaTransporte empresa) { this.empresa = empresa; } // Métodos específicos /** * Calcula el tiempo estimado de viaje en horas. * Esto puede ser fijo o calculado según la distancia. Aquí lo dejamos fijo. * * @return Tiempo estimado de viaje en horas */ public int getTiempoEstimadoViaje() { // Puedes implementar lógica para calcular el tiempo basado en el destino return 5; // Ejemplo: 5 horas estimadas } }Archivo:
ProyectoFinal/model/Cliente.javaAñadamos métodos para manejar las reservas específicamente por viaje, lo que es necesario para las devoluciones.
// src/model/Cliente.java package model; import util.ListaEnlazada; /** * Clase que representa a un cliente. */ public class Cliente extends Usuario { private int puntos; private ListaEnlazada<Reserva> reservas; private ListaEnlazada<Notificacion> notificaciones; private ListaEnlazada<Devolucion> historialDevoluciones; // Constructor public Cliente(String usuario, String contraseña, String nombre, String apellido) { super(usuario, contraseña, nombre, apellido); this.puntos = 0; this.reservas = new ListaEnlazada<>(); this.notificaciones = new ListaEnlazada<>(); this.historialDevoluciones = new ListaEnlazada<>(); } // Getters y Setters public int getPuntos() { return puntos; } public void setPuntos(int puntos) { this.puntos = puntos; } public ListaEnlazada<Reserva> getReservas() { return reservas; } public ListaEnlazada<Notificacion> getNotificaciones() { return notificaciones; } public ListaEnlazada<Devolucion> getHistorialDevoluciones() { return historialDevoluciones; } // Métodos específicos /** * Acumula puntos basados en el valor invertido. * * @param valorInvertido Valor invertido en la compra de tiquetes */ public void acumularPuntos(double valorInvertido) { this.puntos += (int) ((valorInvertido / 10000) * 3); } /** * Canjea puntos por un tiquete. * * @param puntosACanjear Puntos a canjear * @return true si el canje fue exitoso, false de lo contrario */ public boolean canjearPuntos(int puntosACanjear) { if (this.puntos >= puntosACanjear) { this.puntos -= puntosACanjear; // Implementar lógica para canjear puntos por tiquete si es aplicable return true; } return false; } /** * Añade una reserva a la lista de reservas. * * @param reserva Reserva a añadir */ public void agregarReserva(Reserva reserva) { this.reservas.agregar(reserva); } /** * Cancela una reserva específica por el viaje. * * @param viaje Viaje asociado a la reserva * @return true si la reserva fue encontrada y eliminada, false de lo contrario */ public boolean cancelarReservaPorViaje(Viaje viaje) { return this.reservas.eliminar(r -> r.getViaje().equals(viaje)); } /** * Añade una notificación a la lista de notificaciones. * * @param notificacion Notificación a añadir */ public void agregarNotificacion(Notificacion notificacion) { this.notificaciones.agregar(notificacion); } /** * Añade una devolución al historial de devoluciones. * * @param devolucion Devolución a añadir */ public void agregarDevolucion(Devolucion devolucion) { this.historialDevoluciones.agregar(devolucion); } /** * Reduce los puntos del cliente (usado en devoluciones). * * @param puntosAReducir Puntos a reducir */ public void reducirPuntos(double puntosAReducir) { this.puntos -= puntosAReducir; if (this.puntos < 0) { this.puntos = 0; } } /** * Retorna el historial de reservas efectivas. */ public ListaEnlazada<Reserva> listarReservasEfectivas() { ListaEnlazada<Reserva> efectivas = new ListaEnlazada<>(); for (Reserva reserva : reservas) { if (reserva.isEfectiva()) { efectivas.agregar(reserva); } } return efectivas; } /** * Retorna el historial de reservas activas (no efectivas). */ public ListaEnlazada<Reserva> listarReservasActivas() { ListaEnlazada<Reserva> activas = new ListaEnlazada<>(); for (Reserva reserva : reservas) { if (!reserva.isEfectiva()) { activas.agregar(reserva); } } return activas; } }Archivo:
ProyectoFinal/model/Reserva.javaAsegurémonos de que la clase
Reservapueda manejar si es efectiva o no.// src/model/Reserva.java package model; import java.time.LocalDate; /** * Clase que representa una reserva de tiquetes. */ public class Reserva { private Viaje viaje; private Cliente cliente; private int cantidad; private LocalDate fechaReserva; private boolean efectiva; // Constructor public Reserva(Viaje viaje, Cliente cliente, int cantidad, boolean efectiva) { this.viaje = viaje; this.cliente = cliente; this.cantidad = cantidad; this.fechaReserva = LocalDate.now(); this.efectiva = efectiva; } // Getters y Setters public Viaje getViaje() { return viaje; } public void setViaje(Viaje viaje) { this.viaje = viaje; } public Cliente getCliente() { return cliente; } public void setCliente(Cliente cliente) { this.cliente = cliente; } public int getCantidad() { return cantidad; } public void setCantidad(int cantidad) { this.cantidad = cantidad; } public LocalDate getFechaReserva() { return fechaReserva; } public boolean isEfectiva() { return efectiva; } public void setEfectiva(boolean efectiva) { this.efectiva = efectiva; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (!(obj instanceof Reserva)) return false; Reserva other = (Reserva) obj; return this.viaje.equals(other.viaje) && this.cliente.equals(other.cliente) && this.cantidad == other.cantidad && this.efectiva == other.efectiva; } }Archivo:
ProyectoFinal/model/Tiquete.javaAsegurémonos de que la clase
Tiquetetenga métodos apropiados y que se relacione correctamente conEmpresaTransporte.// src/model/Tiquete.java package model; import java.time.LocalDate; /** * Clase que representa un tiquete de viaje. */ public class Tiquete { private Viaje viaje; private Cliente cliente; private int cantidad; private LocalDate fechaCompra; // Constructor public Tiquete(Viaje viaje, Cliente cliente, int cantidad) { this.viaje = viaje; this.cliente = cliente; this.cantidad = cantidad; this.fechaCompra = LocalDate.now(); } // Getters y Setters public Viaje getViaje() { return viaje; } public void setViaje(Viaje viaje) { this.viaje = viaje; } public Cliente getCliente() { return cliente; } public void setCliente(Cliente cliente) { this.cliente = cliente; } public int getCantidad() { return cantidad; } public void setCantidad(int cantidad) { this.cantidad = cantidad; } public LocalDate getFechaCompra() { return fechaCompra; } /** * Retorna el monto invertido en el tiquete. * * @return Monto invertido */ public double getMontoInvertido() { return cantidad * viaje.getValorUnitario(); } @Override public boolean equals(Object obj) { if (this == obj) return true; if (!(obj instanceof Tiquete)) return false; Tiquete other = (Tiquete) obj; return this.viaje.equals(other.viaje) && this.cliente.equals(other.cliente) && this.cantidad == other.cantidad && this.fechaCompra.equals(other.fechaCompra); } }Archivo:
ProyectoFinal/model/EmpresaTransporte.javaAsegurémonos de que la clase
EmpresaTransportepueda manejar los tiquetes vendidos.// src/model/EmpresaTransporte.java package model; import util.ListaEnlazada; /** * Clase que representa a una empresa de transporte. */ public class EmpresaTransporte { private String nit; private String nombreEmpresa; private double canonArrendamiento; private int plazasEstacionamiento; private ListaEnlazada<Bus> buses; private ListaEnlazada<Viaje> viajes; private ListaEnlazada<Tiquete> tiquetesVendidos; // Constructor public EmpresaTransporte(String nit, String nombreEmpresa, double canonArrendamiento, int plazasEstacionamiento) { this.nit = nit; this.nombreEmpresa = nombreEmpresa; this.canonArrendamiento = canonArrendamiento; this.plazasEstacionamiento = plazasEstacionamiento; this.buses = new ListaEnlazada<>(); this.viajes = new ListaEnlazada<>(); this.tiquetesVendidos = new ListaEnlazada<>(); } // Getters y Setters public String getNit() { return nit; } public String getNombreEmpresa() { return nombreEmpresa; } public double getCanonArrendamiento() { return canonArrendamiento; } public int getPlazasEstacionamiento() { return plazasEstacionamiento; } public ListaEnlazada<Bus> getBuses() { return buses; } public ListaEnlazada<Viaje> getViajes() { return viajes; } public ListaEnlazada<Tiquete> getTiquetesVendidos() { return tiquetesVendidos; } // Métodos específicos /** * Agrega un bus a la empresa. * * @param bus Bus a agregar */ public void agregarBus(Bus bus) { this.buses.agregar(bus); } /** * Agrega un viaje a la empresa. * * @param viaje Viaje a agregar */ public void agregarViaje(Viaje viaje) { this.viajes.agregar(viaje); } /** * Agrega un tiquete a la lista de tiquetes vendidos. * * @param tiquete Tiquete a agregar */ public void agregarTiquete(Tiquete tiquete) { this.tiquetesVendidos.agregar(tiquete); } /** * Elimina un tiquete de la lista de tiquetes vendidos. * * @param tiquete Tiquete a eliminar * @return true si se eliminó correctamente, false de lo contrario */ public boolean eliminarTiquete(Tiquete tiquete) { return this.tiquetesVendidos.eliminar(t -> t.equals(tiquete)); } /** * Busca un bus por su placa. * * @param placa Placa del bus * @return Bus encontrado o null si no existe */ public Bus buscarBusPorPlaca(String placa) { return buses.buscar(b -> b.getPlaca().equalsIgnoreCase(placa)); } /** * Busca un viaje por destino y fecha de salida. * * @param destino Destino del viaje * @param fechaSalida Fecha y hora de salida * @return Viaje encontrado o null si no existe */ public Viaje buscarViaje(String destino, LocalDateTime fechaSalida) { return viajes.buscar(v -> v.getDestino().equalsIgnoreCase(destino) && v.fechaSalida().equals(fechaSalida)); } }Archivo:
ProyectoFinal/controller/ControladorAdministradorFlota.javaAsegurémonos de que el controlador del Administrador de Flota utilice correctamente el
ControladorViaje.// src/controller/ControladorAdministradorFlota.java package controller; import java.time.LocalDateTime; import java.time.LocalTime; import model.AdministradorFlota; import model.Bus; import model.Cliente; import model.EmpresaTransporte; import model.Viaje; import model.Tiquete; import util.ListaEnlazada; /** * Controlador que gestiona las operaciones del Administrador de Flota. */ public class ControladorAdministradorFlota { private AdministradorFlota adminFlota; private ControladorViaje controladorViaje; private ListaEnlazada<EmpresaTransporte> todasLasEmpresas; // Constructor public ControladorAdministradorFlota(AdministradorFlota adminFlota, ListaEnlazada<EmpresaTransporte> todasLasEmpresas) { this.adminFlota = adminFlota; this.todasLasEmpresas = todasLasEmpresas; this.controladorViaje = new ControladorViaje(todasLasEmpresas); } /** * Registra un nuevo bus en la empresa asignada. * * @param placa Placa del bus * @param puestos Número de puestos disponibles * @return true si el bus fue registrado exitosamente, false si la placa ya existe */ public boolean registrarBus(String placa, int puestos) { // Verifica si la placa ya existe en todas las empresas for (EmpresaTransporte emp : todasLasEmpresas) { Bus busExistente = emp.buscarBusPorPlaca(placa); if (busExistente != null) { return false; // Placa ya existente } } // Obtener la empresa del administrador de flota EmpresaTransporte empresa = adminFlota.getEmpresa(); Bus nuevoBus = new Bus(placa, puestos, empresa); empresa.agregarBus(nuevoBus); return true; } /** * Crea un nuevo viaje para un bus específico. * * @param destino Destino del viaje * @param horaSalida Hora de salida * @param fechaLlegada Fecha y hora de llegada * @param placaBus Placa del bus asignado * @param valorUnitario Valor unitario por tiquete * @return true si el viaje fue creado exitosamente, false de lo contrario */ public boolean crearViaje(String destino, LocalTime horaSalida, LocalDateTime fechaLlegada, String placaBus, double valorUnitario) { // Buscar el bus por placa Bus bus = adminFlota.getEmpresa().buscarBusPorPlaca(placaBus); if (bus == null) { return false; // Bus no encontrado } // Crear el viaje utilizando el controlador de viajes boolean viajeCreado = controladorViaje.crearViaje(destino, horaSalida, fechaLlegada, bus, valorUnitario); return viajeCreado; } /** * Vende tiquetes para un viaje específico a un cliente. * * @param destino Destino del viaje * @param fechaSalida Fecha y hora de salida del viaje * @param cliente Cliente que compra los tiquetes * @param cantidad Cantidad de tiquetes a comprar * @return true si la venta fue exitosa, false si se añadió a la cola de espera */ public boolean venderTiquete(String destino, LocalDateTime fechaSalida, Cliente cliente, int cantidad) { Viaje viaje = controladorViaje.buscarViaje(destino, fechaSalida); if (viaje == null) { return false; // Viaje no encontrado } return controladorViaje.venderTiquete(viaje, cliente, cantidad); } /** * Procesa la cola de espera de un viaje específico. * * @param destino Destino del viaje * @param fechaSalida Fecha y hora de salida del viaje */ public void procesarColaEsperas(String destino, LocalDateTime fechaSalida) { Viaje viaje = controladorViaje.buscarViaje(destino, fechaSalida); if (viaje != null) { controladorViaje.procesarColaEsperas(viaje); } } /** * Devuelve un tiquete y actualiza los puntos del cliente. * * @param tiquete Tiquete a devolver * @return true si la devolución fue exitosa, false de lo contrario */ public boolean devolverTiquete(Tiquete tiquete) { return controladorViaje.devolverTiquete(tiquete); } /** * Obtiene la lista de todos los viajes. * * @return Lista de viajes */ public ListaEnlazada<Viaje> obtenerListaViajes() { return controladorViaje.getViajes(); } }Explicaciones y Mejoras
-
Integración del Controlador de Viajes: El
ControladorAdministradorFlotaahora utiliza elControladorViajepara gestionar todas las operaciones relacionadas con los viajes. Esto separa las responsabilidades y facilita el mantenimiento. -
Método
registrarBus: Registra un nuevo bus verificando que la placa no esté duplicada en ninguna de las empresas de transporte existentes. -
Método
crearViaje: Crea un nuevo viaje asignándolo a un bus específico. Utiliza el controlador de viajes para realizar esta operación, asegurando que las validaciones necesarias se realicen correctamente. -
Método
venderTiquete: Vende tiquetes para un viaje específico en base al destino y la fecha de salida. Esto facilita la identificación del viaje al que se le vendrán tiquetes. -
Método
procesarColaEsperas: Procesa la cola de espera para un viaje específico, permitiendo que los clientes en espera sean notificados y se les asignen tiquetes disponibles automáticamente. -
Método
devolverTiquete: Gestiona la devolución de tiquetes y actualiza los puntos y el historial de devoluciones del cliente. -
Método
obtenerListaViajes: Permite obtener la lista completa de viajes programados, lo cual es útil para mostrar información en la interfaz de usuario o para realizar operaciones adicionales.
4. Uso en el
Main.javaFinalmente, vamos a actualizar el
Main.javapara demostrar cómo utilizar el nuevo controlador de viajes y verificar que todo funcione correctamente.Archivo:
ProyectoFinal/Main.javaimport controller.ControladorLogin; import controller.ControladorAdministradorTerminal; import controller.ControladorCliente; import controller.ControladorAdministradorFlota; import controller.ControladorViaje; import model.AdministradorTerminal; import model.EmpresaTransporte; import model.AdministradorFlota; import model.Bus; import model.Cliente; import model.Viaje; import util.ListaEnlazada; public class Main { public static void main(String[] args) { // Inicializar el controlador de login ControladorLogin controladorLogin = new ControladorLogin(); // Crear y registrar una empresa de transporte EmpresaTransporte empresa1 = new EmpresaTransporte("123456789-0", "Transporte Express", 500000.0, 10); controladorLogin.agregarEmpresaTransporte(empresa1); // Registrar un Administrador de Flota para la empresa controladorLogin.registrarAdministradorFlota("adminFlota1", "passFlota1", "Carlos", "Pérez", empresa1); // Obtener el Administrador Terminal registrado AdministradorTerminal adminTerminal = (AdministradorTerminal) controladorLogin.getUsuarios().buscar(u -> u instanceof AdministradorTerminal); // Crear un controlador para el Administrador Terminal ControladorAdministradorTerminal controladorAdminTerminal = new ControladorAdministradorTerminal(adminTerminal); // Asignar la empresa a una caseta específica boolean asignado = controladorAdminTerminal.asignarEmpresaACaseta(0, 0, empresa1); if (asignado) { System.out.println("Empresa asignada a la caseta correctamente."); } else { System.out.println("Error al asignar la empresa a la caseta."); } // Crear un controlador para el Administrador de Flota AdministradorFlota adminFlota = (AdministradorFlota) controladorLogin.getUsuarios().buscar(u -> u instanceof AdministradorFlota); ControladorAdministradorFlota controladorAdminFlota = new ControladorAdministradorFlota(adminFlota, controladorLogin.getEmpresasTransporte()); // Registrar un nuevo bus boolean busRegistrado = controladorAdminFlota.registrarBus("ABC123", 50); if (busRegistrado) { System.out.println("Bus registrado exitosamente."); } else { System.out.println("Error al registrar el bus (placa duplicada)."); } // Crear un nuevo viaje boolean viajeCreado = controladorAdminFlota.crearViaje( "Ciudad B", java.time.LocalTime.of(8, 0), java.time.LocalDateTime.of(2023, 12, 25, 12, 0), "ABC123", 50000.0 ); if (viajeCreado) { System.out.println("Viaje creado exitosamente."); } else { System.out.println("Error al crear el viaje (bus no disponible)."); } // Registrar un cliente boolean clienteRegistrado = controladorLogin.registrarCliente("cliente1", "passCliente1", "Ana", "García"); if (clienteRegistrado) { System.out.println("Cliente registrado exitosamente."); } else { System.out.println("Error al registrar el cliente (usuario duplicado)."); } // Autenticar al cliente model.Usuario usuarioAutenticado = controladorLogin.autenticar("cliente1", "passCliente1"); if (usuarioAutenticado != null && usuarioAutenticado instanceof Cliente) { Cliente cliente = (Cliente) usuarioAutenticado; ControladorCliente controladorCliente = new ControladorCliente(cliente); // Obtener el controlador de viajes ControladorViaje controladorViaje = controladorAdminFlota.getControladorViaje(); // Realizar una reserva Viaje viaje = controladorViaje.buscarViaje("Ciudad B", java.time.LocalDateTime.of(2023, 12, 25, 8, 0)); if (viaje != null) { boolean reservaExitosa = controladorViaje.venderTiquete("Ciudad B", java.time.LocalDateTime.of(2023, 12, 25, 8, 0), cliente, 2); if (reservaExitosa) { System.out.println("Reserva realizada exitosamente."); } else { System.out.println("Reserva agregada a la cola de espera."); } } else { System.out.println("Viaje no encontrado para la reserva."); } // Mostrar puntos acumulados System.out.println("Puntos acumulados: " + cliente.getPuntos()); // Procesar la cola de espera (simulando que se desocupa un tiquete) controladorViaje.procesarColaEsperas("Ciudad B", java.time.LocalDateTime.of(2023, 12, 25, 8, 0)); // Mostrar notificaciones del cliente for (model.Notificacion notificacion : cliente.getNotificaciones()) { System.out.println("Notificación: " + notificacion.getMensaje()); } } else { System.out.println("Error en la autenticación del cliente."); } } }Explicaciones y Mejoras
-
Integración del Controlador de Viajes: Ahora, el
ControladorAdministradorFlotaexpone elControladorViajepara que pueda ser utilizado en elMain.java. -
Registro y Creación de Viajes: Después de registrar un bus, se crea un viaje asignándole ese bus. La creación verifica la disponibilidad del bus antes de agregar el viaje.
-
Venta de Tiquetes y Reserva: Se realiza una venta de tiquetes para un cliente. Si la venta excede la capacidad del viaje, el cliente se agrega a la cola de espera.
-
Procesamiento de la Cola de Espera: Simula que se desocupan tiquetes y se procesan las reservas en espera, notificando al cliente si su reserva fue confirmada.
-
Puntos y Notificaciones: Muestra los puntos acumulados del cliente y las notificaciones recibidas después de procesar la cola de espera.
5. Consideraciones Finales
-
Validaciones Adicionales: Dependiendo de los requerimientos específicos de tu proyecto, podrías necesitar agregar validaciones adicionales, como verificar que las fechas de salida y llegada sean lógicas o que los campos no estén vacíos.
-
Persistencia de Datos: Actualmente, todas las estructuras de datos están en memoria. Para una aplicación real, considerarías implementar persistencia utilizando bases de datos.
-
Interfaz de Usuario: Aunque el enfoque actual es en la lógica de negocio, eventualmente querrás desarrollar una interfaz (gráfica o web) para interactuar con los controladores.
-
Manejo de Errores: Implementar un manejo de excepciones adecuado para situaciones inesperadas y asegurar que la aplicación sea robusta.
-
Pruebas Unitarias: Desarrollar pruebas unitarias para asegurar que cada componente funcione como se espera.
Espero que esta implementación te ayude a avanzar en tu proyecto. Si tienes alguna pregunta adicional o necesitas más ayuda con otra parte del sistema, no dudes en consultarme. ¡Éxito con tu proyecto!
-
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.