vatsim-api 0.1.0

Rust types, async client, and mock server for various VATSIM APIs.
Documentation
use axum::extract::{Path, State};
use axum::http::StatusCode;
use axum::routing::{get, post};
use axum::{Json, Router};

use crate::mock::state::{MockState, SharedState};
use crate::types::CertificateId;
use crate::types::connect::ConnectUser;
use crate::types::datafeed::{Atis, Controller, Pilot, Prefile, Server};

type ApiResult<T> = Result<Json<T>, StatusCode>;
type StatusCodeResult = Result<StatusCode, StatusCode>;

pub fn routes() -> Router<SharedState> {
    Router::new()
        .route("/api/state", get(get_state).put(put_state))
        .route("/api/reset", post(reset_state))
        .route("/api/pilots", get(list_pilots).post(upsert_pilot))
        .route(
            "/api/pilots/{cid}",
            get(get_pilot).put(put_pilot).delete(delete_pilot),
        )
        .route(
            "/api/controllers",
            get(list_controllers).post(upsert_controller),
        )
        .route(
            "/api/controllers/{cid}",
            get(get_controller)
                .put(put_controller)
                .delete(delete_controller),
        )
        .route("/api/atis", get(list_atis).post(upsert_atis))
        .route(
            "/api/atis/{callsign}",
            get(get_atis).put(put_atis).delete(delete_atis),
        )
        .route("/api/prefiles", get(list_prefiles).post(upsert_prefile))
        .route(
            "/api/prefiles/{cid}",
            get(get_prefile).put(put_prefile).delete(delete_prefile),
        )
        .route("/api/servers", get(list_servers).post(upsert_server))
        .route(
            "/api/servers/{ident}",
            get(get_server).put(put_server).delete(delete_server),
        )
        .route("/api/users", get(list_users).post(upsert_user))
        .route(
            "/api/users/{cid}",
            get(get_user_by_cid).put(put_user).delete(delete_user),
        )
}

async fn get_state(State(state): State<SharedState>) -> ApiResult<MockState> {
    let state = state.read().await;
    Ok(Json(state.clone()))
}

async fn put_state(
    State(state): State<SharedState>,
    Json(new_state): Json<MockState>,
) -> StatusCodeResult {
    let mut state = state.write().await;
    state.replace(new_state);
    Ok(StatusCode::NO_CONTENT)
}

async fn reset_state(State(state): State<SharedState>) -> StatusCodeResult {
    let mut state = state.write().await;
    state.reset();
    Ok(StatusCode::NO_CONTENT)
}

async fn list_pilots(State(state): State<SharedState>) -> ApiResult<Vec<Pilot>> {
    let state = state.read().await;
    Ok(Json(state.pilots.clone()))
}

async fn get_pilot(State(state): State<SharedState>, Path(cid): Path<u32>) -> ApiResult<Pilot> {
    let state = state.read().await;
    state
        .pilot(CertificateId::new(cid))
        .cloned()
        .map(Json)
        .ok_or(StatusCode::NOT_FOUND)
}

async fn upsert_pilot(
    State(state): State<SharedState>,
    Json(pilot): Json<Pilot>,
) -> StatusCodeResult {
    let mut state = state.write().await;
    state.upsert_pilot(pilot);
    Ok(StatusCode::NO_CONTENT)
}

async fn put_pilot(
    State(state): State<SharedState>,
    Path(cid): Path<u32>,
    Json(mut pilot): Json<Pilot>,
) -> StatusCodeResult {
    pilot.cid = CertificateId::new(cid);
    let mut state = state.write().await;
    state.upsert_pilot(pilot);
    Ok(StatusCode::NO_CONTENT)
}

async fn delete_pilot(State(state): State<SharedState>, Path(cid): Path<u32>) -> StatusCodeResult {
    let mut state = state.write().await;
    if state.remove_pilot(CertificateId::new(cid)) {
        Ok(StatusCode::NO_CONTENT)
    } else {
        Err(StatusCode::NOT_FOUND)
    }
}

async fn list_controllers(State(state): State<SharedState>) -> ApiResult<Vec<Controller>> {
    let state = state.read().await;
    Ok(Json(state.controllers.clone()))
}

async fn get_controller(
    State(state): State<SharedState>,
    Path(cid): Path<u32>,
) -> ApiResult<Controller> {
    let state = state.read().await;
    state
        .controller(CertificateId::new(cid))
        .cloned()
        .map(Json)
        .ok_or(StatusCode::NOT_FOUND)
}

async fn upsert_controller(
    State(state): State<SharedState>,
    Json(controller): Json<Controller>,
) -> StatusCodeResult {
    let mut state = state.write().await;
    state.upsert_controller(controller);
    Ok(StatusCode::NO_CONTENT)
}

async fn put_controller(
    State(state): State<SharedState>,
    Path(cid): Path<u32>,
    Json(mut controller): Json<Controller>,
) -> StatusCodeResult {
    controller.cid = CertificateId::new(cid);
    let mut state = state.write().await;
    state.upsert_controller(controller);
    Ok(StatusCode::NO_CONTENT)
}

async fn delete_controller(
    State(state): State<SharedState>,
    Path(cid): Path<u32>,
) -> StatusCodeResult {
    let mut state = state.write().await;
    if state.remove_controller(CertificateId::new(cid)) {
        Ok(StatusCode::NO_CONTENT)
    } else {
        Err(StatusCode::NOT_FOUND)
    }
}

async fn list_atis(State(state): State<SharedState>) -> ApiResult<Vec<Atis>> {
    let state = state.read().await;
    Ok(Json(state.atis.clone()))
}

async fn get_atis(
    State(state): State<SharedState>,
    Path(callsign): Path<String>,
) -> ApiResult<Atis> {
    let state = state.read().await;
    state
        .atis(&callsign)
        .cloned()
        .map(Json)
        .ok_or(StatusCode::NOT_FOUND)
}

async fn upsert_atis(State(state): State<SharedState>, Json(atis): Json<Atis>) -> StatusCodeResult {
    let mut state = state.write().await;
    state.upsert_atis(atis);
    Ok(StatusCode::NO_CONTENT)
}

async fn put_atis(
    State(state): State<SharedState>,
    Path(callsign): Path<String>,
    Json(mut atis): Json<Atis>,
) -> StatusCodeResult {
    atis.callsign = callsign;
    let mut state = state.write().await;
    state.upsert_atis(atis);
    Ok(StatusCode::NO_CONTENT)
}

async fn delete_atis(
    State(state): State<SharedState>,
    Path(callsign): Path<String>,
) -> StatusCodeResult {
    let mut state = state.write().await;
    if state.remove_atis(&callsign) {
        Ok(StatusCode::NO_CONTENT)
    } else {
        Err(StatusCode::NOT_FOUND)
    }
}

async fn list_prefiles(State(state): State<SharedState>) -> ApiResult<Vec<Prefile>> {
    let state = state.read().await;
    Ok(Json(state.prefiles.clone()))
}

async fn get_prefile(State(state): State<SharedState>, Path(cid): Path<u32>) -> ApiResult<Prefile> {
    let state = state.read().await;
    state
        .prefile(CertificateId::new(cid))
        .cloned()
        .map(Json)
        .ok_or(StatusCode::NOT_FOUND)
}

async fn upsert_prefile(
    State(state): State<SharedState>,
    Json(prefile): Json<Prefile>,
) -> StatusCodeResult {
    let mut state = state.write().await;
    state.upsert_prefile(prefile);
    Ok(StatusCode::NO_CONTENT)
}

async fn put_prefile(
    State(state): State<SharedState>,
    Path(cid): Path<u32>,
    Json(mut prefile): Json<Prefile>,
) -> StatusCodeResult {
    prefile.cid = CertificateId::new(cid);
    let mut state = state.write().await;
    state.upsert_prefile(prefile);
    Ok(StatusCode::NO_CONTENT)
}

async fn delete_prefile(
    State(state): State<SharedState>,
    Path(cid): Path<u32>,
) -> StatusCodeResult {
    let mut state = state.write().await;
    if state.remove_prefile(CertificateId::new(cid)) {
        Ok(StatusCode::NO_CONTENT)
    } else {
        Err(StatusCode::NOT_FOUND)
    }
}

async fn list_servers(State(state): State<SharedState>) -> ApiResult<Vec<Server>> {
    let state = state.read().await;
    Ok(Json(state.servers.clone()))
}

async fn get_server(
    State(state): State<SharedState>,
    Path(ident): Path<String>,
) -> ApiResult<Server> {
    let state = state.read().await;
    state
        .server(&ident)
        .cloned()
        .map(Json)
        .ok_or(StatusCode::NOT_FOUND)
}

async fn upsert_server(
    State(state): State<SharedState>,
    Json(server): Json<Server>,
) -> StatusCodeResult {
    let mut state = state.write().await;
    state.upsert_server(server);
    Ok(StatusCode::NO_CONTENT)
}

async fn put_server(
    State(state): State<SharedState>,
    Path(ident): Path<String>,
    Json(mut server): Json<Server>,
) -> StatusCodeResult {
    server.ident = ident;
    let mut state = state.write().await;
    state.upsert_server(server);
    Ok(StatusCode::NO_CONTENT)
}

async fn delete_server(
    State(state): State<SharedState>,
    Path(ident): Path<String>,
) -> StatusCodeResult {
    let mut state = state.write().await;
    if state.remove_server(&ident) {
        Ok(StatusCode::NO_CONTENT)
    } else {
        Err(StatusCode::NOT_FOUND)
    }
}

async fn list_users(State(state): State<SharedState>) -> ApiResult<Vec<ConnectUser>> {
    let state = state.read().await;
    Ok(Json(state.users.clone()))
}

async fn get_user_by_cid(
    State(state): State<SharedState>,
    Path(cid): Path<u32>,
) -> ApiResult<ConnectUser> {
    let state = state.read().await;
    state
        .user(CertificateId::new(cid))
        .cloned()
        .map(Json)
        .ok_or(StatusCode::NOT_FOUND)
}

async fn upsert_user(
    State(state): State<SharedState>,
    Json(user): Json<ConnectUser>,
) -> StatusCodeResult {
    let mut state = state.write().await;
    state.upsert_user(user);
    Ok(StatusCode::NO_CONTENT)
}

async fn put_user(
    State(state): State<SharedState>,
    Path(cid): Path<u32>,
    Json(mut user): Json<ConnectUser>,
) -> StatusCodeResult {
    user.cid = CertificateId::new(cid);
    let mut state = state.write().await;
    state.upsert_user(user);
    Ok(StatusCode::NO_CONTENT)
}

async fn delete_user(State(state): State<SharedState>, Path(cid): Path<u32>) -> StatusCodeResult {
    let mut state = state.write().await;
    if state.remove_user(CertificateId::new(cid)) {
        Ok(StatusCode::NO_CONTENT)
    } else {
        Err(StatusCode::NOT_FOUND)
    }
}