EinsatzOnline/src/modules/api/events/read.rs

use chrono::{Duration, Local, NaiveDateTime};
use rocket::serde::json::Json;
use rocket::State;

use crate::database::controller::billing::states::get_min_billing_states_for_event;
use crate::database::controller::events::{get_event, get_event_count, get_events, get_events_for_member_in_future, get_instance_positions_name_description};
use crate::database::controller::events::instances::instances::get_instances;
use crate::database::model::events::Event;
use crate::helper::session_cookies::model::SessionCookie;
use crate::helper::settings::Settings;
use crate::helper::translate_diesel_error::translate_diesel;
use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid, parse_uuid_string};
use crate::modules::api::model::api_outcome::{ApiError, ApiErrorWrapper};

#[derive(Queryable, Clone, Deserialize, Serialize)]
pub struct EventList {
    pub(crate) events: Vec<Event>,
    pub(crate) total_event_count: i64,
}

#[get("/api/events?<start>&<end>&<limit>&<offset>&<groups>&<states>", format = "json")]
pub fn read_events(
    settings: &State<Settings>,
    cookie: SessionCookie,
    start: Option<String>,
    end: Option<String>,
    limit: Option<i64>,
    offset: Option<i64>,
    groups: Option<String>,
    states: Option<String>,
) -> Result<Json<EventList>, Json<ApiErrorWrapper>> {
    let caller = parse_member_cookie(cookie.member)?;

    if !caller.has_permission(crate::permissions::modules::event_management::events::VIEW.to_string()) {
        return Err(Json(ApiError::new(403, "Keine Berechtigung Einsätze abzurufen!".to_string()).to_wrapper()))
    }

    let states = match states{
        Some(states) => {
            let mut res: Vec<i16> = vec![];
            for state in states.split(","){
                let parsed_state : i16 = match state.parse(){
                    Ok(state) => state,
                    Err(e) => {
                        error!("Couldn't parse transmitted event state: {}", e);
                        return Err(Json(ApiError::new(400, "Couldn't parse transmitted event states".to_string()).to_wrapper()))
                    }
                };
                res.push(parsed_state)
            }
            Some(res)
        },
        None => None
    };

    let start = match start {
        Some(mut start) => {
            start += "T00:00";
            match NaiveDateTime::parse_from_str(&start, "%Y-%m-%dT%H:%M") {
                Ok(start) => start,
                Err(e) => {
                    error!("Couldn't parse start datetime: {}", e);
                    return Err(Json(ApiError::new(400, "Das eingegebene Datum konnte nicht verarbeitet werden.".to_string()).to_wrapper()))
                }
            }
        },
        None => {
            Local::now().naive_local()
        }
    };
    let end = match end {
        Some(mut end) => {
            end += "T23:59";
            match NaiveDateTime::parse_from_str(&end, "%Y-%m-%dT%H:%M") {
                Ok(end) => end,
                Err(e) => {
                    error!("Couldn't parse end datetime: {}", e);
                    return Err(Json(ApiError::new(400, "Das eingegebene Datum konnte nicht verarbeitet werden.".to_string()).to_wrapper()))
                }
            }
        },
        None => Local::now().naive_local() + Duration::days(90)
    };
    let limit = limit.unwrap_or(settings.api.default_pagination_limit);
    let offset = offset.unwrap_or(0);

    let groups = match groups{
        Some(groups) => {
            let mut groups_res: Vec<uuid::Uuid> = vec![];
            for group in groups.split(','){
                groups_res.push(parse_uuid(group)?);
            }
            Some(groups_res)
        },
        None => None,
    };

    let events = match get_events(settings, start, end, limit, offset, groups.clone(), states){
        Ok(events) => events,
        Err(e) => return Err(translate_diesel(e)),
    };
    let total_event_count = match get_event_count(settings, start, end, groups){
        Ok(count) => count,
        Err(e) => return Err(translate_diesel(e)),
    };

    Ok(Json(EventList{
        events,
        total_event_count
    }))
}

#[get("/api/events/<entity_id>", format = "json")]
pub fn read_event(settings: &State<Settings>, cookie: SessionCookie, entity_id: String) -> Result<Json<Event>, Json<ApiErrorWrapper>>{
    let caller = parse_member_cookie(cookie.member)?;

    if !caller.has_permission(crate::permissions::modules::event_management::events::VIEW.to_string()) {
        return Err(Json(ApiError::new(403, "Keine Berechtigung Einsatz abzurufen!".to_string()).to_wrapper()))
    }

    match get_event(settings, parse_uuid_string(entity_id)?){
        Ok(event) => Ok(Json(event)),
        Err(e) => Err(translate_diesel(e)),
    }
}

/// Returns events member participates in
/// future events only
#[get("/api/events/members/<member_id>", format = "json")]
pub fn read_future_event_for_member(settings: &State<Settings>, cookie: SessionCookie, member_id: String) -> Result<Json<Vec<Event>>, Json<ApiErrorWrapper>>{
    let caller = parse_member_cookie(cookie.member)?;

    if !caller.has_permission(crate::permissions::modules::event_management::VIEW.to_string()) {
        return Err(Json(ApiError::new(403, "Keine Berechtigung Einsätze abzurufen!".to_string()).to_wrapper()))
    }

    match get_events_for_member_in_future(settings, parse_uuid_string(member_id)?){
        Ok(events) => Ok(Json(events)),
        Err(e) => Err(translate_diesel(e)),
    }
}

#[derive(Queryable, Clone, Deserialize, Serialize)]
pub struct EventCastStatus{
    event_id: uuid::Uuid,
    full: bool,
    open_positions: Option<Vec<OpenPosition>>
}

#[derive(Queryable, Clone, Deserialize, Serialize)]
pub struct OpenPosition{
    position_id: uuid::Uuid,
    position_name: String,
}

#[get("/api/events/<event_id>/cast_status", format = "json", rank = 2)]
pub fn check_event_cast_status(settings: &State<Settings>, cookie: SessionCookie, event_id: String) -> Result<Json<EventCastStatus>, Json<ApiErrorWrapper>>{
    let caller = parse_member_cookie(cookie.member)?;

    if !caller.has_permission(crate::permissions::modules::event_management::VIEW.to_string()) {
        return Err(Json(ApiError::new(403, "Keine Berechtigung Einsätze abzurufen!".to_string()).to_wrapper()))
    }

    let event_id = parse_uuid(&event_id)?;

    let instances = match get_instances(settings, event_id){
        Ok(instances) => instances,
        Err(e) => {
            error!("Couldn't get instances for event cast status check.");
            return Err(translate_diesel(e))
        }
    };

    let mut open_positions : Vec<OpenPosition> = vec![];

    for instance in instances{
        let positions = match get_instance_positions_name_description(settings, instance.instance_id) {
            Ok(positions) => positions,
            Err(e) => {
                error!("Couldn't get instance positions for event cast status check.");
                return Err(translate_diesel(e))
            }
        };
        for position in positions{
            if position.taken_by.is_none(){
                open_positions.push(OpenPosition{
                    position_id: position.position_id,
                    position_name: position.name
                })
            }
        }
    }

    let full = open_positions.len() == 0;
    let open_positions = if full { None } else { Some(open_positions) };

    Ok(Json(EventCastStatus {
        event_id: event_id,
        full,
        open_positions,
    }))
}

/*
/// Returns list of all non null billing_states for specific event
#[get("/api/events/<event_id>/billing_states", format = "json", rank = 3)]
pub fn read_billing_states_for_event(settings: &State<Settings>, cookie: SessionCookie, event_id: String) -> Result<Json<Vec<String>>, Json<ApiErrorWrapper>> {
    let caller = parse_member_cookie(cookie.member)?;

    if !caller.has_permission(crate::permissions::modules::event_management::VIEW.to_string()) {
        return Err(Json(ApiError::new(403, "Keine Berechtigung Einsätze abzurufen!".to_string()).to_wrapper()))
    }

    match get_billing_states_for_event(settings, parse_uuid_string(event_id)?) {
        Ok(states) => Ok(Json(states)),
        Err(e) => Err(translate_diesel(e)),
    }
}
*/

/// Returns minimal billing_state for specific event
/// Ignores event units with null as billing_state_id
/// Used to determine if a specific billing state is fulfilled for all instances on one event
#[get("/api/events/<event_id>/billing_states/min", format = "json", rank = 3)]
pub fn read_min_billing_states_for_event(settings: &State<Settings>, cookie: SessionCookie, event_id: String) -> Result<Json<Option<uuid::Uuid>>, Json<ApiErrorWrapper>> {
    let caller = parse_member_cookie(cookie.member)?;

    if !caller.has_permission(crate::permissions::modules::event_management::VIEW.to_string()) {
        return Err(Json(ApiError::new(403, "Keine Berechtigung Einsätze abzurufen!".to_string()).to_wrapper()))
    }

    match get_min_billing_states_for_event(settings, parse_uuid_string(event_id)?) {
        Ok(state) => Ok(Json(state)),
        Err(e) => Err(translate_diesel(e)),
    }
}