src/api.rs - develop - rorikstr/multiberry-frontend

src/api.rs
141 строка4 KB
Rorik Star Platinum
feat: login, logout, account after request
09 ноя 2025, 21:20
09 ноя 2025, 21:20684fbd5
use serde::{Deserialize, Serialize};
use crate::app_log; 

#[derive(Serialize)]
pub struct LoginRequest {
    pub bank_user_id: String,
    pub password: String,
}

#[derive(Deserialize)]
pub struct LoginResponse {
    pub token: String,
    pub bank_user_id: String,
}

pub async fn login(bank_user_id: String, password: String) -> Result<LoginResponse, String> {
    app_log!("Sending login request for {}", bank_user_id);
    let client = reqwest::Client::new();
    let response = client
        .post("http://localhost:3000/api/auth/login")
        .json(&LoginRequest { bank_user_id, password })
        .send()
        .await
        .map_err(|e| e.to_string())?;
    
    if response.status().is_success() {
        response.json().await.map_err(|e| e.to_string())
    } else {
        let err_text = response.text().await.unwrap_or_default();
        app_log!("[ERROR] Login API error: {}", err_text);
        Err(err_text)
    }
}

#[derive(Serialize)]
pub struct RegisterRequest {
    pub bank_user_number: u32,
    pub password: String,
}

pub async fn register(bank_user_number: u32, password: String) -> Result<LoginResponse, String> {
    app_log!("Sending register request for user number {}", bank_user_number);
    let client = reqwest::Client::new();
    let response = client
        .post("http://localhost:3000/api/auth/register")
        .json(&RegisterRequest { bank_user_number, password })
        .send()
        .await
        .map_err(|e| e.to_string())?;
    
    if response.status().is_success() {
        response.json().await.map_err(|e| e.to_string())
    } else {
        let err_text = response.text().await.unwrap_or_default();
        app_log!("[ERROR] Register API error: {}", err_text);
        Err(err_text)
    }
}

pub async fn request_consent(bank: &str, token: &str) -> Result<ConsentResponse, String> {
    let client = reqwest::Client::new();
    let url = format!("http://localhost:3000/api/consent/{}", bank);
    
    let response = client
        .post(&url)
        .header("Authorization", format!("Bearer {}", token))
        .send()
        .await
        .map_err(|e| e.to_string())?;
    
    if response.status().is_success() {
        response.json().await.map_err(|e| e.to_string())
    } else {
        let err_text = response.text().await.unwrap_or_default();
        app_log!("[ERROR] Consent request API error: {}", err_text);
        Err(err_text)
    }
}

pub async fn check_consent(bank: &str, token: &str) -> Result<ConsentResponse, String> {
    let client = reqwest::Client::new();
    let url = format!("http://localhost:3000/api/consent/{}", bank);
    
    let response = client
        .get(&url)
        .header("Authorization", format!("Bearer {}", token))
        .send()
        .await
        .map_err(|e| e.to_string())?;
    
    if response.status().is_success() {
        response.json().await.map_err(|e| e.to_string())
    } else {
        Err("No consent".to_string())
    }
}

#[derive(Deserialize, Clone)]
pub struct AccountsResponse {
    pub data: AccountsData,
}

#[derive(Deserialize, Clone)]
pub struct AccountsData {
    pub account: Vec<Account>,
}

#[derive(Deserialize, Clone)]
pub struct Account {
    #[serde(rename = "accountId")]
    pub account_id: String,
    pub nickname: String,
    pub currency: String,
    pub status: String,
}

pub async fn fetch_accounts(bank: &str, token: &str) -> Result<AccountsResponse, String> {
    let client = reqwest::Client::new();
    let url = format!("http://localhost:3000/api/accounts/{}", bank);
    
    let response = client
        .get(&url)
        .header("Authorization", format!("Bearer {}", token))
        .send()
        .await
        .map_err(|e| e.to_string())?;
    
    if response.status().is_success() {
        response.json().await.map_err(|e| e.to_string())
    } else {
        let err_text = response.text().await.unwrap_or_default();
        app_log!("[ERROR] Fetch accounts API error: {}", err_text);
        Err(err_text)
    }
}

#[derive(Deserialize)]
pub struct ConsentResponse {
    pub consent_id: String,
    pub status: String,
}