rust way step 8

use actix_web::{get, post, web, App, Error, HttpResponse, HttpServer, Responder};
use actix_files as fs;
use actix_web::{Result};
use actix_files::NamedFile;
use actix_web::HttpRequest;
use serde::Serialize;
use std::{path::PathBuf, string};
use serde::Deserialize;


#[derive(Serialize,Deserialize)]
struct MyObj {
    name: String,
    sex:i32
}

#[get("/obj/{name}")]
async fn test6(name: web::Path<String>) -> Result<impl Responder> {
    let obj = MyObj {
        name: name.to_string(),
        sex:1
    };
    Ok(web::Json(obj))
}



#[get("/file/{filename:.*}")]
async fn test5(req: HttpRequest) -> actix_web::Result<NamedFile> {
    let path: PathBuf = req.match_info().query("filename").parse().unwrap();
    println!("{}",path.to_str().unwrap());
    println!("当前工作目录是: {:?}", std::env::current_dir());
    Ok(NamedFile::open(path)?)
}

#[get("/users/{user_id}/{friend}")] // <- define path parameters
async fn test2(path: web::Path<(u32, String)>) -> Result<String> {
    let (user_id, friend) = path.into_inner();
    Ok(format!("Welcome {}, user_id {}!", friend, user_id))
}


#[get("/")]
async fn hello() -> impl Responder {
    HttpResponse::Ok().body("Hello world!")
}

#[post("/echo")]
async fn echo(req_body: String) -> impl Responder {
    HttpResponse::Ok().body(req_body)
}

// http://127.0.0.1:8080/echo1?name=sdf&sex=1
#[get("/echo1")]
async fn test1(info: web::Query<MyObj>) -> String {
    format!("Welcome {} {}!", info.name,info.sex)
}

async fn manual_hello() -> impl Responder {
    HttpResponse::Ok().body("iam here!")
}

#[derive(Deserialize)]
struct Info {
    username: String,
    pass:String,
}

/// deserialize `Info` from request's body
#[post("/submit")]
async fn submit(info: web::Json<Info>) ->String{

    let json_data = serde_json::json!({
        "name": info.username,
        "pass": info.pass
    });

    let json_string =serde_json::to_string(&json_data).unwrap();
    format!("Welcome {}!", json_string)
}

async fn index() -> String {
    let data ="Hello world!";
    let base64_str: String = base64::encode(&data);
    return format!("Base64 string: {}", base64_str);
}

use actix::{fut::ok, Actor, StreamHandler};
//use actix_web::{web, App, Error, HttpRequest, HttpResponse, HttpServer};
use actix_web_actors::ws;

/// Define HTTP actor
struct MyWs;

impl Actor for MyWs {
    type Context = ws::WebsocketContext<Self>;
}

/// Handler for ws::Message message
impl StreamHandler<Result<ws::Message, ws::ProtocolError>> for MyWs {
    fn handle(&mut self, msg: Result<ws::Message, ws::ProtocolError>, ctx: &mut Self::Context) {
        match msg {
            Ok(ws::Message::Ping(msg)) => ctx.pong(&msg),
            Ok(ws::Message::Text(text)) => ctx.text(text),
            Ok(ws::Message::Binary(bin)) => ctx.binary(bin),
            _ => (),
        }
    }
}

async fn wstest(req: HttpRequest, stream: web::Payload) -> Result<HttpResponse, Error> {
    let resp = ws::start(MyWs {}, &req, stream);
    println!("{:?}", resp);
    resp
}

use actix_web::middleware::Logger;
use env_logger::Env;


/************************************************************* */
use file_hashing::get_hash_file;
use md5::Md5;
use sha1::{Digest, Sha1};

use std::path::Path;

pub fn test_md5<P: AsRef<Path>>(path: P) -> Result<String, std::io::Error> {
    let mut hasher = Md5::new();
    get_hash_file(path, &mut hasher)
}

pub fn test_sha1<P: AsRef<Path>>(path: P) -> Result<String, std::io::Error> {
    let mut hasher = Sha1::new();
    get_hash_file(path, &mut hasher)
}




#[actix_web::main]
async fn main() -> std::io::Result<()> {


    let path = std::env::current_dir().unwrap().join("2.jpg");

    let actual = test_md5(path.clone());
    if let Ok(a)=actual{
        println!("md5 {}",a);
    }
   
    let actual = test_sha1(path).unwrap();
    println!("sha1 {}",actual);

    env_logger::init_from_env(Env::default().default_filter_or("info"));

    HttpServer::new(|| {
        App::new()
            .wrap(Logger::default())
            .wrap(Logger::new("%a i"))
            .service(hello)
            .service(echo)
            .service(submit)
            .service(test2)
            .service(test1)
            .service(test6)
            .service(test5)
            .service(fs::Files::new("/static", "./static")
            .show_files_listing()
            .use_last_modified(true))
            .route("/hi", web::get().to(manual_hello))
            .service(
                web::scope("/app")  
                .route("/index.html", web::get().to(index)),
            )
            .route("/ws/", web::get().to(wstest))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

[package]

name = "hello-dioxus"

version = "0.1.0"

edition = "2021"

[dependencies]

reqwest = "0.12.5"

tokio = { version = "1.0.0", features = ["full"] }

actix-web = "4"

actix-files ="0.6.6"

serde = { version = "1.0", features = ["derive"] }

serde_json = "1.0"

env_logger ="0.11.3"

actix-web-actors ="4.3.0"

actix="0.13.5"

base64 = "=0.22.1"

file-hashing = "0.1.2"

md-5 = "0.10.6"

sha1 = "0.10.6"