mn create-app example.micronaut.micronautguide \
    --features=data-jdbc,liquibase,oracle,serialization-jackson,validation \
    --build=gradle \
    --lang=groovy \
    --test=spock

package example.micronaut

import groovy.transform.CompileStatic
import io.micronaut.data.annotation.GeneratedValue
import io.micronaut.data.annotation.Id
import io.micronaut.data.annotation.Index
import io.micronaut.data.annotation.MappedEntity
import io.micronaut.data.annotation.Srid
import io.micronaut.data.model.geo.Point

import jakarta.validation.constraints.NotBlank
import jakarta.validation.constraints.NotNull

@CompileStatic
@MappedEntity('delivery_driver') (1)
class DeliveryDriver {

    enum Status {
        AVAILABLE,
        BUSY
    }

    @Id
    @GeneratedValue
    Long id

    @NotBlank
    String name

    @NotNull
    Status status (2)

    @NotNull
    @Srid(4326) (3)
    @Index(columns = 'location') (4)
    Point location

    DeliveryDriver() {
    }

    DeliveryDriver(String name, Status status, Point location) {
        this.name = name
        this.status = status
        this.location = location
    }
}

package example.micronaut

import io.micronaut.data.jdbc.annotation.JdbcRepository
import io.micronaut.data.model.geo.Point
import io.micronaut.data.model.query.builder.sql.Dialect
import io.micronaut.data.repository.CrudRepository

@JdbcRepository(dialect = Dialect.ORACLE) (1)
interface DeliveryDriverRepository extends CrudRepository<DeliveryDriver, Long> {

    List<DeliveryDriver> findByStatusAndLocationNear(DeliveryDriver.Status status, Point orderLocation, double maxDistanceMeters) (2)
}

package example.micronaut

import groovy.transform.CompileStatic
import io.micronaut.data.model.geo.Point
import jakarta.inject.Singleton

@CompileStatic
@Singleton
class DispatchService {

    private static final double MAX_DISTANCE_METERS = 5_000d (1)
    private static final double EARTH_RADIUS_METERS = 6_371_008.8d

    private final DeliveryDriverRepository deliveryDriverRepository

    DispatchService(DeliveryDriverRepository deliveryDriverRepository) {
        this.deliveryDriverRepository = deliveryDriverRepository
    }

    Optional<DriverMatch> findClosestAvailableDriver(Point orderLocation) {
        List<DeliveryDriver> candidates = deliveryDriverRepository.findByStatusAndLocationNear(
            DeliveryDriver.Status.AVAILABLE,
            orderLocation,
            MAX_DISTANCE_METERS
        ) (2)

        DriverMatch closest = null
        for (DeliveryDriver driver : candidates) {
            DriverMatch match = new DriverMatch(
                driver.id,
                driver.name,
                distanceMeters(orderLocation, driver.location)
            )
            if (closest == null || match.distanceMeters < closest.distanceMeters) {
                closest = match
            }
        }
        return Optional.ofNullable(closest) (3)
    }

    private double distanceMeters(Point left, Point right) { (4)
        double leftLatitude = Math.toRadians(left.y())
        double rightLatitude = Math.toRadians(right.y())
        double deltaLatitude = Math.toRadians(right.y() - left.y())
        double deltaLongitude = Math.toRadians(right.x() - left.x())

        double sinHalfDeltaLatitude = Math.sin(deltaLatitude * 0.5d)
        double sinHalfDeltaLongitude = Math.sin(deltaLongitude * 0.5d)
        double a = sinHalfDeltaLatitude * sinHalfDeltaLatitude +
            Math.cos(leftLatitude) * Math.cos(rightLatitude) *
            sinHalfDeltaLongitude * sinHalfDeltaLongitude
        double c = 2d * Math.atan2(Math.sqrt(a), Math.sqrt(1d - a))
        EARTH_RADIUS_METERS * c
    }
}

package example.micronaut

import groovy.transform.CompileStatic
import io.micronaut.serde.annotation.Serdeable

@CompileStatic
@Serdeable
class DriverMatch {

    final Long driverId
    final String name
    final double distanceMeters

    DriverMatch(Long driverId, String name, double distanceMeters) {
        this.driverId = driverId
        this.name = name
        this.distanceMeters = distanceMeters
    }
}

package example.micronaut

import groovy.transform.CompileStatic
import io.micronaut.data.model.geo.Point
import io.micronaut.http.annotation.Controller
import io.micronaut.http.annotation.Get
import io.micronaut.http.annotation.QueryValue

@CompileStatic
@Controller('/orders') (1)
class DeliveryDispatchController {

    private final DispatchService dispatchService

    DeliveryDispatchController(DispatchService dispatchService) {
        this.dispatchService = dispatchService
    }

    @Get('/nearest-driver') (2)
    Optional<DriverMatch> nearestDriver(@QueryValue double longitude, @QueryValue double latitude) { (3)
        dispatchService.findClosestAvailableDriver(new Point(longitude, latitude))
    }
}

package example.micronaut

import io.micronaut.data.model.geo.Point
import io.micronaut.http.HttpRequest
import io.micronaut.http.HttpResponse
import io.micronaut.http.HttpStatus
import io.micronaut.http.client.BlockingHttpClient
import io.micronaut.http.client.HttpClient
import io.micronaut.http.client.annotation.Client
import io.micronaut.http.client.exceptions.HttpClientResponseException
import io.micronaut.test.extensions.spock.annotation.MicronautTest
import jakarta.inject.Inject
import spock.lang.Specification

@MicronautTest(transactional = false) (1)
class DeliveryDispatchControllerSpec extends Specification {

    @Inject
    DeliveryDriverRepository deliveryDriverRepository

    @Inject
    @Client('/') (2)
    HttpClient httpClient

    void setup() {
        deliveryDriverRepository.deleteAll()
    }

    void "finds closest available driver within five kilometers"() {
        given:
        deliveryDriverRepository.save(new DeliveryDriver(
            'Nearby Driver',
            DeliveryDriver.Status.AVAILABLE,
            new Point(-73.9757d, 40.7554d)
        ))
        DeliveryDriver closest = deliveryDriverRepository.save(new DeliveryDriver(
            'Closest Driver',
            DeliveryDriver.Status.AVAILABLE,
            new Point(-73.9827d, 40.7504d)
        ))
        deliveryDriverRepository.save(new DeliveryDriver(
            'Busy Driver',
            DeliveryDriver.Status.BUSY,
            new Point(-73.9850d, 40.7488d)
        )) (3)
        deliveryDriverRepository.save(new DeliveryDriver(
            'Far Driver',
            DeliveryDriver.Status.AVAILABLE,
            new Point(-73.9000d, 40.8000d)
        )) (4)

        when:
        BlockingHttpClient client = httpClient.toBlocking()
        HttpResponse<DriverMatch> response = client.exchange(
            HttpRequest.GET('/orders/nearest-driver?longitude=-73.9857&latitude=40.7484'),
            DriverMatch
        ) (5)

        then:
        response.status() == HttpStatus.OK
        response.body().driverId == closest.id (6)
    }

    void "returns not found when no available driver is close enough"() {
        given:
        deliveryDriverRepository.save(new DeliveryDriver(
            'Busy Driver',
            DeliveryDriver.Status.BUSY,
            new Point(-73.9850d, 40.7488d)
        ))
        deliveryDriverRepository.save(new DeliveryDriver(
            'Far Driver',
            DeliveryDriver.Status.AVAILABLE,
            new Point(-73.9000d, 40.8000d)
        ))

        when:
        BlockingHttpClient client = httpClient.toBlocking()
        client.exchange(
            HttpRequest.GET('/orders/nearest-driver?longitude=-73.9857&latitude=40.7484'),
            DriverMatch
        ) (7)

        then:
        HttpClientResponseException thrown = thrown()
        thrown.status == HttpStatus.NOT_FOUND
    }
}

./gradlew test