jvmvm-api 0.1.0

use diesel::prelude::*;
use warp::reject::Reject;

use crate::{models::Version, schema::versions::dsl::*, sql::establish_connection};

#[derive(Debug)]
pub struct UnexpectedError {
    pub err: diesel::result::Error,
}

impl Reject for UnexpectedError {}

pub async fn get_versions(
    candidate_arg: String,
    vendor_arg: String,
) -> Result<impl warp::Reply, warp::Rejection> {
    let conn = &mut establish_connection();
    match versions
        .filter(candidate.eq(candidate_arg).and(vendor.eq(vendor_arg)))
        .load::<Version>(conn)
    {
        Ok(data) => Ok(warp::reply::json(&data)),
        Err(err) => Err(warp::reject::custom(UnexpectedError { err })),
    }
}

pub async fn get_all_versions(
    all: bool,
    platform_q: &Option<String>,
) -> Result<impl warp::Reply + use<>, warp::Rejection> {
    let conn = &mut establish_connection();
    let mut query = versions.into_boxed();
    if let Some(platform_v) = platform_q {
        query = query.filter(platform.eq(platform_v));
    }

    if !all {
        query = query.filter(visible.eq(true))
    }
    match query.load::<Version>(conn) {
        Ok(data) => Ok(warp::reply::json(&data)),
        Err(err) => Err(warp::reject::custom(UnexpectedError { err })),
    }
}

pub async fn get_version(
    candidate_arg: String,
    vendor_arg: String,
    platform_arg: String,
    version_arg: String,
) -> Result<impl warp::Reply, warp::Rejection> {
    let conn = &mut establish_connection();
    match versions
        .filter(
            candidate.eq(candidate_arg).and(
                vendor
                    .eq(vendor_arg)
                    .and(platform.eq(platform_arg))
                    .and(version.eq(version_arg)),
            ),
        )
        .first::<Version>(conn)
    {
        Ok(data) => Ok(warp::reply::json(&data)),
        Err(diesel::NotFound) => Err(warp::reject::not_found()),
        Err(err) => Err(warp::reject::custom(UnexpectedError { err })),
    }
}