userlib/store/

user_store.rs

use std::collections::HashMap;
use std::str::FromStr;

use common::model::status_message::StatusMessage;
use common::remote::services::USER_API;
use common::security::captcha::CaptchaResponse;
use common::store::build_exp_link;
use common::store::{delete, get, post, put};
use uuid::Uuid;

use crate::dto::address_request::AddressRequest;
use crate::dto::auth_request::AuthRequest;
use crate::dto::change_pass_request::ChangePasswordRequest;
use crate::dto::file_request::FileRequest;
use crate::dto::get_token_response::GetTokenResponse;
use crate::dto::recovered_password_request::RecoveredPasswordRequest;
use crate::dto::recovery_response::RecoveryResponse;
use crate::dto::update_user_request::UpdateUserRequest;
use crate::dto::user_request::UserRequest;
use crate::dto::user_role_qr_card_response::UserRoleQrCardResponse;
use crate::dto::user_role_response::UserRoleResponse;
use crate::dto::user_with_roles_response::UserWithRolesResponse;
use crate::dto::verification_role_org_request::VerificationRoleOrgRequest;

pub struct UserStore {}

impl UserStore {
    pub async fn create(new_user: UserRequest) -> Result<UserWithRolesResponse, String> {
        post::<_, UserWithRolesResponse>(build_exp_link(USER_API, format!("/user")), new_user).await
    }

    pub async fn get(user_id: Uuid) -> Result<UserWithRolesResponse, String> {
        get::<UserWithRolesResponse>(build_exp_link(USER_API, format!("/user/{}", user_id))).await
    }

    pub async fn update(updated_user: UpdateUserRequest) -> Result<UserWithRolesResponse, String> {
        put::<_, UserWithRolesResponse>(build_exp_link(USER_API, format!("/user")), updated_user)
            .await
    }

    pub async fn delete(user_id: Uuid) -> Result<usize, String> {
        // todo change usize to status message ?
        delete::<usize>(build_exp_link(USER_API, format!("/user/{}", user_id))).await
    }

    pub async fn get_users_without_roles() -> Result<UserWithRolesResponse, String> {
        get::<UserWithRolesResponse>(build_exp_link(
            USER_API,
            format!("/user/getUsersWithoutRoles"),
        ))
        .await
    }

    pub async fn save_student_data_from_csv(
        file_request: FileRequest,
    ) -> Result<UserWithRolesResponse, String> {
        post::<_, UserWithRolesResponse>(
            build_exp_link(USER_API, format!("/user/saveStudentDataFromCSV")),
            file_request,
        )
        .await
    }

    pub async fn get_token(auth_request: AuthRequest) -> Result<GetTokenResponse, String> {
        post::<_, GetTokenResponse>(
            build_exp_link(USER_API, format!("/user/getToken")),
            auth_request,
        )
        .await
    }

    pub async fn get_token_for_user(user_id: Uuid) -> Result<GetTokenResponse, String> {
        get::<GetTokenResponse>(build_exp_link(
            USER_API,
            format!("/user/getToken/{}", user_id),
        ))
        .await
    }

    pub async fn get_qr_cards(user_id_lists: Vec<Uuid>) -> Result<UserRoleQrCardResponse, String> {
        post::<_, UserRoleQrCardResponse>(
            build_exp_link(USER_API, format!("/user/getQrCards")),
            user_id_lists,
        )
        .await
    }

    pub async fn change_pass(
        user_id: Uuid,
        change_password_request: ChangePasswordRequest,
    ) -> Result<UserWithRolesResponse, String> {
        post::<_, UserWithRolesResponse>(
            build_exp_link(USER_API, format!("/user/changePass/{}", user_id)),
            change_password_request,
        )
        .await
    }

    pub async fn change_online_status(status: String) -> Result<UserWithRolesResponse, String> {
        put::<_, UserWithRolesResponse>(
            build_exp_link(USER_API, format!("/user/changeOnlineStatus/{}", status)),
            serde_json::Value::from_str("{}").unwrap(), // todo option body ?
        )
        .await
    }

    pub async fn find_users_for_org() -> Result<UserRoleQrCardResponse, String> {
        get::<UserRoleQrCardResponse>(build_exp_link(USER_API, format!("/user/findForOrg"))).await
    }

    pub async fn enable_two_step_auth(user_id: Uuid) -> Result<String, String> {
        // todo temp solution
        get::<String>(build_exp_link(
            USER_API,
            format!("/user/enableTwoStepAuth/{}", user_id),
        ))
        .await
    }

    pub async fn disable_two_step_auth(user_id: Uuid) -> Result<String, String> {
        // todo temp solution
        get::<String>(build_exp_link(
            USER_API,
            format!("/user/disableTwoStepAuth/{}", user_id),
        ))
        .await
    }

    pub async fn get_users_by_list_ids(
        id_list: Vec<Uuid>,
    ) -> Result<UserWithRolesResponse, String> {
        // todo get???
        post::<_, UserWithRolesResponse>(
            build_exp_link(USER_API, format!("/user/getUsersByListIds")),
            id_list,
        )
        .await
    }

    pub async fn get_users_by_org_id(id: Uuid) -> Result<UserWithRolesResponse, String> {
        get::<UserWithRolesResponse>(build_exp_link(USER_API, format!("/user/findByOrgId/{id}")))
            .await
    }

    pub async fn get_users_by_org_ids(id_list: Vec<Uuid>) -> Result<UserWithRolesResponse, String> {
        post::<_, UserWithRolesResponse>(
            build_exp_link(USER_API, format!("/user/findByOrgIds")),
            id_list,
        )
        .await
    }

    pub async fn find_by_email(email: String) -> Result<String, String> {
        get::<String>(build_exp_link(
            USER_API,
            format!("/user/findByEmail/{}", email),
        ))
        .await
    }

    pub async fn edit_user_admin(user: UpdateUserRequest) -> Result<UserWithRolesResponse, String> {
        put::<_, UserWithRolesResponse>(
            build_exp_link(USER_API, format!("/user/editUserAdmin")),
            user,
        )
        .await
    }

    pub async fn send_invitation(
        verification_request: VerificationRoleOrgRequest,
    ) -> Result<String, String> {
        // todo response
        post::<_, String>(
            build_exp_link(USER_API, format!("/user/sendInvitation")),
            verification_request,
        )
        .await
    }

    pub async fn find_ids_for_school_invitation() -> Result<Vec<Uuid>, String> {
        get::<Vec<Uuid>>(build_exp_link(
            USER_API,
            format!("/user/getIdsForSchoolInvitation"),
        ))
        .await
    }

    pub async fn send_school_invitations_by_ids_list(id_list: Vec<Uuid>) -> Result<String, String> {
        post::<_, String>(
            build_exp_link(USER_API, format!("/user/sendSchoolInvitationsByIdsList")),
            id_list,
        )
        .await
    }

    pub async fn send_school_invitations(id_list: Vec<Uuid>) -> Result<String, String> {
        post::<_, String>(
            build_exp_link(USER_API, format!("/user/sendSchoolInvitations")),
            id_list,
        )
        .await
    }

    pub async fn send_invitation_from_org(
        org_id: Uuid,
        vitrification_request: VerificationRoleOrgRequest,
    ) -> Result<String, String> {
        post::<_, String>(
            build_exp_link(USER_API, format!("/user/sendInvitation/{org_id}")),
            vitrification_request,
        )
        .await
    }

    pub async fn recover_password_with_captcha(
        auth_request: AuthRequest,
    ) -> Result<String, String> {
        post::<_, String>(
            build_exp_link(USER_API, format!("/user/recover")),
            auth_request,
        )
        .await
    }

    pub async fn recover_password(auth_request: AuthRequest) -> Result<StatusMessage, String> {
        post::<_, StatusMessage>(
            build_exp_link(USER_API, format!("/user/recoverGuest")),
            auth_request,
        )
        .await
    }

    pub async fn recovered_password(
        recovery_request: RecoveredPasswordRequest,
    ) -> Result<usize, String> {
        put::<_, usize>(
            build_exp_link(USER_API, format!("/user/recoveredPassword")),
            recovery_request,
        )
        .await
    }

    pub async fn login_by_token(token: String) -> Result<Vec<UserRoleResponse>, String> {
        get::<Vec<UserRoleResponse>>(build_exp_link(
            USER_API,
            format!("/user/loginByToken/{token}"),
        ))
        .await
    }

    pub async fn approve_role(role_id: Uuid, domain: String) -> Result<UserRoleResponse, String> {
        get::<UserRoleResponse>(build_exp_link(
            USER_API,
            format!("/user/approveRole/{role_id}/{domain}"),
        ))
        .await
    }

    pub async fn delete_user_from_class(
        user_id: Uuid,
        class_id: Uuid,
    ) -> Result<Vec<UserRoleResponse>, String> {
        get::<Vec<UserRoleResponse>>(build_exp_link(
            USER_API,
            format!("/user/deleteFromClass/{user_id}/{class_id}"),
        ))
        .await
    }

    pub async fn decline_role(role_id: Uuid) -> Result<UserRoleResponse, String> {
        get::<UserRoleResponse>(build_exp_link(
            USER_API,
            format!("/user/declineRole/{role_id}"),
        ))
        .await
    }

    pub async fn block_role(role_id: Uuid) -> Result<UserRoleResponse, String> {
        get::<UserRoleResponse>(build_exp_link(
            USER_API,
            format!("/user/blockRole/{role_id}"),
        ))
        .await
    }

    pub async fn set_avatar(path: String) -> Result<UserWithRolesResponse, String> {
        put::<_, UserWithRolesResponse>(build_exp_link(USER_API, format!("/user/setAvatar")), path)
            .await
    }

    pub async fn set_avatar_by_id(
        user_id: Uuid,
        path: String,
    ) -> Result<UserWithRolesResponse, String> {
        put::<_, UserWithRolesResponse>(
            build_exp_link(USER_API, format!("/user/setAvatar/{user_id}")),
            path,
        )
        .await
    }

    pub async fn approve_email_from_token() -> Result<UserRoleResponse, String> {
        get::<UserRoleResponse>(build_exp_link(
            USER_API,
            format!("/user/approveEmailFromToken"),
        ))
        .await
    }

    pub async fn approve_email(user_id: Uuid) -> Result<UserRoleResponse, String> {
        get::<UserRoleResponse>(build_exp_link(
            USER_API,
            format!("/user/approveEmail/{user_id}"),
        ))
        .await
    }

    pub async fn block_user(user_id: Uuid) -> Result<UserWithRolesResponse, String> {
        put::<_, UserWithRolesResponse>(
            build_exp_link(USER_API, format!("/user/blockUser/{user_id}")),
            serde_json::Value::from_str("{}").unwrap(),
        )
        .await
    }

    pub async fn register(user: UpdateUserRequest) -> Result<UserWithRolesResponse, String> {
        post::<_, UserWithRolesResponse>(build_exp_link(USER_API, format!("/user/register")), user)
            .await
    }

    pub async fn get_recovery_response(token: String) -> Result<RecoveryResponse, String> {
        get::<RecoveryResponse>(build_exp_link(
            USER_API,
            format!("/user/getRecovResponse/{token}"),
        ))
        .await
    }

    pub async fn save_teacher_data_from_csv(
        file: FileRequest,
    ) -> Result<UserWithRolesResponse, String> {
        post::<_, UserWithRolesResponse>(
            build_exp_link(USER_API, format!("/user/saveTeacherDataFromCSV")),
            file,
        )
        .await
    }

    pub async fn get_users_by_string_data_for_curr_org(
        data: Vec<String>,
    ) -> Result<UserWithRolesResponse, String> {
        post::<_, UserWithRolesResponse>(
            build_exp_link(USER_API, format!("/user/getUsersByStringDataForCurrOrg")),
            data,
        )
        .await
    }

    pub async fn get_users_by_string_data_for_all_orgs_except_current(
        data: Vec<String>,
    ) -> Result<UserWithRolesResponse, String> {
        post::<_, UserWithRolesResponse>(
            build_exp_link(
                USER_API,
                format!("/user/getUsersByStringDataForAllOrgsExceptCurrent"),
            ),
            data,
        )
        .await
    }

    pub async fn find_for_class(class_id: Uuid) -> Result<Vec<UserWithRolesResponse>, String> {
        get::<Vec<UserWithRolesResponse>>(build_exp_link(
            USER_API,
            format!("/user/findForClass/{class_id}"),
        ))
        .await
    }

    pub async fn find_by_ids(
        ids: Vec<Uuid>,
    ) -> Result<HashMap<Uuid, UserWithRolesResponse>, String> {
        post::<_, HashMap<Uuid, UserWithRolesResponse>>(
            build_exp_link(USER_API, format!("/user/findByIds")),
            ids,
        )
        .await
    }

    pub async fn find_my_addresses() -> Result<Vec<AddressRequest>, String> {
        // todo response
        get::<Vec<AddressRequest>>(build_exp_link(USER_API, format!("/user/addresses"))).await
    }

    pub async fn find_addresses_for_user(user_id: Uuid) -> Result<Vec<AddressRequest>, String> {
        // todo response
        get::<Vec<AddressRequest>>(build_exp_link(
            USER_API,
            format!("/user/addressesForUser/{user_id}"),
        ))
        .await
    }

    pub async fn get_roboteacher() -> Result<UserWithRolesResponse, String> {
        get::<UserWithRolesResponse>(build_exp_link(USER_API, format!("/user/getRoboTeacher")))
            .await
    }
    pub async fn generate_captcha() -> Result<CaptchaResponse, String> {
        get::<CaptchaResponse>(build_exp_link(USER_API, format!("/user/captcha"))).await
    }
}