eclipse-ee4j/cargotracker

This system is a cargo tracking and logistics management application that manages the booking, routing, and handling of shipments. It provides interfaces for users to book new cargo, track real-time status and handling events, and view interactive maps of shipment locations. The platform supports administrative tasks such as modifying destinations and deadlines, while also processing bulk handling event data via batch jobs and messaging queues.

15 changes.

The project underwent a comprehensive migration to Jakarta EE 10, updating the persistence layer, JSF components, and build configuration. This period also involved removing legacy application logic, UI components, and test suites, while introducing modern containerized deployment and build automation infrastructure.

31 changes.

This period focused on migrating the codebase to Jakarta EE 10, which involved renaming all packages from \net.java.cargotracker\ to \org.eclipse.cargotracker\ and updating all \javax\ imports to \jakarta\. The domain models for cargo, handling, location, and voyage were modernized with improved validation and Java 8+ features. Additionally, new features were introduced for external routing integration, mobile handling event registration, and public cargo tracking interfaces.

11 changes.

This period focused on expanding the web-based administrative interface with new forms for tracking and managing cargo details, alongside the introduction of real-time cargo tracking via Server-Sent Events. The work also included adding map visualization capabilities and configuring the application for deployment on Open Liberty, supported by corresponding infrastructure and test updates.

The project now includes Kubernetes deployment descriptors (cargo-tracker.yml, postgres.yml) and a GitHub Actions workflow (nightly.yml) to automate nightly builds and deployments. A Dockerfile and docker-compose.yml are added to support containerized local development and cloud deployment. The Maven wrapper (mvnw, mvnw.cmd) is introduced to ensure consistent builds. Additionally, a DEPENDENCIES file is added to track third-party library licenses and origins, and legacy NetBeans-specific configuration files (nb-configuration.xml, nbactions.xml) are removed.

(repo-wide) · high confidence

The interface layer now includes a Coordinates class to represent latitude and longitude as a shared DTO, along with a CoordinatesFactory that maps location UnLocodes to their geographic coordinates. Additionally, a FacesConfiguration class has been added to configure Jakarta Faces with application-scoped beans.

src/main/java/org/eclipse/cargotracker/interfaces · high confidence

Introduced a new public-facing cargo tracking feature, exposing a web interface that allows users to look up a cargo's status and handling history by tracking ID. The implementation adds a JSF backing bean (Track.java) that queries the Cargo and HandlingEvent repositories, and a view adapter (CargoTrackingViewAdapter.java) that formats domain data for the UI, including origin, destination, estimated time of arrival, and a timeline of handling events.

src/main/java/org/eclipse/cargotracker/interfaces/tracking · high confidence

A new SSE-based REST endpoint at /cargo enables real-time updates for all tracked cargo. The RealtimeCargoTrackingService broadcasts CargoUpdated events to connected clients, while view adapters (RealtimeCargoTrackingViewAdapter, LocationViewAdapter) format cargo and location data for the SSE stream.

src/main/java/org/eclipse/cargotracker/interfaces/booking/sse · high confidence

A new CDI qualifier annotation, CargoUpdated, has been introduced in the infrastructure events layer to support context-dependent injection of cargo update events. This change adds the necessary infrastructure to distinguish and inject specific event types within the application's event handling mechanism.

src/main/java/org/eclipse/cargotracker/infrastructure/events · high confidence

A new Java class, HandlingEventRegistrationAttempt, has been introduced in the org.eclipse.cargotracker.interfaces.handling package. This class serves as a transfer object for passing incoming handling event registration attempts to the proper registration procedure, acting as a message queue element. It encapsulates details such as registration and completion times, tracking ID, voyage number, event type, and location code.

src/main/java/org/eclipse/cargotracker/interfaces/handling · high confidence

The Leaflet 1.6.0 JavaScript library (including source and source map files) has been added to the application's webapp resources, enabling interactive map functionality.

src/main/webapp/resources/leaflet · high confidence

New configuration files (server.xml and bootstrap.properties) have been added to the src/main/liberty directory to enable the application to run on Open Liberty. The server.xml defines the necessary Java EE/Jakarta EE features (such as CDI, JMS, JDBC, and EJB timers), configures the embedded HSQLDB data source, sets up JMS queues and activation specs for message-driven beans, and maps the web application context root. The bootstrap.properties file configures HTTP/HTTPS ports and logging limits, allowing the application to be deployed and tested on the Open Liberty runtime.

src/main/liberty · high confidence

Users can now update a shipment's arrival deadline or change its final destination through new admin dialog interfaces. The arrival deadline dialog allows editing the expected arrival date, while the destination dialog provides a dropdown to select a new destination from a list of potential locations.

src/main/webapp/admin/dialogs · high confidence

Introduced new utility classes for the application: ApplicationSettings to track sample data loading status, DateConverter for date/time formatting, RestConfiguration for JAX-RS setup, and SampleDataGenerator to populate the database with initial demo data including locations, voyages, and cargo. These components support the demo environment by providing infrastructure for data seeding and date handling.

src/main/java/org/eclipse/cargotracker/application/util · high confidence

A new multi-step wizard form has been added to the event-logger module, allowing users to input and confirm tracking ID, location, event type, voyage number, and completion date. The form utilizes PrimeFaces components and is styled with the application's CSS, culminating in a confirmation screen that displays the entered data before submission.

src/main/webapp/event-logger · high confidence

A new ExternalRoutingService implementation was added to the routing infrastructure, enabling the application to communicate with an external Path-Finder routing API. This service translates domain models to and from the external API, fetching itineraries based on route specifications and validating them against the user's constraints.

src/main/java/org/eclipse/cargotracker/infrastructure/routing · high confidence

A new internal facade, DefaultBookingServiceFacade, was added to handle booking-related operations such as creating new cargo bookings, assigning cargo to routes, changing destinations or deadlines, and retrieving cargo status or route information. This implementation relies on injected repositories and DTO assemblers to bridge the domain model with the booking interface, providing the concrete logic for the booking API.

src/main/java/org/eclipse/cargotracker/interfaces/booking/facade/internal · high confidence

The project now includes the jQuery library (version 3.5.1) in the webapp resources, enabling client-side DOM manipulation and event handling capabilities for the application's frontend.

src/main/webapp/resources/js · high confidence

Introduced a new mobile web interface for registering handling events, implemented via the new EventLogger managed bean and its associated package documentation. This component provides a user-facing form for logging cargo handling events, allowing users to select a cargo tracking ID, location, voyage, and event type, with validation to ensure required fields like voyage number are present for load/unload operations.

src/main/java/org/eclipse/cargotracker/interfaces/handling/mobile · high confidence

A new package.html file was added to the org.eclipse.pathfinder package, providing an HTML-based description of the pathfinder application context. This documentation clarifies that the pathfinder is a separate context from the core cargo domain model, serving as a routing domain service implementation that works against the API exposed by this specific context.

src/main/java/org/eclipse/pathfinder · high confidence

A new BookingServiceFacade interface has been added to the booking package, defining the public API for booking and managing cargo. This facade shields the domain layer from UI and remote communication concerns, providing methods to book new cargo, load routing and tracking information, assign routes, and manage destination or deadline changes.

src/main/java/org/eclipse/cargotracker/interfaces/booking/facade · high confidence

The Cargo Tracker application now provides a new way to obtain Java Util Logging loggers via CDI injection. A new \LoggerProducer\ class in the \infrastructure.logging\ package uses the \@Produces\ annotation to create loggers dynamically based on the injection point, allowing developers to inject \Logger\ instances directly into their classes. This replaces the need for manual logger instantiation or static logger fields, aligning the application with Jakarta EE 9 standards as indicated by the \jakarta.enterprise\ imports.

src/main/java/org/eclipse/cargotracker/infrastructure/logging · high confidence

Added a new RoutingService interface in the domain service layer that accepts a RouteSpecification and returns a list of possible Itineraries. This introduces a domain-level contract for fetching routes, with an accompanying package documentation file.

src/main/java/org/eclipse/cargotracker/domain/service · high confidence

The application layer now exposes a set of new Java interfaces that define the system's use cases. The BookingService interface allows users to register new cargo, request possible routes, and modify destination or arrival deadlines. The HandlingEventService interface enables the registration of handling events, while the CargoInspectionService interface supports inspection and notification of cargo status. Additionally, the ApplicationEvents interface provides a mechanism for the system to notify other components about cargo handling, misdirection, and arrival events.

src/main/java/org/eclipse/cargotracker/application · high confidence

Added new internal implementations for the application layer: DefaultBookingService, DefaultCargoInspectionService, and DefaultHandlingEventService. These classes provide the concrete logic for booking new cargo, inspecting cargo status, and registering handling events, effectively implementing the corresponding interfaces within the org.eclipse.cargotracker.application.internal package.

src/main/java/org/eclipse/cargotracker/application/internal · high confidence

Added a new file-based interface for processing handling events, including a scheduled scanner that triggers a batch job to read, parse, and archive event files. The implementation uses Jakarta Batch (JSR-352) with new components: EventItemReader/Writer for chunk processing, a JobListener for logging, and a SkipReadListener to handle malformed lines by writing them to a failed directory. The package was also migrated from net.java.cargotracker to org.eclipse.cargotracker.

src/main/java/org/eclipse/cargotracker/interfaces/handling/file · high confidence

The booking interface now exposes structured data transfer objects (DTOs) for cargo tracking and route information. New assembler classes (CargoRouteDtoAssembler, CargoStatusDtoAssembler, ItineraryCandidateDtoAssembler, LocationDtoAssembler, and TrackingEventsDtoAssembler) map internal domain models to external-facing DTOs. This enables the UI to display detailed cargo status, handling events with timestamps, and available route candidates with leg details, improving the visibility of shipment progress and itinerary options.

src/main/java/org/eclipse/cargotracker/interfaces/booking/facade/internal/assembler · high confidence

Added new JSF templates for the admin tracking section: a 'Track Cargo' page (track.xhtml) that allows administrators to search for a cargo by ID and view its status, handling history, and ETA, and a 'Live Map' page (map.xhtml/mapFrame.xhtml) that displays real-time cargo locations on an OpenStreetMap using the Leaflet library and Server-Sent Events for live updates.

src/main/webapp/admin/tracking · high confidence

The admin dashboard now includes three new pages for managing cargo: a table for claimed cargoes, a table for not-yet-routed cargoes (with inline actions to update destination and deadline), and a table for routed but unclaimed cargoes (showing last known location and status). These new views allow administrators to track and modify cargo details directly from the web interface.

src/main/webapp/admin/tables · high confidence

The cargo tracking application layer has been removed, including the \ApplicationEvents\ interface and the \BookingService\, \CargoInspectionService\, and \HandlingEventService\ interfaces along with their default implementations. Additionally, utility classes such as \DateUtil\, \LocationUtil\, and \RestConfiguration\ have been deleted, as have the \BookingBackingBean\ (JSF UI component) and the \SampleDataGenerator\ used for demo data. This removes the core application logic and associated UI components for booking and tracking cargo.

src/main/java/net, src/main/resources/net · high confidence

New package-level documentation files (package.html) were added to the domain model and domain/model directories. These HTML files provide an overview of the application's core domain logic, explaining that the domain model is the heart of the application, containing aggregates, repositories, and factories, and utilizing ubiquitous language familiar to cargo shipping experts.

src/main/java/org/eclipse/cargotracker/domain · high confidence

The domain shared classes (Specification interface, AbstractSpecification, AndSpecification, OrSpecification, and NotSpecification) have been moved from the net.java.cargotracker package to the org.eclipse.cargotracker package. This package rename affects all classes in the domain/shared directory, updating their package declarations and import statements accordingly.

src/main/java/org/eclipse/cargotracker/domain/shared · high confidence

The REST endpoint for registering handling events now enforces stricter validation rules on incoming data. Specifically, the completion time field now requires 15 to 19 characters (previously 16), and all required string fields (completion time, tracking ID, event type, and UN location code) now include explicit error messages for missing or invalid values. This ensures that users receive clear feedback when submitting handling reports with malformed or incomplete data.

src/main/java/org/eclipse/cargotracker/interfaces/handling/rest · high confidence

The booking flow pages (booking, booking-destination, booking-date) and their configuration have been updated to use the Jakarta EE 10 namespace (jakarta.faces.\*) and the Jakarta Faces 4.0 schema. The JSF backing bean references were changed from bookingBackingBean to booking, and the layout was adjusted to use PrimeFaces grid classes (ui-g-2, ui-g-8) instead of the previous grid system. These changes align the booking interface with the upgraded server environment.

src/main/webapp/booking · high confidence

The location domain model, including the Location, UnLocode, and SampleLocations classes, has been migrated from the legacy javax.persistence and javax.validation APIs to the new jakarta.persistence and jakarta.validation APIs. Additionally, the package structure has been updated from net.java.cargotracker to org.eclipse.cargotracker, aligning with the Eclipse project namespace. This change ensures compatibility with modern Jakarta EE 10 environments and removes dependencies on the older Java EE 8/Java SE 8 specific annotations and validation constraints.

src/main/java/org/eclipse/cargotracker/domain/model/location · high confidence

The pathfinder API classes have been moved from the \net.java\ package to \org.eclipse.pathfinder.api\ and \org.eclipse.pathfinder.internal\. This includes the new \GraphTraversalService\ resource, which provides a REST endpoint for finding the shortest transit path between two UN location codes, along with updated \TransitEdge\ and \TransitPath\ models. The codebase has also been upgraded to use Jakarta EE 10 annotations (e.g., \jakarta.\*\ imports) and modern Java 8+ syntax.

src/main/java/org/eclipse/pathfinder/api · high confidence

The JPA repository implementations (JpaCargoRepository, JpaHandlingEventRepository, JpaLocationRepository, and JpaVoyageRepository) have been updated to use Jakarta EE 9 APIs (e.g., jakarta.persistence, jakarta.enterprise) and Java 8 syntax, replacing the previous javax.\* namespace usage. This change ensures compatibility with modern Jakarta EE 9+ servers and aligns the persistence infrastructure with current Java standards.

src/main/java/org/eclipse/cargotracker/infrastructure/persistence · high confidence

The voyage domain model classes (CarrierMovement, Schedule, Voyage, VoyageNumber) have been migrated from the legacy javax.\* namespace to the new jakarta.\* namespace, reflecting the Jakarta EE 9+ package rename. Additionally, validation annotations have been updated (e.g., @NotEmpty replacing @NotNull in some contexts) and date-time handling has been modernized to use java.time.LocalDateTime with nanosecond truncation to resolve Hibernate persistence issues. The package structure has also been updated from net.java.cargotracker to org.eclipse.cargotracker.

src/main/java/org/eclipse/cargotracker/domain/model/voyage · high confidence

The web controllers for the cargo booking interface have been migrated to Jakarta EE 10, updating all imports from the \javax\ namespace to \jakarta\ and adjusting the package structure to \org.eclipse.cargotracker.interfaces.booking.web\. This change includes the addition of new controllers for handling cargo details, itinerary selection, and deadline changes, while refactoring existing controllers like \ChangeDestination\ and \ItinerarySelection\ to align with the new framework standards and improve separation between the user interface and the domain model.

src/main/java/org/eclipse/cargotracker/interfaces/booking/web · high confidence

The JMS messaging layer has been updated to use the \jakarta.\\ package namespaces (e.g., \jakarta.ejb\, \jakarta.jms\) and the \org.eclipse.cargotracker\ package structure, replacing the previous \javax.\\ and \net.java.cargotracker\ conventions. This includes renaming \JmsApplicationEvents\ and introducing new message-driven consumers (\CargoHandledConsumer\, \DeliveredCargoConsumer\, \HandlingEventRegistrationAttemptConsumer\, \MisdirectedCargoConsumer\, \RejectedRegistrationAttemptsConsumer\) to handle asynchronous events for cargo tracking and handling.

src/main/java/org/eclipse/cargotracker/infrastructure/messaging · high confidence

The cargo domain model classes (Cargo, Delivery, Itinerary, etc.) have been migrated from the \javax\ to the \jakarta\ namespace, reflecting an upgrade to Jakarta EE 10. This includes updating all \javax.persistence\ imports to \jakarta.persistence\ and \javax.validation\ to \jakarta.validation\. Additionally, the \RouteSpecification\ class now uses \java.time.LocalDate\ for the arrival deadline instead of \java.util.Date\, and validation annotations have been updated to use \@NotEmpty\ and \@NotNull\ from the Jakarta validation API. The package name has also been updated from \net.java.cargotracker\ to \org.eclipse.cargotracker\.

src/main/java/org/eclipse/cargotracker/domain/model/cargo · high confidence

The handling domain model has been modernized to align with current Java and Jakarta EE standards. The \HandlingEvent\ class and its associated factory, repository interface, and exception classes have been updated with improved validation, time handling, and dependency injection. Additionally, the \HandlingHistory\ class has been refactored to use modern Java features, such as \List.of()\ and \Comparator.comparing()\, replacing older patterns like \Collections.sort()\ and anonymous inner classes.

src/main/java/org/eclipse/cargotracker/domain/model/handling · medium confidence

The public tracking and about pages have been redesigned to modernize the user interface and improve usability. The tracking page now uses a card-based layout with a dedicated input field for the tracking ID, and the handling history now displays timestamps for each event. A new interactive map view has been added to the tracking page, allowing users to see the origin, destination, and last known location of their cargo on a map. The about page has also been updated with a cleaner layout and updated links.

src/main/webapp/public · high confidence

The admin and public site templates have been restructured to use a side-panel navigation menu instead of the previous top-header layout. The admin template now features a vertical menu with links to Live, Book, Track, About, and Dashboard, while the public template includes a side-panel with About and Tracking links. Both templates have been updated to use the Jakarta Faces namespace (jakarta.faces.\*) and include JavaScript handlers that make the logo images clickable to return to the home page.

src/main/webapp/WEB-INF/templates · high confidence

The internationalization (i18n) message properties for cargo status and delivery history events have been moved to the new org.eclipse.cargotracker package structure. This change reflects the broader package rename from jakarta.cargotracker to org.eclipse.cargotracker, ensuring that all localized text resources are correctly aligned with the updated namespace.

src/main/resources/org · high confidence

The application's static assets have been removed, specifically the custom calendar and CargoTracker CSS stylesheets, the jQuery jvectormap styles, and the bundled jQuery 3.4.1 library. This change eliminates the associated UI components and dependencies, meaning the application no longer provides the calendar picker, map visualization, or the specific jQuery functionality previously available in these resources.

src/main/webapp/resources, src/main/webapp/resources/primefaces · medium confidence

The Foundation CSS framework stylesheets (foundation.css and foundation.min.css) have been removed from the application. This change eliminates the dependency on the external CSS framework, likely to reduce bundle size or migrate to a different styling approach.

src/main/webapp/resources/css · high confidence

The CSV file handling\_events.csv has been removed from the application's resources. This file previously contained sample event data (including timestamps, identifiers, and locations), and its removal means the application no longer has access to this specific set of event records.

src/main/resources · high confidence

The admin interface has been significantly restructured to support Jakarta EE 10 and Payara 6. Several older XHTML views (changeDestination, listClaimed, listNotRouted, listRouted, map, mapFrame, track) were removed, while others (about, dashboard, route, selectItinerary) were updated to use Jakarta namespace URIs (jakarta.faces.\*) and modernized layouts. This change reflects a broader migration of the application's presentation layer to the new Java EE/Jakarta EE standards.

src/main/webapp/admin · high confidence

The eventLogger feature's web layer has been removed. Specifically, the JSF flow definition (eventLogger-flow.xml), the XHTML templates for the first and second screens (eventLogger.xhtml), and the root redirect page (root.xhtml) have all been deleted. This eliminates the user-facing interface for logging events via the PrimeFaces mobile UI.

src/main/webapp/eventLogger · high confidence

The project's Maven wrapper has been upgraded to version 3.9.16, ensuring that all developers and CI systems use a consistent, up-to-date version of the build tool. This change updates the \maven-wrapper.properties\ file to reference the new wrapper version and distribution URL, which helps prevent build inconsistencies caused by varying local Maven installations.

.mvn · high confidence

The booking facade's data transfer objects have been refactored to improve the tracking and routing information available to the user. CargoStatus now includes a list of handling events for the track page, while CargoRoute and Leg DTOs have been updated to use the new Location DTO and standardize date/time handling. These changes ensure that the booking interface presents accurate, up-to-date cargo status, itinerary details, and tracking events.

src/main/java/org/eclipse/cargotracker/interfaces/booking/facade/dto · high confidence

The homepage (index.xhtml) has been updated to reflect the Eclipse Cargo Tracker branding and Jakarta EE 10 compatibility, including updated links and styling. Additionally, the legacy error handling pages (error.xhtml, error\_404.xhtml) and the mobile.xhtml page have been removed from the webapp directory.

src/main/webapp · medium confidence

The persistence configuration has been updated to Jakarta EE 10 (JPA 3.0), which changes the XML namespace and schema location. The configuration now enables shared caching for the 'CargoTrackerUnit' and is set to load initial data from 'initital-data.sql' to support application settings checks. Additionally, the file includes a SQL script to insert a default application settings record.

src/main/resources/META-INF · medium confidence

Add sample data for handling events; Added and migrated application-layer integration tests; Added unit tests for Cargo, Itinerary, and RouteSpecification domain models; Added unit tests for HandlingEvent and HandlingHistory; Added unit tests for location model and DTO assembler; Removed legacy test suite for cargo tracking.

The project's Maven build has been updated to use newer versions of several key dependencies, including upgrading JUnit from 4.12 to 4.13.1, Hibernate Validator to 6.0.16.Final, and PrimeFaces to 6.2. Additionally, the build configuration was simplified by removing the explicit dependency on the ui-lightness theme and updating the Arquillian BOM version to 1.1.10.Final.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 35 → 36 (+0.5)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 94 → 93 (-0.3)
• Architecture 100 → 98 (-2.1)
• Maturity 52 → 36 (-15.9)
• Readiness 30 → 34 (+3.6)
• Security 60 → 52 (-7.9)
• Domain Modelling 63 → 69 (+6.3)
• Accessibility 21 → 26 (+4.8)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 3) (src/main/java/org/eclipse/cargotracker/application/util/SampleDataGenerator.java)
• Duplicated block (12 lines × 2) (src/main/java/org/eclipse/cargotracker/interfaces/booking/facade/internal/assembler/CargoStatusDtoAssembler.java)
• Duplicated block (16 lines × 2) (src/main/java/org/eclipse/cargotracker/application/util/SampleDataGenerator.java)
• Duplicated block (7 lines × 2) (src/main/java/org/eclipse/cargotracker/application/util/SampleDataGenerator.java)
• Duplicated block (8 lines × 2) (src/main/java/org/eclipse/cargotracker/application/util/SampleDataGenerator.java)
• Duplicated block (8 lines × 2) (src/main/java/org/eclipse/cargotracker/interfaces/booking/web/ChangeArrivalDeadlineDialog.java)
• Duplicated block (8 lines × 3) (src/main/java/org/eclipse/cargotracker/application/util/SampleDataGenerator.java)
• Duplicated block (9 lines × 2) (src/main/java/org/eclipse/cargotracker/application/util/SampleDataGenerator.java)
• Duplicated block (9 lines × 2) (src/main/java/org/eclipse/cargotracker/application/util/SampleDataGenerator.java)
• Duplicated block (9 lines × 2) (src/main/java/org/eclipse/cargotracker/domain/model/cargo/Itinerary.java)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 16 more

• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no usage examples (README.md)
• Duplicated block (10–11 lines × 3) (src/main/java/org/eclipse/cargotracker/application/util/SampleDataGenerator.java)
• Duplicated block (11 lines × 2) (src/main/java/org/eclipse/cargotracker/application/util/SampleDataGenerator.java)
• Duplicated block (13 lines × 3) (src/main/java/org/eclipse/cargotracker/domain/model/cargo/TrackingId.java)
• Duplicated block (16 lines × 2) (src/main/java/org/eclipse/cargotracker/application/util/SampleDataGenerator.java)
• Duplicated block (16 lines × 2) (src/main/java/org/eclipse/cargotracker/interfaces/booking/web/ChangeArrivalDeadlineDialog.java)
• Duplicated block (25 lines × 2) (src/main/java/org/eclipse/cargotracker/interfaces/booking/facade/internal/assembler/CargoStatusDtoAssembler.java)
• Duplicated block (33 lines × 3) (src/main/java/org/eclipse/cargotracker/infrastructure/messaging/jms/DeliveredCargoConsumer.java)
• Duplicated block (7 lines × 2) (src/main/java/org/eclipse/cargotracker/application/util/SampleDataGenerator.java)
• Duplicated block (8 lines × 2) (src/main/java/org/eclipse/cargotracker/application/util/SampleDataGenerator.java)
• Duplicated block (8 lines × 3) (src/main/java/org/eclipse/cargotracker/application/util/SampleDataGenerator.java)
• Duplicated block (8 lines × 3) (src/main/java/org/eclipse/cargotracker/application/util/SampleDataGenerator.java)
• Duplicated block (8–9 lines × 5) (src/main/java/org/eclipse/cargotracker/application/util/SampleDataGenerator.java)
• Duplicated block (9 lines × 2) (src/main/java/org/eclipse/cargotracker/application/util/SampleDataGenerator.java)
• Duplicated block (9 lines × 2) (src/main/java/org/eclipse/cargotracker/application/util/SampleDataGenerator.java)
• Edited copy of a member (27 corresponding lines) (src/main/java/org/eclipse/cargotracker/interfaces/booking/facade/internal/assembler/CargoStatusDtoAssembler.java)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 87 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

eclipse-ee4j/cargotracker was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.