Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

tengo esto: Folder Structure: ProyectoFinal/ ├─ model/ │ model/ │ ├─ Bus.java │ ├─…

  1. User

    tengo 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 │ └─ ControladorViaje.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

    package model;

    import util.ListaEnlazada;

    /**

    • Clase que representa un bus. */ public class Bus { private String placa; private int puestosDisponibles; private ListaEnlazada viajesProgramados; private EmpresaTransporte empresa; // Añadido: referencia a la empresa

      // 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 getViajesProgramados() { return viajesProgramados; }

      public void setViajesProgramados(ListaEnlazada viajesProgramados) { this.viajesProgramados = viajesProgramados; }

      public EmpresaTransporte getEmpresa() { return empresa; }

      public void setEmpresa(EmpresaTransporte empresa) { this.empresa = empresa; }

      // Métodos específicos

      /**

      • Agrega un viaje programado al bus. */ public void agregarViaje(Viaje viaje) { this.viajesProgramados.agregar(viaje); }

      /**

      • 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 } }

    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; // 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 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 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.fechaLlegada) && viajeProgramado.fechaSalida().isBefore(this.fechaLlegada.plusDays(1))) { return false; } } return true; }

      /**

      • Retorna la fecha y hora de salida completa. */ public LocalDateTime fechaSalida() { // Asumiendo que la hora de salida del viaje está ya establecida return this.fechaCreacion.withHour(horaSalida.getHour()).withMinute(horaSalida.getMinute()); }

      /**

      • Retorna la fecha y hora de llegada completa. */ public LocalDateTime fechaLeyenda() { return fechaLlegada; } }

    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 java.time.LocalDateTime;

    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 String getNombreEmpresa() { return nombreEmpresa; }

      public double getCanonArrendamiento() { return canonArrendamiento; }

      public int getPlazasEstacionamiento() { return plazasEstacionamiento; }

      public ListaEnlazada getBuses() { return buses; }

      public ListaEnlazada getViajes() { return viajes; }

      public ListaEnlazada 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)); } }

    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; }

      /**

      • 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 ListaEnlazada getNotificaciones() { return notificaciones; }

      public ListaEnlazada getHistorialDevoluciones() { return 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; // Implementar lógica para canjear puntos por tiquete si es aplicable return true; } return false; }

      /**

      • Añade una reserva a la lista de reservas. */ public void agregarReserva(Reserva reserva) { this.reservas.agregar(reserva); }

      /**

      • Cancela una reserva específica por el viaje. */ public boolean cancelarReservaPorViaje(Viaje viaje) { return this.reservas.eliminar(r -> r.getViaje().equals(viaje)); }

      /**

      • 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 efectivas. */ public ListaEnlazada listarReservasEfectivas() { ListaEnlazada 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 listarReservasActivas() { ListaEnlazada activas = new ListaEnlazada<>(); for (Reserva reserva : reservas) { if (!reserva.isEfectiva()) { activas.agregar(reserva); } } return activas; } }

    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, 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; } }

    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

    // 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 todasLasEmpresas;

      // Constructor public ControladorAdministradorFlota(AdministradorFlota adminFlota, ListaEnlazada 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 obtenerListaViajes() { return controladorViaje.getViajes(); }

      /**

      • Obtiene el controlador de viajes.
      • @return ControladorViaje */ public ControladorViaje getControladorViaje() { return controladorViaje; } }

    File: 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 model.Devolucion; // Asegúrate de que esta línea exista 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 viajes;

      // Constructor public ControladorViaje(ListaEnlazada empresasTransporte) { this.viajes = new ListaEnlazada<>(); }

      public ListaEnlazada getViajes() { return viajes; }

      public void setViajes(ListaEnlazada 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)); } }

    File: ProyectoFinal/Main.java

    import 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(viaje, 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.");
        }
    }
    

    }

    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; } }

    en mi proyecto tengo que hacer esto:

    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.

    1. 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

    1. 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.
    2. 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.
    3. 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 10000quehayainvertidoenviajesenlaterminal.ii.Elclientepodraˊcambiar90puntospreviamenteacumuladorporuntiquetedemaˊximo10000 que haya invertido en viajes en la terminal. ii. El cliente podrá cambiar 90 puntos previamente acumulador por un tiquete de máximo 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.
    4. Hará efectivas las reservas de los clientes (Hacer efectiva una reserva equivale a convertirla en un tiquete vendido)
    5. 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

    1. Podrá registrarse desde la ventana de login
    2. 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.

    Entrega Uno:

    PERO SOLO ME ANDO ENFOCANDO EN TODO LO QUE TENGA QUE VER CON VIAJES DE ACUERDO AL ENUNCIADO

    como tal tengo que decirte que en mis modelos usan serializacion y como guardado de datos uso singleton entonces para que te hagas una idea y me ayudes a cuadrar las cosas, ademas

    lo que sucede es que como tal tengo unos errores, estos:

    administradorflota:

    The constructor Bus(String, int) is undefinedJava(134217858) The constructor Viaje(String, String, LocalTime, LocalDateTime, Bus, double) is undefinedJava(134217858)

    controladorcliente:

    The method cancelarReserva(Reserva) is undefined for the type ClienteJava(67108964)

    mi main:

    The method procesarColaEsperas(Viaje) in the type ControladorViaje is not applicable for the arguments (String, LocalDateTime)Java(67108979)

    como quedaria entonces con lo que te acabo de mostrar y decir

  2. Assistant

    Entiendo que estás desarrollando una aplicación en Java para la gestión de una terminal de transportes y te has encontrado con varios errores relacionados con los constructores y métodos en tus clases de modelo y controlador. A continuación, te proporcionaré una guía detallada para resolver estos problemas, asegurándome de que tu proyecto esté bien estructurado y funcione correctamente según los requerimientos descritos.

    1. Análisis de Errores

    a. Errores en AdministradorFlota

    • Error: The constructor Bus(String, int) is undefinedJava(134217858)

      Causa: En tu clase Bus, el constructor definido es:

      public Bus(String placa, int puestosDisponibles, EmpresaTransporte empresa) { ... }
      

      Sin embargo, estás intentando crear una instancia de Bus pasando solo dos parámetros (placa y puestos), omitiendo el tercero (EmpresaTransporte empresa).

    • Error: The constructor Viaje(String, String, LocalTime, LocalDateTime, Bus, double) is undefinedJava(134217858)

      Causa: En tu clase Viaje, el constructor definido es:

      public Viaje(String origen, String destino, LocalTime horaSalida, LocalDateTime fechaLlegada, Bus busAsignado, double valorUnitario) { ... }
      

      Pero estás intentando crear una instancia de Viaje pasando solo cinco parámetros, omitiendo origen.

    b. Error en ControladorCliente

    • Error: The method cancelarReserva(Reserva) is undefined for the type ClienteJava(67108964)

      Causa: Estás intentando llamar al método cancelarReserva(Reserva) en la clase Cliente, pero este método no está definido. En su lugar, tienes cancelarReservaPorViaje(Viaje viaje).

    c. Error en Main

    • Error: The method procesarColaEsperas(Viaje) in the type ControladorViaje is not applicable for the arguments (String, LocalDateTime)Java(67108979)

      Causa: Estás llamando al método procesarColaEsperas pasando un String y un LocalDateTime, cuando este método espera un objeto Viaje.


    2. Soluciones Propuestas

    Vamos a abordar cada uno de estos errores paso a paso.

    a. Corrección de Constructores en Bus y Viaje

    i. Actualizar el Constructor de Bus:

    Asegúrate de que cada instancia de Bus se cree proporcionando los tres parámetros requeridos: placa, puestosDisponibles y EmpresaTransporte empresa.

    Ejemplo de Corrección en ControladorAdministradorFlota:

    public boolean registrarBus(String placa, int puestos) {
        // Verificar 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); // Se pasa la empresa
        empresa.agregarBus(nuevoBus);
        return true;
    }
    

    ii. Simplificar el Constructor de Viaje:

    Dado que el origen es siempre "Ciudad Terminal", puedes simplificar el constructor de Viaje eliminando el parámetro origen y estableciéndolo internamente.

    Actualización en Viaje.java:

    public class Viaje implements Serializable {
        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<Cliente> colaEspera;
    
        // Constructor simplificado
        public Viaje(String destino, LocalTime horaSalida, LocalDateTime fechaLlegada, Bus busAsignado, double valorUnitario) {
            this.origen = "Ciudad Terminal"; // Origen fijo
            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<>();
        }
    
        // Constructor existente (si aún lo necesitas)
        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<>();
        }
    
        // Resto de la clase...
    }
    

    iii. Actualizar ControladorAdministradorFlota para Usar el Constructor Simplificado:

    En tu controlador, asegúrate de crear instancias de Viaje usando el constructor que no requiere origen.

    Ejemplo de Corrección en ControladorAdministradorFlota:

    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;
    }
    

    b. Añadir el Método cancelarReserva en Cliente

    Debido a que ControladorCliente está intentando llamar a cancelarReserva(Reserva), y este método no existe en Cliente, necesitas implementarlo.

    Actualización en Cliente.java:

    public class Cliente extends Usuario {
        // ... otros atributos y métodos ...
    
        /**
         * Cancela una reserva específica.
         */
        public boolean cancelarReserva(Reserva reserva) {
            return this.reservas.eliminar(r -> r.equals(reserva));
        }
    
        // ... resto de la clase ...
    }
    

    c. Ajustar la Llamada a procesarColaEsperas en Main

    El método procesarColaEsperas en ControladorViaje espera un objeto Viaje, pero estás pasando un String y un LocalDateTime. Debes buscar primero el objeto Viaje correspondiente y luego pasarlo al método.

    Corrección en Main.java:

    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 = 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("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(viaje); // Se pasa el objeto Viaje
    
                // 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.");
            }
        }
    }
    

    Notas Importantes:

    • Método reservarTiquete en ControladorCliente: Asegúrate de que estás llamando al método correcto en el controlador de cliente para reservar tiquetes. En el código original compartido, se utilizó controladorViaje.venderTiquete, pero debería ser controladorCliente.reservarTiquete.

    d. Implementación Completa de ControladorCliente

    Asegúrate de que la clase ControladorCliente tiene todos los métodos necesarios y que interactúa correctamente con las reservas.

    Actualización en 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, true);
                cliente.agregarReserva(reserva);
                return true;
            } else {
                viaje.agregarACola(cliente);
                Reserva reserva = new Reserva(viaje, cliente, cantidad, false);
                cliente.agregarReserva(reserva);
                cliente.agregarNotificacion(new Notificacion("Reserva en espera para el viaje a " + viaje.getDestino() + "."));
                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); // Ahora este método existe
            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<Devolucion> obtenerHistorialDevoluciones() {
            return cliente.getHistorialDevoluciones();
        }
    
        /**
         * Obtiene las notificaciones del cliente.
         */
        public ListaEnlazada<Notificacion> 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<Reserva> obtenerReservasEfectivas() {
            return cliente.listarReservasEfectivas();
        }
    
        /**
         * Obtiene las reservas activas del cliente.
         */
        public ListaEnlazada<Reserva> obtenerReservasActivas() {
            return cliente.listarReservasActivas();
        }
    }
    

    3. Ajustes Adicionales para Cumplir con los Requisitos del Proyecto

    Dado que estás enfocándote en la gestión de viajes según el enunciado del proyecto, aquí hay algunos ajustes y mejoras que podrías considerar:

    a. Gestión de Colas de Espera

    Asegúrate de que la lógica para manejar las colas de espera esté correctamente implementada en la clase Viaje.

    Actualización en Viaje.java:

    public class Viaje implements Serializable {
        // ... atributos existentes ...
    
        /**
         * Procesa la cola de espera y asigna tiquetes si hay disponibilidad.
         */
        public void procesarCola() {
            while (!colaEspera.estaVacia() && tiquetesVendidos < capacidad) {
                Cliente cliente = colaEspera.desencolar();
                int cantidadSolicitada = 1; // Puedes adaptar esto según tus necesidades
                if (venderTiquete(cantidadSolicitada)) {
                    Tiquete tiquete = new Tiquete(this, cliente, cantidadSolicitada);
                    cliente.acumularPuntos(tiquete.getMontoInvertido());
                    Reserva reserva = new Reserva(this, cliente, cantidadSolicitada, true);
                    cliente.agregarReserva(reserva);
                    cliente.agregarNotificacion(new Notificacion("Tu reserva para el viaje a " + destino + " ha sido confirmada."));
                    busAsignado.getEmpresa().agregarTiquete(tiquete);
                } else {
                    agregarACola(cliente); // Reagregar si aún no hay disponibilidad
                    break;
                }
            }
        }
    
        // ... resto de la clase ...
    }
    

    b. Implementación de Serialización y Singleton para Guardado de Datos

    Dado que mencionas que estás utilizando serialización y el patrón Singleton para el guardado de datos, asegúrate de implementar correctamente estas características para persistir el estado de tus objetos.

    Ejemplo de Implementación Singleton para ControladorLogin:

    package controller;
    
    import model.Usuario;
    import util.ListaEnlazada;
    import java.io.*;
    
    public class ControladorLogin implements Serializable {
        private ListaEnlazada<Usuario> usuarios;
        private ListaEnlazada<EmpresaTransporte> empresasTransporte;
    
        // Instancia única
        private static ControladorLogin instancia = null;
    
        // Constructor privado
        private ControladorLogin() {
            this.usuarios = new ListaEnlazada<>();
            this.empresasTransporte = new ListaEnlazada<>();
            inicializarUsuarios();
        }
    
        // Método para obtener la instancia
        public static ControladorLogin getInstancia() {
            if (instancia == null) {
                instancia = new ControladorLogin();
            }
            return instancia;
        }
    
        // Métodos para guardar y cargar el estado
        public void guardarEstado(String filename) throws IOException {
            try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filename))) {
                oos.writeObject(this);
            }
        }
    
        public static void cargarEstado(String filename) throws IOException, ClassNotFoundException {
            try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filename))) {
                instancia = (ControladorLogin) ois.readObject();
            }
        }
    
        // ... resto de la clase ...
    }
    

    Notas:

    • Asegúrate de que todas las clases que se serializan implementen la interfaz Serializable.
    • Implementa métodos similares en otros controladores si es necesario.

    4. Revisión Final y Buenas Prácticas

    • Consistencia en Nombres de Métodos: Asegúrate de que los nombres de los métodos sean consistentes y reflejen claramente su funcionalidad. Por ejemplo, si un método se llama cancelarReserva, este debe estar presente tanto en la clase Cliente como en el controlador correspondiente.

    • Manejo de Excepciones: Implementa un manejo adecuado de excepciones, especialmente en operaciones que involucran acceso a archivos o interacción con estructuras de datos.

    • Comentarios y Documentación: Mantén comentarios claros y documentación en tu código para facilitar el mantenimiento y comprensión del mismo.

    • Validaciones Adicionales: Implementa validaciones adicionales donde sea necesario, como verificar fechas válidas, evitar ventas de tiquetes en horarios inválidos, etc.


    5. Resumen de Pasos para Resolver los Errores

    1. Actualizar Constructores:

      • Bus.java: Asegurarse de que cada instancia se crea con los tres parámetros requeridos.
      • Viaje.java: Simplificar el constructor para fijar el origen internamente.
    2. Añadir Métodos Faltantes:

      • Cliente.java: Implementar cancelarReserva(Reserva reserva).
    3. Ajustar Llamadas a Métodos:

      • Main.java: Buscar el objeto Viaje correspondiente y pasarlo al método procesarColaEsperas.
    4. Implementar Singleton y Serialización: (Opcional según el progreso del proyecto)

    5. Revisar y Probar Todas las Funcionalidades: Asegurarse de que todas las funcionalidades trabajen según lo esperado y corregir cualquier otro error que pueda surgir.


    Espero que esta guía te ayude a resolver los errores que estás enfrentando y a avanzar en el desarrollo de tu proyecto. Si tienes alguna otra pregunta o necesitas más asistencia, no dudes en pedirla.