ソフトウェアエンジニアの技術ブログ：Software engineer tech blog

use std::{collections::HashMap, sync::Arc};

use axum::{
    async_trait,
    extract::{FromRequestParts, Request, State},
    middleware::Next,
    response::Response,
    RequestExt as _,
};
use axum_extra::{
    headers::{authorization::Bearer, Authorization},
    TypedHeader,
};
use http::{request::Parts, StatusCode};

pub type Token = String;
pub type UserMap = HashMap<Token, User>;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct User {
    pub username: String,
}

pub fn build_user_map() -> UserMap {
    let mut user_map = HashMap::new();
    user_map.insert(
        "aaa".to_string(),
        User {
            username: "Andy".to_string(),
        },
    );
    user_map.insert(
        "bbb".to_string(),
        User {
            username: "Bella".to_string(),
        },
    );
    user_map.insert(
        "ccc".to_string(),
        User {
            username: "Callie".to_string(),
        },
    );
    user_map.insert(
        "ddd".to_string(),
        User {
            username: "Daren".to_string(),
        },
    );
    user_map
}

#[async_trait]
impl<S> FromRequestParts<S> for User
where
    S: Send + Sync,
{
    type Rejection = StatusCode;

    async fn from_request_parts(parts: &mut Parts, _: &S) -> Result<Self, Self::Rejection> {
        let user = parts
            .extensions
            .get::<Self>()
            .expect("User not found. Did you add auth_middleware?");
        Ok(user.clone())
    }
}

pub async fn auth_middleware(
    State(user_map): State<Arc<UserMap>>,
    mut request: Request,
    next: Next,
) -> axum::response::Result<Response> {
    let bearer = request
        .extract_parts::<TypedHeader<Authorization<Bearer>>>()
        .await
        .map_err(|_| StatusCode::BAD_REQUEST)?;
    let token = bearer.token();

    let user = user_map.get(token).ok_or(StatusCode::UNAUTHORIZED)?;
    request.extensions_mut().insert(user.clone());

    Ok(next.run(request).await)
}

mod auth;

use std::sync::Arc;
use axum::{middleware::from_fn_with_state, routing::get, Router};
use auth::{auth_middleware, build_user_map, User, UserMap};


#[tokio::main]
async fn main() {
    let user_map = build_user_map();
    let app = build_app(Arc::new(user_map));
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

#[rustfmt::skip]
fn build_app(user_map: Arc<UserMap>) -> Router {
    let public_router = Router::new()
        .route("/public", get(public));

    let private_router = Router::new()
        .route("/private", get(private))
        .route("/your-name", get(your_name))
        .route_layer(from_fn_with_state(user_map.clone(), auth_middleware));

    Router::new()
        .nest("/", public_router)
        .nest("/", private_router)
        .with_state(user_map)
}

async fn public() -> &'static str {
    "This is public."
}

async fn private() -> &'static str {
    "This is public."
}

async fn your_name(user: User) -> String {
    format!("Your name is {}.", user.username)
}

curl http://192.168.33.10:3000/public
curl -I http://192.168.33.10:3000/private
curl -H ‘Authorization: Bearer aaa’ http://192.168.33.10:3000/your-name

やりたいことはギリわかるが、Bearer認証およびtraitのextensionとauth middlewareのinputとその先の内容がイマイチ理解できん…

取得して処理する元の値(json)
Object {“currencySymbol”: Null, “id”: String(“likecoin”), “rateUsd”: String(“0.0009301600000000”), “symbol”: String(“LIKE”), “type”: String(“crypto”)}, Object {“currencySymbol”: String(“£”), “id”: String(“falkland-islands-pound”), “rateUsd”: String(“1.2207493203478160”), “symbol”: String(“FKP”), “type”: String(“fiat”)},….

構造体

#[derive(Debug, Serialize, Clone, Deserialize)]
struct Rate {
    id: String,
    symbol: String,
    currencySymbol: String,
    r#type: String,
    rateUsd: String,
}

これで、serde_json::from_valueで構造体Rateに入れようとすると

    let mut coins = get_price().await.unwrap();

    let objs: Vec<Rate> = serde_json::from_value(coins).unwrap();
    for obj in objs {
        println!("{:?}", &obj);
    }    

thread ‘main’ panicked at src/main.rs:17:57:
called `Result::unwrap()` on an `Err` value: Error(“invalid type: null, expected a string”, line: 0, column: 0)
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

構造体ではcurrencySymbolをStringで定義しているが、一部の値でNullが含まれているためエラーになってしまう…

Nullを空文字に置換できないか、構造体でString or Nullみたいな書き方はできないか、　など色々試行錯誤したが、いっそのこと

#[derive(Debug, Serialize, Clone, Deserialize)]
struct Rate {
    id: String,
    symbol: String,
    // currencySymbol: String,
    r#type: String,
    rateUsd: String,
}

currencySymbol自体を取らないとしたら、
$ cargo run
…
Rate { id: “salvadoran-colón”, symbol: “SVC”, type: “fiat”, rateUsd: “0.1137841148955581” }
Rate { id: “saint-helena-pound”, symbol: “SHP”, type: “fiat”, rateUsd: “1.2207493203478160” }
Rate { id: “haitian-gourde”, symbol: “HTG”, type: “fiat”, rateUsd: “0.0076549269176472” }
Rate { id: “bermudan-dollar”, symbol: “BMD”, type: “fiat”, rateUsd: “1.0000000000000000” }
Rate { id: “turkmenistani-manat”, symbol: “TMT”, type: “fiat”, rateUsd: “0.2857142857142857” }
Rate { id: “litecoin”, symbol: “LTC”, type: “crypto”, rateUsd: “104.0104020958773373” }

あれ、できるやん。つまり、元データから構造体で定義したデータだけ引っこ抜くということが可能だとわかった。
元データと一致していないといけないと思ったんだが、、、　なんのこっちゃ

まずはhashmapから

use std::collections::HashMap;

fn main(){
    let mut map = HashMap::new();
    map.insert("x", 10);
    map.insert("y", 20);
    map.insert("z", 30);
    
    for (k, v) in &map {
        println!("{} {}", k, v);
    }

}

これを構造体で使いたい

#[derive(Debug)]
struct Name {
    name: HashMap<String, String>,
    age: u32,
}

fn main(){
    let mut n = Name { name: HashMap::new(), age: 20 };
    n.name.insert("Yamada".to_string(), "Taro".to_string());
    
    println!("{:?}", n);
}

上記でもできるのはできるけど、一発で書きたい

fromを使えば以下で行ける。

#[derive(Debug)]
struct Name {
    name: HashMap<String, String>,
    age: u32,
}

fn main(){
    let mut n = Name { name: HashMap::from([("yamada".to_string(), "taro".to_string())]), age: 20 };
    println!("{:?}", n);
}

Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.39s
Running `target/debug/sample`
Name { name: {“yamada”: “taro”}, age: 20 }

HashMap::from(“yamada”.to_string(), “taro”.to_string())　だと上手くいかないので注意が必要。セットが一つでも[]で囲ってあげる必要あり。

Pythonで書くとこんな感じ

import requests

def get_bitcoin_price():
    url = 'https://coincheck.com/api/ticker'
    response = requests.get(url)
    data = response.json()
    last_price = data['last']
    return last_price

bitcoin_price = get_bitcoin_price()
print(f"現在のbtc価格: {bitcoin_price} JPY")

これをRustで書く。構造体にしてあげる。

use reqwest::Client;
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Clone, Debug)]
struct Price {
    last: f32,
    bid: f32,
    ask: f32,
    high: f32,
    volume: f32,
    timestamp: u32
} 

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let url = "https://coincheck.com/api/ticker";
    let contents = reqwest::get(url).await?.text().await?;
    println!("{:?}", &contents);
    let res: Price = serde_json::from_str(&contents).unwrap();
    println!("{:?}", res.last);
    Ok(())
}

Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.05s
Running `target/debug/wallet`
“{\”last\”:14905296.0,\”bid\”:14904987.0,\”ask\”:14907006.0,\”high\”:15136729.0,\”low\”:14578786.0,\”volume\”:1207.84604682,\”timestamp\”:1736567711}”
14905296.0

coincheckは日本円なので、USD変換のAPIの方が良いな。かつ、Ethの値も一緒に取れると尚良

use reqwest::Client;
use serde::{Serialize, Deserialize};
use serde_json::{Value};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let url = "https://api.coinbase.com/v2/exchange-rates?currency=BTC";
    let contents = reqwest::get(url).await?.text().await?;
    // println!("{:?}", &contents);
    let res: Value = serde_json::from_str(&contents).unwrap();
    println!("{:?}", res["data"]["rates"]["USD"]);
    Ok(())
}

coinbaseのapiだと、btcもethもusdベースで取得できる。よっしゃああああああああああああ