EinsatzOnline/src/database/controller/api_members.rs

use crate::database::controller::connector::establish_connection;
use crate::database::controller::groups::get_groups_for_member;
use crate::database::model::api_members::RawMemberSearchResult;
use crate::diesel::query_dsl::filter_dsl::OrFilterDsl;
use crate::diesel::query_dsl::limit_dsl::LimitDsl;
use crate::diesel::query_dsl::select_dsl::SelectDsl;
use crate::diesel::RunQueryDsl;
use crate::helper::check_access::check_access_to_member_and_group;
use crate::helper::settings::Settings;
use crate::modules::api::members::get_member::MemberSearchResult;
use diesel::query_dsl::filter_dsl::FilterDsl;
use diesel::{ExpressionMethods, PgTextExpressionMethods};
use rocket::State;

pub fn get_raw_member_search_result(
    settings: &State<Settings>,
    member_entity_id: uuid::Uuid,
) -> Result<RawMemberSearchResult, diesel::result::Error> {
    use crate::schema::members::dsl::*;

    let connection = establish_connection(settings);

    let short_member: Result<RawMemberSearchResult, diesel::result::Error> = members
        .filter(entity_id.eq(member_entity_id))
        .select((entity_id, firstname, lastname))
        .first(&connection);

    match short_member {
        Ok(raw_member) => Ok(raw_member),
        Err(e) => {
            warn!("Couldn't load RawMemberSearchResult: {}", e);
            return Err(e);
        }
    }
}

pub fn get_member_search_result(
    settings: &State<Settings>,
    member_entity_id: uuid::Uuid,
    caller_entity_id: uuid::Uuid,
) -> Result<MemberSearchResult, diesel::result::Error> {
    let member = get_raw_member_search_result(settings, member_entity_id)?;
    let groups = get_groups_for_member(settings, member_entity_id);

    let readable = check_access_to_member_and_group(
        settings,
        member_entity_id,
        groups,
        caller_entity_id,
        "modules.member_management.profile.view".to_string(),
    );
    Ok(MemberSearchResult {
        entity_id: member.entity_id,
        firstname: member.firstname,
        lastname: member.lastname,
        readable,
    })
}

pub fn get_raw_member_search_result_by_name(
    settings: &State<Settings>,
    member_name: String,
) -> Result<Vec<RawMemberSearchResult>, diesel::result::Error> {
    use crate::schema::members::dsl::*;

    let connection = establish_connection(settings);

    let splitted_name: Vec<&str> = member_name.split_whitespace().collect();

    let short_members: Result<Vec<RawMemberSearchResult>, diesel::result::Error>;

    if splitted_name.len() == 0 {
        return Ok(vec![]);
    } else if splitted_name.len() == 1 {
        short_members = members
            .filter(firstname.ilike(format!("{}%", member_name)))
            .or_filter(lastname.ilike(format!("{}%", member_name)))
            .select((entity_id, firstname, lastname))
            .limit(5)
            .load(&connection);
    } else {
        short_members = members
            .filter(firstname.ilike(format!("{}%", splitted_name[0])))
            .filter(lastname.ilike(format!("{}%", splitted_name[1])))
            .select((entity_id, firstname, lastname))
            .limit(5)
            .load(&connection);
    }

    match short_members {
        Ok(raw_member) => Ok(raw_member),
        Err(e) => {
            warn!("Couldn't load RawMemberSearchResult: {}", e);
            return Err(e);
        }
    }
}

pub fn get_member_search_result_by_name(
    settings: &State<Settings>,
    name: String,
    caller_entity_id: uuid::Uuid,
) -> Result<Vec<MemberSearchResult>, diesel::result::Error> {
    let raw_members = get_raw_member_search_result_by_name(settings, name)?;
    let mut members: Vec<MemberSearchResult> = vec![];

    for member in raw_members {
        let groups = get_groups_for_member(settings, member.entity_id);
        let readable = check_access_to_member_and_group(
            settings,
            member.entity_id,
            groups,
            caller_entity_id,
            "modules.member_management.profile.view".to_string(),
        );
        members.push(MemberSearchResult {
            entity_id: member.entity_id,
            firstname: member.firstname,
            lastname: member.lastname,
            readable,
        });
    }

    Ok(members)
}

/// DO NOT USE! Will be removed soon, use crate::database::controller::entities::remove_entity instead!
pub fn delete_entity_deprecated(
    settings: &State<Settings>,
    entity_id_to_delete: uuid::Uuid,
) -> Result<usize, diesel::result::Error> {
    use crate::schema::entities::dsl::*;

    let connection = establish_connection(settings);

    match diesel::delete(entities.filter(entity_id.eq(entity_id_to_delete))).execute(&connection) {
        Ok(size) => Ok(size),
        Err(e) => {
            warn!("Couldn't delete entity: {}", e);
            Err(e)
        }
    }
}