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

mira, tengo este proyecto para hacer: Proyecto Final V1 Construcción de app para la…

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

    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.

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

  2. 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 Viaje y un controlador ControladorViaje en 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 Viaje

    Primero, revisemos y ampliemos la clase Viaje para 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

    1. Origen Fijo: El origen del viaje está fijo en "Ciudad Terminal", según el requerimiento.

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

    3. Métodos de Fechas:

      • fechaSalida: Calcula la fecha y hora de salida completa del viaje. Asumo que tienes un método getTiempoEstimadoViaje en la clase Bus que 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.
    4. 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.

    5. Relacionamiento con Empresa: He asumido que la clase Bus tiene un método getEmpresa() para obtener la empresa de transporte asociada, lo cual es necesario para agregar tiquetes vendidos a la lista correspondiente.

    2. Controlador ControladorViaje

    Ahora, vamos a crear un controlador dedicado para gestionar los viajes, que interactúe con el modelo Viaje y 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

    1. Constructor del Controlador: El controlador ControladorViaje recibe una lista de todas las empresas de transporte para gestionar los tiquetes y asegurar que se agreguen correctamente a la empresa correspondiente.

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

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

    4. Método procesarColaEsperas: Llama al método procesarCola del modelo Viaje para asignar automáticamente tiquetes a los clientes en espera cuando se desocupan puestos.

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

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

    7. 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, Reserva y Devolucion tengan los métodos necesarios que se están utilizando en el modelo y el controlador de Viaje. A continuación, revisaré y ajustaré algunas de estas clases para garantizar una correcta integración.

    Archivo: ProyectoFinal/model/Bus.java

    Asegurémonos de que la clase Bus tenga 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.java

    Añ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.java

    Asegurémonos de que la clase Reserva pueda 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.java

    Asegurémonos de que la clase Tiquete tenga métodos apropiados y que se relacione correctamente con EmpresaTransporte.

    // 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.java

    Asegurémonos de que la clase EmpresaTransporte pueda 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.java

    Aseguré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

    1. Integración del Controlador de Viajes: El ControladorAdministradorFlota ahora utiliza el ControladorViaje para gestionar todas las operaciones relacionadas con los viajes. Esto separa las responsabilidades y facilita el mantenimiento.

    2. Método registrarBus: Registra un nuevo bus verificando que la placa no esté duplicada en ninguna de las empresas de transporte existentes.

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

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

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

    6. Método devolverTiquete: Gestiona la devolución de tiquetes y actualiza los puntos y el historial de devoluciones del cliente.

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

    Finalmente, vamos a actualizar el Main.java para demostrar cómo utilizar el nuevo controlador de viajes y verificar que todo funcione correctamente.

    Archivo: 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("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

    1. Integración del Controlador de Viajes: Ahora, el ControladorAdministradorFlota expone el ControladorViaje para que pueda ser utilizado en el Main.java.

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

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

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

    5. 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!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.