236 lines
9.0 KiB
Rust
236 lines
9.0 KiB
Rust
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.clone()){
|
|
Ok(events) => events,
|
|
Err(e) => return Err(translate_diesel(e)),
|
|
};
|
|
let total_event_count = match get_event_count(settings, start, end, groups, states){
|
|
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)),
|
|
}
|
|
} |