nomilo/src/routes/zones.rs

use std::convert::TryInto;
use serde_json::json;
use rocket::Response;
use rocket::http::Status;

use rocket_contrib::json::Json;

use crate::DbConn;
use crate::models;
use crate::dns;
use crate::dns::{RecordApi, ZoneApi};


#[get("/zones/<zone>/records")]
pub async fn get_zone_records(
    client: dns::client::DnsClient,
    conn: DbConn,
    user_info: Result<models::UserInfo, models::ErrorResponse>,
    zone: models::AbsoluteName
) -> Result<Json<Vec<models::Record>>, models::ErrorResponse> {

    let user_info = user_info?;
    let zone_name = zone.to_string();

    conn.run(move |c| {
        if user_info.is_admin() {
            models::Zone::get_by_name(c, &zone_name)
        } else {
            user_info.get_zone(c, &zone_name)
        }
    }).await?;

    let mut dns_api = dns::DnsApiClient::new(client);

    let dns_records = dns_api.get_records(zone.clone(), dns::DNSClass::IN).await?;
    let records: Vec<_> = dns_records.into_iter().map(models::Record::from).collect();

    Ok(Json(records))
}

#[post("/zones/<zone>/records", data = "<new_records>")]
pub async fn create_zone_records(
    client: dns::client::DnsClient,
    conn: DbConn,
    user_info: Result<models::UserInfo, models::ErrorResponse>,
    zone: models::AbsoluteName,
    new_records: Json<Vec<models::Record>>
) -> Result<Json<()>, models::ErrorResponse> {

    let user_info = user_info?;
    let zone_name = zone.to_utf8();

    conn.run(move |c| {
        if user_info.is_admin() {
            models::Zone::get_by_name(c, &zone_name)
        } else {
            user_info.get_zone(c, &zone_name)
        }
    }).await?;

    // TODO: What about relative names (also in cnames and stuff)
    let mut bad_records = Vec::new();
    let mut records: Vec<dns::Record> = Vec::new();

    for record in new_records.into_inner().into_iter() {
        let this_record = record.clone();
        if let Ok(record) = record.try_into() {
            records.push(record);
        } else {
            bad_records.push(this_record.clone());
        }
    }

    if !bad_records.is_empty() {
        return models::ErrorResponse::new(
            Status::BadRequest,
            "Record list contains records that could not been parsed into DNS records".into()
        ).with_details(
            json!({
                "zone_name": zone.to_utf8(),
                "records": bad_records
            })
        ).err();
    }

    let mut dns_api = dns::DnsApiClient::new(client);
    dns_api.add_records(zone.clone(), dns::DNSClass::IN, records).await?;

    return Ok(Json(()));
}

#[get("/zones")]
pub async fn get_zones(
    conn: DbConn,
    user_info: Result<models::UserInfo, models::ErrorResponse>,
) -> Result<Json<Vec<models::Zone>>, models::ErrorResponse> {
    let user_info = user_info?;

    let zones = conn.run(move |c| {
        if user_info.is_admin() {
            models::Zone::get_all(c)
        } else {
            user_info.get_zones(c)
        }
    }).await?;

    Ok(Json(zones))
}

#[post("/zones", data = "<zone_request>")]
pub async fn create_zone(
    conn: DbConn,
    client: dns::client::DnsClient,
    user_info: Result<models::UserInfo, models::ErrorResponse>,
    zone_request: Json<models::CreateZoneRequest>,
) -> Result<Json<models::Zone>, models::ErrorResponse> {
    user_info?.check_admin()?;

    let mut dns_api = dns::DnsApiClient::new(client);
    dns_api.zone_exists(zone_request.name.clone(), dns::DNSClass::IN).await?;

    let zone = conn.run(move |c| {
        models::Zone::create_zone(c, zone_request.into_inner())
    }).await?;

    Ok(Json(zone))
}


#[post("/zones/<zone>/members", data = "<zone_member_request>")]
pub async fn add_member_to_zone<'r>(
    conn: DbConn,
    zone: models::AbsoluteName,
    user_info: Result<models::UserInfo, models::ErrorResponse>,
    zone_member_request: Json<models::AddZoneMemberRequest>
) -> Result<Response<'r>, models::ErrorResponse> {
    let user_info = user_info?;
    let zone_name = zone.to_utf8();

    conn.run(move |c| {
        let zone = if user_info.is_admin() {
            models::Zone::get_by_name(c, &zone_name)
        } else {
            user_info.get_zone(c, &zone_name)
        }?;

        let new_member = models::LocalUser::get_user_by_uuid(c, &zone_member_request.id)?;
        zone.add_member(&c, &new_member)
    }).await?;

    Response::build()
        .status(Status::Created) // TODO: change this?
        .ok()
}