bc_web/

main.rs

//!
//! Main Web runner for the Blockchain Application.<br>
//! Function main.<br>
//! List, transact and reset the blockchain sample application.
//!

use actix_web::web::Json;
use actix_web::{middleware::Logger, web, App, HttpResponse, HttpServer, Responder};
use actix_web::{Error, HttpRequest};
use actix_web_actors::ws;
use bc_db::mongo_utils;
use bc_utils::{utils, wsactor};
use block_chain::blockchain::Blockchain;
use block_chain::wallet::Wallet;
use bson::Document;
use env_logger;
use include_dir::{include_dir, Dir};
use mime_guess;
use mongodb::{Client, Collection};
use serde::{Deserialize, Serialize};
use serde_json::json;
use std::collections::HashMap;
use std::sync::Mutex;

///
/// Struct SendCryptoRequest.
///
#[derive(Serialize, Deserialize)]
struct SendCryptoRequest {
    address_s: String,
    address_r: String,
    amount: f64,
    fee: f64,
}

///
/// Struct AppState.
///
struct AppState {
    blockchain: Mutex<Blockchain>,
    blocks_collection: Collection<Document>,
    wallets_collection: Collection<Document>,
    blockchain_collection: Collection<Document>,
}

///
/// List the blockchain.
///
async fn list_blockchain(data: web::Data<AppState>) -> impl Responder {
    // Load blockchain from database
    let blockchain = mongo_utils::load_blockchain(
        data.blocks_collection.clone(),
        data.blockchain_collection.clone(),
    )
    .await
    .unwrap();

    let output = utils::list_blockchain(&blockchain);
    HttpResponse::Ok()
        .content_type("application/json") // Ensure the content type is JSON
        .body(output)
    // HttpResponse::Ok().body(output)
    // HttpResponse::Ok().json(&*blockchain)
}

///
/// Get the wallet address.
///
async fn get_wallet_addresses(data: web::Data<AppState>) -> Json<Vec<String>> {
    Json(utils::get_wallet_addresses(&data.wallets_collection).await)
}

///
/// Get pending transactions.
///
async fn get_pending_transactions(data: web::Data<AppState>) -> Json<Vec<String>> {
    Json(utils::get_pending_transactions(&data.wallets_collection).await)
}

///
/// Get previous hash.
///
async fn get_previous_hash(data: web::Data<AppState>) -> String {
    utils::get_previous_hash(&data.blocks_collection, &data.blockchain_collection).await
}

///
/// Display wallet details.
///
async fn view_wallet(
    data: web::Data<AppState>,
    query: web::Query<std::collections::HashMap<String, String>>,
) -> impl Responder {
    let wallets_collection = data.wallets_collection.clone();
    let mut wallet_map: HashMap<String, Wallet> = Result::expect(
        mongo_utils::load_wallets(wallets_collection.clone()).await,
        "Could not get wallets data",
    );

    let address = query.get("address").unwrap_or(&String::new()).to_string();

    let wallet = wallet_map
        .remove(&address)
        .expect("Sender wallet not found");

    let output = utils::view_wallet(&wallet, &wallet.address);

    HttpResponse::Ok()
        .content_type("application/json") // Ensure the content type is JSON
        .body(output)
}

///
/// Send crypto one wallet to another.
///
async fn send_crypto(
    data: web::Data<AppState>,
    req: web::Json<SendCryptoRequest>,
    // wallet_id: web::Path<u8>,
) -> impl Responder {
    let blocks_collection = data.blocks_collection.clone();
    let wallets_collection = data.wallets_collection.clone();
    let blockchain_collection = data.blockchain_collection.clone();
    //let mut blockchain = data.blockchain.lock().unwrap();

    // Load blockchain from database
    let mut blockchain = mongo_utils::load_blockchain(
        data.blocks_collection.clone(),
        data.blockchain_collection.clone(),
    )
    .await
    .unwrap();

    let mut wallet_map: HashMap<String, Wallet> = Result::expect(
        mongo_utils::load_wallets(wallets_collection.clone()).await,
        "Could not get wallets data",
    );

    let mut wallet1 = wallet_map
        .remove(&req.address_s)
        .expect("Sender wallet not found");
    let mut wallet2 = wallet_map
        .remove(&req.address_r)
        .expect("Receiver wallet not found");

    let txn_result = utils::send_crypto(
        req.amount,
        req.fee,
        &mut blockchain,
        &mut wallet1,
        &mut wallet2,
        blocks_collection,
        wallets_collection,
        blockchain_collection,
    )
    .await;

    // HttpResponse::Ok().json(&*blockchain)
    let response = json!({
        "message": "Send Crypto...",
        "response": txn_result.unwrap()
    });
    HttpResponse::Ok().json(response)
    // HttpResponse::Ok().body(txn_result.unwrap())
}

///
/// Mine a pending transaction.
///
async fn mine_trxn(
    // data: web::Data<AppState>,
    query: web::Query<std::collections::HashMap<String, String>>,
) -> impl Responder {
    let transaction_str = query.get("tx_id").unwrap_or(&String::new()).to_string();
    println!("string is {transaction_str}");

    let tx_id = transaction_str
        .split(',')
        .nth(0)
        .and_then(|s| s.split(':').nth(1))
        .unwrap_or("tx_id not found")
        .replace('"', "")
        .trim()
        .to_string();

    println!("tx_id = {}", tx_id);

    let mut response = String::from("");
    if tx_id.clone() == String::from("tx_id not found") {
        response = String::from("No transaction to process!");
    }
    // } else {
    //     let blocks_collection = data.blocks_collection.clone();
    //     let blockchain_collection = data.blockchain_collection.clone();

    //     utils::mine_crypto(blocks_collection, blockchain_collection).await;
    // }

    HttpResponse::Ok().body(response)
}

///
/// Save mined transaction to database.
///
async fn commit_mine_trxn(
    data: web::Data<AppState>,
    query: web::Query<std::collections::HashMap<String, String>>,
) -> impl Responder {
    let transaction_str = query.get("tx_id").unwrap_or(&String::new()).to_string();
    println!("string is {transaction_str}");

    let tx_id = transaction_str
        .split(',')
        .nth(0)
        .and_then(|s| s.split(':').nth(1))
        .unwrap_or("tx_id not found")
        .replace('"', "")
        .trim()
        .to_string();

    let blocks_collection = data.blocks_collection.clone();
    let blockchain_collection = data.blockchain_collection.clone();
    let wallets_collection = data.wallets_collection.clone();

    let response = utils::commit_mine_crypto(
        tx_id.clone(),
        blocks_collection,
        blockchain_collection,
        wallets_collection,
    )
    .await;

    // HttpResponse::Ok().json(response)
    HttpResponse::Ok()
        .content_type("application/json") // Ensure the content type is JSON
        .body(response)
}

///
/// Reset sample data to genesis block.
///
async fn reset_sample_data(data: web::Data<AppState>) -> impl Responder {
    let result = utils::reset_sample_data(
        &data.blocks_collection,
        &data.wallets_collection,
        &data.blockchain_collection,
    )
    .await;

    let new_blockchain = mongo_utils::load_blockchain(
        data.blocks_collection.clone(),
        data.blockchain_collection.clone(),
    )
    .await
    .unwrap();

    // Update the in-memory state
    let mut blockchain = data.blockchain.lock().unwrap();
    *blockchain = new_blockchain;

    println!("{:?}", result);
    HttpResponse::Ok().body("Sample data has been reset and loaded")
}

///
/// Start web socket for mining transaction.
///
async fn websocket_handler(req: HttpRequest, stream: web::Payload) -> Result<HttpResponse, Error> {
    let mining_actor = wsactor::MiningProgressWebSocket::new("".to_string(), "".to_string(), 0);
    ws::start(mining_actor, &req, stream)
}

///
/// Path definition to static file location.
///
static STATIC_DIR: Dir<'_> = include_dir!("$CARGO_MANIFEST_DIR/static");

///
/// Index page for the server.
///
async fn index() -> impl Responder {
    HttpResponse::Ok()
        .content_type("text/html")
        .body(include_str!("../static/pages/index.html"))
}

///
/// Function to server static files.
///
async fn serve_static_file(path: web::Path<(String,)>) -> impl Responder {
    let path = &path.into_inner().0;
    if let Some(file) = STATIC_DIR.get_file(path) {
        let mime_type = mime_guess::from_path(path).first_or_octet_stream();
        HttpResponse::Ok()
            .content_type(mime_type)
            .body(file.contents())
    } else {
        HttpResponse::NotFound().body("File not found")
    }
}

///
/// Function main for the Web blockchain application.
///
#[actix_web::main]
async fn main() -> std::io::Result<()> {
    // Initialize the logger
    env_logger::init();
    println!("Starting server...");

    // Initialize MongoDB client
    let client = Client::with_uri_str("mongodb://localhost:27017")
        .await
        .unwrap();
    let db = client.database("blockchain_db");

    let blocks_collection = db.collection("blocks");
    let wallets_collection = db.collection("wallets");
    let blockchain_collection = db.collection("blockchain");

    // Load blockchain from database
    let blockchain =
        mongo_utils::load_blockchain(blocks_collection.clone(), blockchain_collection.clone())
            .await
            .unwrap();

    // Initialize web app data
    let app_data = web::Data::new(AppState {
        blockchain: Mutex::new(blockchain),
        blocks_collection,
        wallets_collection,
        blockchain_collection,
    });

    // Setup, start and bind Rust server to 8088
    HttpServer::new(move || {
        App::new()
            .wrap(Logger::default())
            .app_data(app_data.clone())
            .route("/blockchain", web::get().to(list_blockchain))
            .route("/wallets", web::get().to(get_wallet_addresses))
            .route("/phash", web::get().to(get_previous_hash))
            .route("/wallet", web::get().to(view_wallet))
            .route("/send_crypto/{id}", web::post().to(send_crypto))
            .route("pendingTxnxs", web::get().to(get_pending_transactions))
            .route("/mining", web::get().to(mine_trxn))
            .route("/commit_mining", web::get().to(commit_mine_trxn))
            .route("/ws", web::get().to(websocket_handler))
            .route("/reset_sample_data", web::post().to(reset_sample_data))
            .route("/", web::get().to(index))
            .route("/static/{filename:.*}", web::get().to(serve_static_file))
    })
    .bind("0.0.0.0:8088")?
    .run()
    .await
}