repo stringlengths 6 65 | file_url stringlengths 81 311 | file_path stringlengths 6 227 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 7
values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-04 15:31:58 2026-01-04 20:25:31 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/json_serialization/login.rs | chapter12/setting_up_the_server/web_app/src/json_serialization/login.rs | use serde::Deserialize;
#[derive(Deserialize)]
pub struct Login {
pub username: String,
pub password: String
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/json_serialization/mod.rs | chapter12/setting_up_the_server/web_app/src/json_serialization/mod.rs | pub mod to_do_items;
pub mod to_do_item;
pub mod new_user;
pub mod login;
pub mod login_response;
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/json_serialization/new_user.rs | chapter12/setting_up_the_server/web_app/src/json_serialization/new_user.rs | use serde::Deserialize;
#[derive(Deserialize)]
pub struct NewUserSchema {
pub name: String,
pub email: String,
pub password: String
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/models/mod.rs | chapter12/setting_up_the_server/web_app/src/models/mod.rs | pub mod item;
pub mod user;
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/models/user/user.rs | chapter12/setting_up_the_server/web_app/src/models/user/user.rs | extern crate bcrypt;
use diesel::{Queryable, Identifiable};
use bcrypt::verify;
use crate::schema::users;
#[derive(Queryable, Clone, Identifiable)]
#[table_name="users"]
pub struct User {
pub id: i32,
pub username: String,
pub email: String,
pub password: String,
pub unique_id: String
}
impl User {
pub fn verify(self, password: String) -> bool {
return verify(password.as_str(),
&self.password).unwrap()
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/models/user/mod.rs | chapter12/setting_up_the_server/web_app/src/models/user/mod.rs | pub mod user;
pub mod new_user;
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/models/user/new_user.rs | chapter12/setting_up_the_server/web_app/src/models/user/new_user.rs | extern crate bcrypt;
use uuid::Uuid;
use diesel::Insertable;
use bcrypt::{DEFAULT_COST, hash};
use crate::schema::users;
#[derive(Insertable, Clone)]
#[table_name="users"]
pub struct NewUser {
pub username: String,
pub email: String,
pub password: String,
pub unique_id: String,
}
impl NewUser {
pub fn new(username: String, email: String, password: String) -> NewUser {
let hashed_password: String = hash(password.as_str(), DEFAULT_COST).unwrap();
let uuid = Uuid::new_v4().to_string();
return NewUser {username, email, password: hashed_password, unique_id: uuid}
}
} | rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/models/item/mod.rs | chapter12/setting_up_the_server/web_app/src/models/item/mod.rs | pub mod new_item;
pub mod item;
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/models/item/item.rs | chapter12/setting_up_the_server/web_app/src/models/item/item.rs | use crate::schema::to_do;
use chrono::NaiveDateTime;
use super::super::user::user::User;
#[derive(Queryable, Identifiable, Associations)]
#[belongs_to(User)]
#[table_name="to_do"]
pub struct Item {
pub id: i32,
pub title: String,
pub status: String,
pub date: NaiveDateTime,
pub user_id: i32,
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/models/item/new_item.rs | chapter12/setting_up_the_server/web_app/src/models/item/new_item.rs | use crate::schema::to_do;
use chrono::{NaiveDateTime, Utc};
#[derive(Insertable)]
#[table_name="to_do"]
pub struct NewItem {
pub title: String,
pub status: String,
pub date: NaiveDateTime,
pub user_id: i32,
}
impl NewItem {
pub fn new(title: String, user_id: i32) -> NewItem {
let now = Utc::now().naive_local();
return NewItem{title, status: String::from("PENDING"), date: now, user_id}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/views/mod.rs | chapter12/setting_up_the_server/web_app/src/views/mod.rs | mod auth;
mod to_do;
mod app;
mod users;
use auth::auth_views_factory;
use to_do::to_do_views_factory;
use app::app_views_factory;
use users::user_views_factory;
use actix_web::web::ServiceConfig;
/// Connects the server to the views being created.
///
/// # Arguments
/// * app: (&mut ServiceConfig) enabling the application configuration to be bound to the view factories
pub fn views_factory(app: &mut ServiceConfig) {
auth_views_factory(app);
to_do_views_factory(app);
app_views_factory(app);
user_views_factory(app);
} | rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/views/auth/login.rs | chapter12/setting_up_the_server/web_app/src/views/auth/login.rs | use crate::diesel;
use diesel::prelude::*;
use actix_web::{web, HttpResponse, http::header::ContentType, };
use crate::database::DB;
use crate::models::user::user::User;
use crate::json_serialization::{login::Login, login_response::LoginResponse};
use crate::schema::users;
use crate::jwt::JwToken;
pub async fn login(credentials: web::Json<Login>, db: DB) -> HttpResponse {
let username: String = credentials.username.clone();
let password: String = credentials.password.clone();
let users = users::table
.filter(users::columns::username.eq(username.as_str()))
.load::<User>(&db.connection).unwrap();
if users.len() == 0 {
return HttpResponse::NotFound().await.unwrap()
} else if users.len() > 1 {
return HttpResponse::Conflict().await.unwrap()
}
match users[0].clone().verify(password) {
true => {
let user_id = users[0].clone().id;
let token = JwToken::new(user_id);
let raw_token = token.encode();
let response = LoginResponse{token: raw_token.clone()};
let body = serde_json::to_string(&response).unwrap();
HttpResponse::Ok().append_header(("token", raw_token))
.content_type(ContentType::json())
.body(body)
},
false => HttpResponse::Unauthorized().await.unwrap()
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/views/auth/mod.rs | chapter12/setting_up_the_server/web_app/src/views/auth/mod.rs | mod login;
mod logout;
use actix_web::web::{ServiceConfig, get, post, scope};
use actix_web::Responder;
pub async fn ping() -> impl Responder {
"ping"
}
pub fn auth_views_factory(app: &mut ServiceConfig) {
app.service(
scope("v1/auth")
.route("login", get().to(login::login))
.route("login", post().to(login::login))
.route("logout", get().to(logout::logout))
.route("ping", get().to(ping))
);
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/views/auth/logout.rs | chapter12/setting_up_the_server/web_app/src/views/auth/logout.rs | use actix_web::HttpResponse;
pub async fn logout() -> HttpResponse {
HttpResponse::Ok()
.content_type("text/html; charset=utf-8")
.body("<html>\
<script>\
localStorage.removeItem('user-token'); \
window.location.replace(
document.location.origin);\
</script>\
</html>")
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/views/app/items.rs | chapter12/setting_up_the_server/web_app/src/views/app/items.rs | use actix_web::HttpResponse;
use super::content_loader::read_file;
use super::content_loader::add_component;
pub async fn items() -> HttpResponse {
let mut html_data = read_file(
"./templates/main.html");
let javascript_data: String = read_file(
"./javascript/main.js");
let css_data: String = read_file(
"./css/main.css");
let base_css_data: String = read_file(
"./css/base.css");
html_data = html_data.replace("{{JAVASCRIPT}}",
&javascript_data);
html_data = html_data.replace("{{CSS}}",
&css_data);
html_data = html_data.replace("{{BASE_CSS}}",
&base_css_data);
html_data = add_component(String::from("header"),
html_data);
HttpResponse::Ok()
.content_type("text/html; charset=utf-8")
.body(html_data)
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/views/app/content_loader.rs | chapter12/setting_up_the_server/web_app/src/views/app/content_loader.rs | use std::fs;
pub fn read_file(file_path: &str) -> String {
let data: String = fs::read_to_string(
file_path).expect("Unable to read file");
return data
}
pub fn add_component(component_tag: String, html_data: String) -> String {
let css_tag: String = component_tag.to_uppercase() + &String::from("_CSS");
let html_tag: String = component_tag.to_uppercase() + &String::from("_HTML");
let css_path = String::from("./templates/components/") + &component_tag.to_lowercase() + &String::from(".css");
let css_loaded = read_file(&css_path);
let html_path = String::from("./templates/components/") + &component_tag.to_lowercase() + &String::from(".html");
let html_loaded = read_file(&html_path);
let html_data = html_data.replace(html_tag.as_str(), &html_loaded);
let html_data = html_data.replace(css_tag.as_str(), &css_loaded);
return html_data
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/views/app/mod.rs | chapter12/setting_up_the_server/web_app/src/views/app/mod.rs | use actix_web::web;
mod items;
mod content_loader;
pub fn app_views_factory(app: &mut web::ServiceConfig) {
app.route("/", web::get().to(items::items));
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/views/users/mod.rs | chapter12/setting_up_the_server/web_app/src/views/users/mod.rs | mod create;
use actix_web::web::{ServiceConfig, post, scope};
pub fn user_views_factory(app: &mut ServiceConfig) {
app.service(
scope("v1/user")
.route("create", post().to(create::create))
);
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/views/users/create.rs | chapter12/setting_up_the_server/web_app/src/views/users/create.rs | use crate::diesel;
use diesel::prelude::*;
use actix_web::{web, HttpResponse};
use crate::database::DB;
use crate::json_serialization::new_user::NewUserSchema;
use crate::models::user::new_user::NewUser;
use crate::schema::users;
pub async fn create(new_user: web::Json<NewUserSchema>, db: DB) -> HttpResponse {
let name: String = new_user.name.clone();
let email: String = new_user.email.clone();
let password: String = new_user.password.clone();
let new_user = NewUser::new(name, email, password);
let insert_result = diesel::insert_into(users::table).values(&new_user).execute(&db.connection);
match insert_result {
Ok(_) => HttpResponse::Created().await.unwrap(),
Err(_) => HttpResponse::Conflict().await.unwrap()
}
} | rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/views/to_do/mod.rs | chapter12/setting_up_the_server/web_app/src/views/to_do/mod.rs | mod create;
mod get;
mod edit;
mod delete;
use actix_web::web::{ServiceConfig, post, get, scope};
pub fn to_do_views_factory(app: &mut ServiceConfig) {
app.service(
scope("v1/item")
.route("create/{title}", post().to(create::create))
.route("get", get().to(get::get))
.route("edit", post().to(edit::edit))
.route("delete", post().to(delete::delete))
);
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/views/to_do/edit.rs | chapter12/setting_up_the_server/web_app/src/views/to_do/edit.rs | use crate::diesel;
use diesel::prelude::*;
use actix_web::{web, HttpResponse};
use crate::json_serialization::{to_do_item::ToDoItem, to_do_items::ToDoItems};
use crate::jwt::JwToken;
use crate::schema::to_do;
use crate::database::DB;
pub async fn edit(to_do_item: web::Json<ToDoItem>, token: JwToken, db: DB) -> HttpResponse {
let results = to_do::table.filter(to_do::columns::title
.eq(&to_do_item.title)).filter(to_do::columns::user_id.eq(&token.user_id));
let _ = diesel::update(results)
.set(to_do::columns::status.eq("DONE"))
.execute(&db.connection);
return HttpResponse::Ok().json(ToDoItems::get_state(token.user_id))
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/views/to_do/create.rs | chapter12/setting_up_the_server/web_app/src/views/to_do/create.rs | use crate::diesel;
use diesel::prelude::*;
use actix_web::HttpResponse;
use actix_web::HttpRequest;
use crate::json_serialization::to_do_items::ToDoItems;
use crate::database::DB;
use crate::models::item::new_item::NewItem;
use crate::models::item::item::Item;
use crate::schema::to_do;
use crate::jwt::JwToken;
/// Creates a to-do item storing it in the state.json file.
pub async fn create(token: JwToken, req: HttpRequest, db: DB) -> HttpResponse {
let title: String = req.match_info().get("title"
).unwrap().to_string();
let items = to_do::table
.filter(to_do::columns::title.eq(&title.as_str()))
.order(to_do::columns::id.asc())
.load::<Item>(&db.connection)
.unwrap();
if items.len() == 0 {
let new_post = NewItem::new(title, token.user_id);
let _ = diesel::insert_into(to_do::table).values(&new_post)
.execute(&db.connection);
}
return HttpResponse::Ok().json(ToDoItems::get_state(token.user_id))
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/views/to_do/get.rs | chapter12/setting_up_the_server/web_app/src/views/to_do/get.rs | use actix_web::Responder;
use crate::json_serialization::to_do_items::ToDoItems;
use crate::jwt::JwToken;
pub async fn get(token: JwToken) -> impl Responder {
return ToDoItems::get_state(token.user_id);
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/views/to_do/delete.rs | chapter12/setting_up_the_server/web_app/src/views/to_do/delete.rs | use crate::diesel;
use diesel::prelude::*;
use actix_web::{web, HttpResponse};
use crate::database::DB;
use crate::schema::to_do;
use crate::json_serialization::{to_do_item::ToDoItem,
to_do_items::ToDoItems};
use crate::jwt::JwToken;
use crate::models::item::item::Item;
pub async fn delete(to_do_item: web::Json<ToDoItem>, token: JwToken, db: DB) -> HttpResponse {
let items = to_do::table
.filter(to_do::columns::title.eq(&to_do_item.title.as_str()))
.filter(to_do::columns::user_id.eq(&token.user_id))
.order(to_do::columns::id.asc())
.load::<Item>(&db.connection)
.unwrap();
let _ = diesel::delete(&items[0]).execute(&db.connection);
return HttpResponse::Ok().json(ToDoItems::get_state(token.user_id))
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/to_do/enums.rs | chapter12/setting_up_the_server/web_app/src/to_do/enums.rs | use serde::ser::{Serialize, Serializer};
/// This Enum is responsible for defining the current status of a task.
///
/// # Attributes
/// * DONE: when the task is finished
/// * PENDING: when the task is waiting to be finished
#[derive(Clone, Eq, Debug)]
pub enum TaskStatus {
DONE,
PENDING
}
impl TaskStatus {
/// turns the TaskStatus enum into a string.
///
/// # Returns
/// * (String): the status of the task
pub fn stringify(&self) -> String {
match &self {
&Self::DONE => {return "DONE".to_string()},
&Self::PENDING => {return "PENDING".to_string()}
}
}
pub fn new(status: &str) -> TaskStatus {
match status {
"DONE" => {return TaskStatus::DONE},
"PENDING" => {return TaskStatus::PENDING},
_ => {panic!("{} not supported", status)}
}
}
}
impl Serialize for TaskStatus {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
Ok(serializer.serialize_str(&self.stringify().as_str())?)
}
}
impl PartialEq for TaskStatus {
fn eq(&self, other: &Self) -> bool {
match self {
TaskStatus::DONE => {
match other {
&TaskStatus::DONE => return true,
&TaskStatus::PENDING => false
}
},
TaskStatus::PENDING => {
match other {
&TaskStatus::DONE => return false,
&TaskStatus::PENDING => true
}
}
}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/to_do/mod.rs | chapter12/setting_up_the_server/web_app/src/to_do/mod.rs | pub mod structs;
pub mod enums;
use enums::TaskStatus;
use structs::done::Done;
use structs::pending::Pending;
/// This struct is responsible for packaging to-do structs to be returned.
///
/// # Attributes
/// * Pending (Pending): a pending item struct
/// * Done (Done): a done item struct
pub enum ItemTypes {
Pending(Pending),
Done(Done)
}
/// This function builds to-do structs based on the status passed in.
///
/// # Arguments
/// * title (&str): the title for the to do item to be made
/// * status (TaskStatus): the type of status for the to-do item being created
pub fn to_do_factory(title: &str, status: TaskStatus) -> ItemTypes {
match status {
TaskStatus::DONE => {
return ItemTypes::Done(Done::new(title))
},
TaskStatus::PENDING => {
return ItemTypes::Pending(Pending::new(title))
}
}
} | rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/to_do/structs/pending.rs | chapter12/setting_up_the_server/web_app/src/to_do/structs/pending.rs | use super::base::Base;
use super::super::enums::TaskStatus;
/// This struct is responsible for defing a task that is yet to be completed.
///
/// # Attributes
/// * super_struct (Base): the super struct that hosts the core functionality and fields
pub struct Pending {
pub super_struct: Base
}
impl Pending {
/// The constructor for the Done struct.
///
/// # Arguements
/// * input_title (&str): the title of the pending task being created
///
/// # Returns
/// (Pending): the constructed struct
pub fn new(input_title: &str) -> Pending {
let base = Base::new(input_title,
TaskStatus::PENDING);
return Pending{super_struct: base}
}
}
#[cfg(test)]
mod pending_tests {
use super::Pending;
use super::TaskStatus;
#[test]
fn new() {
let new_base_struct = Pending::new("test title");
assert_eq!(String::from("test title"), new_base_struct.super_struct.title);
assert_eq!(TaskStatus::PENDING, new_base_struct.super_struct.status);
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/to_do/structs/base.rs | chapter12/setting_up_the_server/web_app/src/to_do/structs/base.rs | use super::super::enums::TaskStatus;
use serde::Serialize;
/// This is the base struct to act as inheritance by composition for other structs.
///
/// # Attributes
/// * title (String): the title of the task
/// * status (TaskStatus): the status of the task
#[derive(Serialize)]
pub struct Base {
pub title: String,
pub status: TaskStatus
}
impl Base {
/// The constructor for the Base struct.
///
/// # Arguments
/// * input_title (&str): the title of the task being created
/// * input_status (TaskStatus): the status of the task being created
///
/// # Returns
/// * (Base): the constructed base
pub fn new(input_title: &str, input_status: TaskStatus) -> Base {
return Base {
title: input_title.to_string(),
status: input_status
}
}
}
#[cfg(test)]
mod base_tests {
use super::Base;
use super::TaskStatus;
#[test]
fn new() {
let expected_title = String::from("test title");
let expected_status = TaskStatus::DONE;
let status = TaskStatus::DONE;
let new_base_struct = Base::new("test title", status);
assert_eq!(expected_title, new_base_struct.title);
assert_eq!(expected_status, new_base_struct.status);
}
} | rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/to_do/structs/mod.rs | chapter12/setting_up_the_server/web_app/src/to_do/structs/mod.rs | pub mod base;
pub mod done;
pub mod pending;
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter12/setting_up_the_server/web_app/src/to_do/structs/done.rs | chapter12/setting_up_the_server/web_app/src/to_do/structs/done.rs | use super::base::Base;
use super::super::enums::TaskStatus;
/// This struct is responsible for defing a completed task.
///
/// # Attributes
/// * super_struct (Base): the super struct that hosts the core functionality and fields
pub struct Done {
pub super_struct: Base
}
impl Done {
/// The constructor for the Done struct.
///
/// # Arguements
/// * input_title (&str): the title of the completed task being created
///
/// # Returns
/// (Done): the constructed struct
pub fn new(input_title: &str) -> Done {
let base = Base::new(input_title,
TaskStatus::DONE);
return Done{super_struct: base}
}
}
#[cfg(test)]
mod done_tests {
use super::Done;
use super::TaskStatus;
#[test]
fn new() {
let new_base_struct = Done::new("test title");
assert_eq!(String::from("test title"), new_base_struct.super_struct.title);
assert_eq!(TaskStatus::DONE, new_base_struct.super_struct.status);
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter15/accepting_tcp/server/src/main.rs | chapter15/accepting_tcp/server/src/main.rs | use tokio::net::TcpListener;
use std::{thread, time};
#[tokio::main]
async fn main() {
let addr = "127.0.0.1:8080".to_string();
let mut socket = TcpListener::bind(&addr).await.unwrap();
println!("Listening on: {}", addr);
while let Ok((mut stream, peer)) = socket.accept().await {
println!("Incoming connection from: {}", peer.to_string());
tokio::spawn(async move {
println!("thread starting {} starting", peer.to_string());
let five_seconds = time::Duration::from_secs(5);
let begin = time::Instant::now();
tokio::time::sleep(five_seconds);
let end = begin.elapsed();
println!("thread {} finishing {}", peer.to_string(),
end.as_secs_f32());
});
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter15/accepting_tcp/client/src/main.rs | chapter15/accepting_tcp/client/src/main.rs | use tokio::net::TcpStream;
use tokio::io::AsyncWriteExt;
use std::error::Error;
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
println!("stream starting");
stream.write_all(b"hello world").await?;
println!("stream finished");
Ok(())
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter15/keeping_track_of_orders_with_actors/server/src/actors.rs | chapter15/keeping_track_of_orders_with_actors/server/src/actors.rs | use tokio::sync::{mpsc, oneshot, mpsc::Sender};
#[derive(Debug)]
pub struct Message {
pub order: String,
pub ticker: String,
pub amount: f32,
pub respond_to: oneshot::Sender<u32>
}
pub struct OrderBookActor {
pub receiver: mpsc::Receiver<Message>,
pub total_invested: f32,
pub investment_cap: f32
}
impl OrderBookActor {
pub fn new(receiver: mpsc::Receiver<Message>, investment_cap: f32) -> Self {
return OrderBookActor { receiver, total_invested: 0.0, investment_cap }
}
fn handle_message(&mut self, message: Message) {
if message.amount + self.total_invested >= self.investment_cap {
println!("rejecting purchase, total invested: {}", self.total_invested);
let _ = message.respond_to.send(0);
} else {
self.total_invested += message.amount;
println!("processing purchase, total invested: {}", self.total_invested);
let _ = message.respond_to.send(1);
}
}
pub async fn run(mut self) {
println!("actor is running");
while let Some(msg) = self.receiver.recv().await {
self.handle_message(msg);
}
}
}
pub struct BuyOrder {
pub ticker: String,
pub amount: f32,
pub order: String,
pub sender: Sender<Message>
}
impl BuyOrder {
pub fn new(amount: f32, ticker: String, sender: Sender<Message>) -> Self {
return BuyOrder { ticker, amount, order: "buy".to_owned(), sender }
}
pub async fn send(self) {
let (send, recv) = oneshot::channel();
let message = Message { order: self.order, amount: self.amount, ticker: self.ticker, respond_to: send};
let _ = self.sender.send(message).await;
match recv.await {
Err(e) => println!("{}", e),
Ok(outcome) => println!("here is the outcome: {}", outcome)
}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter15/keeping_track_of_orders_with_actors/server/src/main.rs | chapter15/keeping_track_of_orders_with_actors/server/src/main.rs | use tokio::net::TcpListener;
use std::{thread, time};
use tokio::io::{BufReader, AsyncBufReadExt, AsyncWriteExt};
use tokio::sync::mpsc;
mod actors;
use actors::{OrderBookActor, BuyOrder, Message};
#[tokio::main]
async fn main() {
let addr = "127.0.0.1:8080".to_string();
let mut socket = TcpListener::bind(&addr).await.unwrap();
println!("Listening on: {}", addr);
let (tx, rx) = mpsc::channel::<Message>(1);
tokio::spawn(async move {
let order_book_actor = OrderBookActor::new(rx, 20.0);
order_book_actor.run().await;
});
println!("order book running now");
while let Ok((mut stream, peer)) = socket.accept().await {
println!("Incoming connection from: {}", peer.to_string());
let tx_one = tx.clone();
tokio::spawn(async move {
println!("thread starting {} starting", peer.to_string());
let (reader, mut writer) = stream.split();
let mut buf_reader = BufReader::new(reader);
let mut buf = vec![];
loop {
match buf_reader.read_until(b'\n', &mut buf).await {
Ok(n) => {
if n == 0 {
println!("EOF received");
break;
}
let buf_string = String::from_utf8_lossy(&buf);
let data: Vec<String> = buf_string.split(";").map(|x| x.to_string()
.replace("\n", ""))
.collect();
let amount = data[0].parse::<f32>().unwrap();
let order_actor = BuyOrder::new(amount, data[1].clone(), tx_one.clone());
println!("{}: {}", order_actor.ticker, order_actor.amount);
order_actor.send().await;
buf.clear();
},
Err(e) => println!("Error receiving message: {}", e)
}
}
println!("thread {} finishing", peer.to_string());
});
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter15/keeping_track_of_orders_with_actors/server/src/order_tracker.rs | chapter15/keeping_track_of_orders_with_actors/server/src/order_tracker.rs | use tokio::sync::{mpsc, oneshot};
use std::collections::HashMap;
#[derive(Debug, Clone)]
pub enum Order {
BUY(String, f32),
GET
}
pub struct TrackerMessage {
pub command: Order,
pub respond_to: oneshot::Sender<String>
}
pub struct GetTrackerActor {
pub sender: mpsc::Sender<TrackerMessage>
}
impl GetTrackerActor {
pub async fn send(self) -> String {
println!("GET function firing");
let (send, recv) = oneshot::channel();
let message = TrackerMessage {
command: Order::GET,
respond_to: send
};
let _ = self.sender.send(message).await;
match recv.await {
Err(e) => panic!("{}", e),
Ok(outcome) => return outcome
}
}
}
pub struct TrackerActor {
pub receiver: mpsc::Receiver<TrackerMessage>,
pub db: HashMap<String, f32>
}
impl TrackerActor {
pub fn new(receiver: mpsc::Receiver<TrackerMessage>) -> Self {
TrackerActor {
receiver,
db: HashMap::new(),
}
}
fn send_state(&self, respond_to: oneshot::Sender<String>) {
let mut buffer = Vec::new();
for key in self.db.keys() {
let amount = self.db.get(key).unwrap();
buffer.push(format!("{}:{ };", &key, amount));
}
buffer.push("\n".to_string());
println!("sending state: {}", buffer.join(""));
respond_to.send(buffer.join(""));
}
fn handle_message(&mut self, message: TrackerMessage) {
match message.command {
Order::GET => {
println!("getting state");
self.send_state(message.respond_to);
},
Order::BUY(ticker, amount) => {
match self.db.get(&ticker) {
Some(ticker_amount) => {
self.db.insert(ticker, ticker_amount + amount);
},
None => {
self.db.insert(ticker, amount);
}
}
println!("db: {:?}", self.db);
}
}
}
pub async fn run(mut self) {
println!("tracker actor is running");
while let Some(msg) = self.receiver.recv().await {
self.handle_message(msg);
}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter15/keeping_track_of_orders_with_actors/client/src/main.rs | chapter15/keeping_track_of_orders_with_actors/client/src/main.rs | use tokio::net::TcpStream;
use tokio::io::AsyncWriteExt;
use std::error::Error;
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
println!("stream starting");
stream.write_all(b"8.0;BYND;\n9.0;PLTR").await?;
println!("stream finished");
Ok(())
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter15/passing_tcp_to_an_actor/server/src/actors.rs | chapter15/passing_tcp_to_an_actor/server/src/actors.rs | use tokio::sync::{mpsc, oneshot, mpsc::Sender};
#[derive(Debug)]
pub struct Message {
pub order: String,
pub ticker: String,
pub amount: f32,
pub respond_to: oneshot::Sender<u32>
}
pub struct OrderBookActor {
pub receiver: mpsc::Receiver<Message>,
pub total_invested: f32,
pub investment_cap: f32
}
impl OrderBookActor {
pub fn new(receiver: mpsc::Receiver<Message>, investment_cap: f32) -> Self {
return OrderBookActor { receiver, total_invested: 0.0, investment_cap }
}
fn handle_message(&mut self, message: Message) {
if message.amount + self.total_invested >= self.investment_cap {
println!("rejecting purchase, total invested: {}", self.total_invested);
let _ = message.respond_to.send(0);
} else {
self.total_invested += message.amount;
println!("processing purchase, total invested: {}", self.total_invested);
let _ = message.respond_to.send(1);
}
}
pub async fn run(mut self) {
println!("actor is running");
while let Some(msg) = self.receiver.recv().await {
self.handle_message(msg);
}
}
}
pub struct BuyOrder {
pub ticker: String,
pub amount: f32,
pub order: String,
pub sender: Sender<Message>
}
impl BuyOrder {
pub fn new(amount: f32, ticker: String, sender: Sender<Message>) -> Self {
return BuyOrder { ticker, amount, order: "buy".to_owned(), sender }
}
pub async fn send(self) {
let (send, recv) = oneshot::channel();
let message = Message { order: self.order, amount: self.amount, ticker: self.ticker, respond_to: send};
let _ = self.sender.send(message).await;
match recv.await {
Err(e) => println!("{}", e),
Ok(outcome) => println!("here is the outcome: {}", outcome)
}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter15/passing_tcp_to_an_actor/server/src/main.rs | chapter15/passing_tcp_to_an_actor/server/src/main.rs | use tokio::net::TcpListener;
use std::{thread, time};
use tokio::io::{BufReader, AsyncBufReadExt, AsyncWriteExt};
use tokio::sync::mpsc;
mod actors;
use actors::{OrderBookActor, BuyOrder, Message};
#[tokio::main]
async fn main() {
let addr = "127.0.0.1:8080".to_string();
let mut socket = TcpListener::bind(&addr).await.unwrap();
println!("Listening on: {}", addr);
let (tx, rx) = mpsc::channel::<Message>(1);
tokio::spawn(async move {
let order_book_actor = OrderBookActor::new(rx, 20.0);
order_book_actor.run().await;
});
println!("order book running now");
while let Ok((mut stream, peer)) = socket.accept().await {
println!("Incoming connection from: {}", peer.to_string());
let tx_one = tx.clone();
tokio::spawn(async move {
println!("thread starting {} starting", peer.to_string());
let (reader, mut writer) = stream.split();
let mut buf_reader = BufReader::new(reader);
let mut buf = vec![];
loop {
match buf_reader.read_until(b'\n', &mut buf).await {
Ok(n) => {
if n == 0 {
println!("EOF received");
break;
}
let buf_string = String::from_utf8_lossy(&buf);
let data: Vec<String> = buf_string.split(";").map(|x| x.to_string()
.replace("\n", ""))
.collect();
let amount = data[0].parse::<f32>().unwrap();
let order_actor = BuyOrder::new(amount, data[1].clone(), tx_one.clone());
println!("{}: {}", order_actor.ticker, order_actor.amount);
order_actor.send().await;
buf.clear();
},
Err(e) => println!("Error receiving message: {}", e)
}
}
println!("thread {} finishing", peer.to_string());
});
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter15/passing_tcp_to_an_actor/client/src/main.rs | chapter15/passing_tcp_to_an_actor/client/src/main.rs | use tokio::net::TcpStream;
use tokio::io::AsyncWriteExt;
use std::error::Error;
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
println!("stream starting");
stream.write_all(b"8.0;BYND;\n9.0;PLTR").await?;
println!("stream finished");
Ok(())
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter15/processing_bytes/server/src/main.rs | chapter15/processing_bytes/server/src/main.rs | use tokio::net::TcpListener;
use std::{thread, time};
use tokio::io::{BufReader, AsyncBufReadExt, AsyncWriteExt};
#[tokio::main]
async fn main() {
let addr = "127.0.0.1:8080".to_string();
let mut socket = TcpListener::bind(&addr).await.unwrap();
println!("Listening on: {}", addr);
while let Ok((mut stream, peer)) = socket.accept().await {
println!("Incoming connection from: {}", peer.to_string());
tokio::spawn(async move {
println!("thread starting {} starting", peer.to_string());
let (reader, mut writer) = stream.split();
let mut buf_reader = BufReader::new(reader);
let mut buf = vec![];
loop {
match buf_reader.read_until(b'\n', &mut buf).await {
Ok(n) => {
if n == 0 {
println!("EOF received");
break;
}
let buf_string = String::from_utf8_lossy(&buf);
let data: Vec<String> = buf_string.split(";").map(|x| x.to_string()
.replace("\n", ""))
.collect();
println!("Received message: {:?}", data);
buf.clear();
},
Err(e) => println!("Error receiving message: {}", e)
}
}
println!("thread {} finishing", peer.to_string());
});
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter15/processing_bytes/client/src/main.rs | chapter15/processing_bytes/client/src/main.rs | use tokio::net::TcpStream;
use tokio::io::AsyncWriteExt;
use std::error::Error;
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
println!("stream starting");
stream.write_all(b"one;two\nthree;four").await?;
println!("stream finished");
Ok(())
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter15/chaining_communication_between_actors/server/src/actors.rs | chapter15/chaining_communication_between_actors/server/src/actors.rs | use tokio::sync::{mpsc, oneshot, mpsc::Sender};
use crate::order_tracker::TrackerMessage;
#[derive(Debug)]
pub struct Message {
pub order: String,
pub ticker: String,
pub amount: f32,
pub respond_to: oneshot::Sender<u32>
}
pub struct OrderBookActor {
pub receiver: mpsc::Receiver<Message>,
pub sender: mpsc::Sender<TrackerMessage>,
pub total_invested: f32,
pub investment_cap: f32
}
impl OrderBookActor {
pub fn new(receiver: mpsc::Receiver<Message>, sender: mpsc::Sender<TrackerMessage>,
investment_cap: f32) -> Self {
OrderBookActor {
receiver, sender,
total_invested: 0.0,
investment_cap
}
}
async fn handle_message(&mut self, message: Message) {
if message.amount + self.total_invested >=
self.investment_cap {
println!("rejecting purchase, total invested: {}",
self.total_invested);
let _ = message.respond_to.send(0);
}
else {
self.total_invested += message.amount;
println!("processing purchase, total invested: {}",
self.total_invested);
let _ = message.respond_to.send(1);
let (send, _) = oneshot::channel();
let tracker_message = TrackerMessage{
command: "BUY".to_string(),
ticker: Some(message.ticker),
amount: Some(message.amount),
respond_to: send
};
let _ = self.sender.send(tracker_message).await;
}
}
pub async fn run(mut self) {
println!("actor is running");
while let Some(msg) = self.receiver.recv().await {
self.handle_message(msg);
}
}
}
pub struct BuyOrder {
pub ticker: String,
pub amount: f32,
pub order: String,
pub sender: Sender<Message>
}
impl BuyOrder {
pub fn new(amount: f32, ticker: String, sender: Sender<Message>) -> Self {
return BuyOrder { ticker, amount, order: "buy".to_owned(), sender }
}
pub async fn send(self) {
let (send, recv) = oneshot::channel();
let message = Message { order: self.order, amount: self.amount, ticker: self.ticker, respond_to: send};
let _ = self.sender.send(message).await;
match recv.await {
Err(e) => println!("{}", e),
Ok(outcome) => println!("here is the outcome: {}", outcome)
}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter15/chaining_communication_between_actors/server/src/main.rs | chapter15/chaining_communication_between_actors/server/src/main.rs | use tokio::net::TcpListener;
use std::{thread, time};
use tokio::io::{BufReader, AsyncBufReadExt, AsyncWriteExt};
use tokio::sync::mpsc;
mod actors;
use actors::{OrderBookActor, BuyOrder, Message};
#[tokio::main]
async fn main() {
let addr = "127.0.0.1:8080".to_string();
let mut socket = TcpListener::bind(&addr).await.unwrap();
println!("Listening on: {}", addr);
let (tx, rx) = mpsc::channel::<Message>(1);
tokio::spawn(async move {
let order_book_actor = OrderBookActor::new(rx, 20.0);
order_book_actor.run().await;
});
println!("order book running now");
while let Ok((mut stream, peer)) = socket.accept().await {
println!("Incoming connection from: {}", peer.to_string());
let tx_one = tx.clone();
tokio::spawn(async move {
println!("thread starting {} starting", peer.to_string());
let (reader, mut writer) = stream.split();
let mut buf_reader = BufReader::new(reader);
let mut buf = vec![];
loop {
match buf_reader.read_until(b'\n', &mut buf).await {
Ok(n) => {
if n == 0 {
println!("EOF received");
break;
}
let buf_string = String::from_utf8_lossy(&buf);
let data: Vec<String> = buf_string.split(";").map(|x| x.to_string()
.replace("\n", ""))
.collect();
let amount = data[0].parse::<f32>().unwrap();
let order_actor = BuyOrder::new(amount, data[1].clone(), tx_one.clone());
println!("{}: {}", order_actor.ticker, order_actor.amount);
order_actor.send().await;
buf.clear();
},
Err(e) => println!("Error receiving message: {}", e)
}
}
println!("thread {} finishing", peer.to_string());
});
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter15/chaining_communication_between_actors/server/src/order_tracker.rs | chapter15/chaining_communication_between_actors/server/src/order_tracker.rs | use tokio::sync::{mpsc, oneshot};
use std::collections::HashMap;
#[derive(Debug, Clone)]
pub enum Order {
BUY(String, f32),
GET
}
pub struct TrackerMessage {
pub command: Order,
pub respond_to: oneshot::Sender<String>
}
pub struct GetTrackerActor {
pub sender: mpsc::Sender<TrackerMessage>
}
impl GetTrackerActor {
pub async fn send(self) -> String {
println!("GET function firing");
let (send, recv) = oneshot::channel();
let message = TrackerMessage {
command: Order::GET,
respond_to: send
};
let _ = self.sender.send(message).await;
match recv.await {
Err(e) => panic!("{}", e),
Ok(outcome) => return outcome
}
}
}
pub struct TrackerActor {
pub receiver: mpsc::Receiver<TrackerMessage>,
pub db: HashMap<String, f32>
}
impl TrackerActor {
pub fn new(receiver: mpsc::Receiver<TrackerMessage>) -> Self {
TrackerActor {
receiver,
db: HashMap::new(),
}
}
fn send_state(&self, respond_to: oneshot::Sender<String>) {
let mut buffer = Vec::new();
for key in self.db.keys() {
let amount = self.db.get(key).unwrap();
buffer.push(format!("{}:{ };", &key, amount));
}
buffer.push("\n".to_string());
println!("sending state: {}", buffer.join(""));
respond_to.send(buffer.join(""));
}
fn handle_message(&mut self, message: TrackerMessage) {
match message.command {
Order::GET => {
println!("getting state");
self.send_state(message.respond_to);
},
Order::BUY(ticker, amount) => {
match self.db.get(&ticker) {
Some(ticker_amount) => {
self.db.insert(ticker, ticker_amount + amount);
},
None => {
self.db.insert(ticker, amount);
}
}
println!("db: {:?}", self.db);
}
}
}
pub async fn run(mut self) {
println!("tracker actor is running");
while let Some(msg) = self.receiver.recv().await {
self.handle_message(msg);
}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter15/chaining_communication_between_actors/client/src/main.rs | chapter15/chaining_communication_between_actors/client/src/main.rs | use tokio::net::TcpStream;
use tokio::io::AsyncWriteExt;
use std::error::Error;
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
println!("stream starting");
stream.write_all(b"8.0;BYND;\n9.0;PLTR").await?;
println!("stream finished");
Ok(())
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/jwt.rs | chapter05/injecting_css_into_html/web_app/src/jwt.rs | use actix_web::dev::Payload;
use actix_web::{Error, FromRequest, HttpRequest};
use futures::future::{Ready, ok};
pub struct JwToken {
pub message: String
}
impl FromRequest for JwToken {
type Error = Error;
type Future = Ready<Result<JwToken, Error>>;
fn from_request(req: &HttpRequest, _: &mut Payload)
-> Self::Future {
match req.headers().get("token") {
Some(data) => {
let token = JwToken{
message: data.to_str().unwrap().to_string()
};
ok(token)
},
None => {
let token = JwToken{
message: String::from("nothing found")
};
ok(token)
}
}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/state.rs | chapter05/injecting_css_into_html/web_app/src/state.rs | use std::fs::File;
use std::fs;
use std::io::Read;
use serde_json::Map;
use serde_json::value::Value;
use serde_json::json;
pub fn read_file(file_name: &str) -> Map<String, Value> {
let mut file = File::open(file_name.to_string()).unwrap();
let mut data = String::new();
file.read_to_string(&mut data).unwrap();
let json: Value = serde_json::from_str(&data).unwrap();
let state: Map<String, Value> = json.as_object().unwrap().clone();
return state
}
pub fn write_to_file(file_name: &str,
state: &mut Map<String, Value>) {
let new_data = json!(state);
fs::write(
file_name.to_string(),
new_data.to_string()
).expect("Unable to write file");
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/processes.rs | chapter05/injecting_css_into_html/web_app/src/processes.rs | use serde_json::Map;
use serde_json::value::Value;
use super::to_do::ItemTypes;
use super::to_do::structs::done::Done;
use super::to_do::structs::pending::Pending;
use super::to_do::traits::get::Get;
use super::to_do::traits::create::Create;
use super::to_do::traits::delete::Delete;
use super::to_do::traits::edit::Edit;
fn process_pending(item: Pending, command: String, state: &Map<String, Value>) {
let mut state = state.clone();
match command.as_str() {
"get" => item.get(&item.super_struct.title, &state),
"create" => item.create(&item.super_struct.title,
&item.super_struct.status.stringify(), &mut state),
"edit" => item.set_to_done(&item.super_struct.title,
&mut state),
_ => println!("command: {} not supported", command)
}
}
fn process_done(item: Done, command: String, state: &Map<String, Value>) {
let mut state = state.clone();
match command.as_str() {
"get" => item.get(&item.super_struct.title, &state),
"delete" => item.delete(&item.super_struct.title, &mut state),
"edit" => item.set_to_pending(&item.super_struct.title, &mut state),
_ => println!("command: {} not supported", command)
}
}
pub fn process_input(item: ItemTypes, command: String, state: &Map<String, Value>) {
match item {
ItemTypes::Pending(item) => process_pending(item, command, state),
ItemTypes::Done(item) => process_done(item, command, state)
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/main.rs | chapter05/injecting_css_into_html/web_app/src/main.rs | use actix_web::{App, HttpServer};
use actix_service::Service;
mod views;
mod to_do;
mod state;
mod processes;
mod json_serialization;
mod jwt;
#[actix_web::main]
async fn main() -> std::io::Result<()> {
HttpServer::new(|| {
let app = App::new()
.wrap_fn(|req, srv|{
println!("{:?}", req);
let future = srv.call(req);
async {
let result = future.await?;
Ok(result)
}
}).configure(views::views_factory);
return app
})
.bind("127.0.0.1:8000")?
.run()
.await
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/json_serialization/to_do_item.rs | chapter05/injecting_css_into_html/web_app/src/json_serialization/to_do_item.rs | use serde::Deserialize;
#[derive(Deserialize)]
pub struct ToDoItem {
pub title: String,
pub status: String
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/json_serialization/to_do_items.rs | chapter05/injecting_css_into_html/web_app/src/json_serialization/to_do_items.rs | use serde::Serialize;
use std::vec::Vec;
use serde_json::value::Value;
use serde_json::Map;
use actix_web::{
body::BoxBody, http::header::ContentType,
HttpRequest, HttpResponse, Responder,
};
use crate::to_do::ItemTypes;
use crate::to_do::structs::base::Base;
use crate::state::read_file;
use crate::to_do::{to_do_factory, enums::TaskStatus};
#[derive(Serialize)]
pub struct ToDoItems {
pub pending_items: Vec<Base>,
pub done_items: Vec<Base>,
pub pending_item_count: i8,
pub done_item_count: i8
}
impl ToDoItems {
pub fn new(input_items: Vec<ItemTypes>) -> ToDoItems {
let mut pending_array_buffer = Vec::new();
let mut done_array_buffer = Vec::new();
for item in input_items {
match item {
ItemTypes::Pending(packed) => pending_array_buffer.
push(packed.super_struct),
ItemTypes::Done(packed) => done_array_buffer.push(
packed.super_struct)
}
}
let done_count: i8 = done_array_buffer.len() as i8;
let pending_count: i8 = pending_array_buffer.len() as i8;
return ToDoItems{
pending_items: pending_array_buffer,
done_item_count: done_count,
pending_item_count: pending_count,
done_items: done_array_buffer
}
}
pub fn get_state() -> ToDoItems {
let state: Map<String, Value> = read_file("./state.json");
let mut array_buffer = Vec::new();
for (key, value) in state {
let status = TaskStatus::from_string(value.as_str().unwrap().to_string());
let item = to_do_factory(
&key, status);
array_buffer.push(item);
}
return ToDoItems::new(array_buffer)
}
}
impl Responder for ToDoItems {
type Body = BoxBody;
fn respond_to(self, _req: &HttpRequest)
-> HttpResponse<Self::Body> {
let body = serde_json::to_string(&self).unwrap();
HttpResponse::Ok()
.content_type(ContentType::json())
.body(body)
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/json_serialization/mod.rs | chapter05/injecting_css_into_html/web_app/src/json_serialization/mod.rs | pub mod to_do_items;
pub mod to_do_item;
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/views/mod.rs | chapter05/injecting_css_into_html/web_app/src/views/mod.rs | mod auth;
mod to_do;
mod app;
use auth::auth_views_factory;
use to_do::to_do_views_factory; // import the factory
use actix_web::web::ServiceConfig;
pub fn views_factory(app: &mut ServiceConfig) {
auth_views_factory(app);
to_do_views_factory(app); // pass the ServiceConfig
app::app_views_factory(app);
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/views/auth/login.rs | chapter05/injecting_css_into_html/web_app/src/views/auth/login.rs |
pub async fn login() -> String {
format!("Login view")
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/views/auth/mod.rs | chapter05/injecting_css_into_html/web_app/src/views/auth/mod.rs | mod login;
mod logout;
use actix_web::web::{ServiceConfig, get, scope};
pub fn auth_views_factory(app: &mut ServiceConfig) {
app.service(
scope("v1/auth")
.route("login", get().to(login::login))
.route("logout", get().to(logout::logout))
);
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/views/auth/logout.rs | chapter05/injecting_css_into_html/web_app/src/views/auth/logout.rs |
pub async fn logout() -> String {
format!("Logout view")
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/views/app/items.rs | chapter05/injecting_css_into_html/web_app/src/views/app/items.rs | use actix_web::HttpResponse;
use super::content_loader::read_file;
pub async fn items() -> HttpResponse {
let mut html_data = read_file(
"./templates/main.html");
let javascript_data: String = read_file(
"./javascript/main.js");
let css_data: String = read_file(
"./css/main.css");
let base_css_data: String = read_file(
"./css/base.css");
html_data = html_data.replace("{{JAVASCRIPT}}",
&javascript_data);
html_data = html_data.replace("{{CSS}}",
&css_data);
html_data = html_data.replace("{{BASE_CSS}}",
&base_css_data);
HttpResponse::Ok()
.content_type("text/html; charset=utf-8")
.body(html_data)
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/views/app/content_loader.rs | chapter05/injecting_css_into_html/web_app/src/views/app/content_loader.rs | use std::fs;
pub fn read_file(file_path: &str) -> String {
let data: String = fs::read_to_string(
file_path).expect("Unable to read file");
return data
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/views/app/mod.rs | chapter05/injecting_css_into_html/web_app/src/views/app/mod.rs | use actix_web::web;
mod items;
mod content_loader;
pub fn app_views_factory(app: &mut web::ServiceConfig) {
app.route("/", web::get().to(items::items));
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/views/to_do/mod.rs | chapter05/injecting_css_into_html/web_app/src/views/to_do/mod.rs | mod create;
mod get;
mod edit;
mod delete;
use actix_web::web::{ServiceConfig, post, get, scope};
pub fn to_do_views_factory(app: &mut ServiceConfig) {
app.service(
scope("v1/item")
.route("create/{title}", post().to(create::create))
.route("get", get().to(get::get))
.route("edit", post().to(edit::edit))
.route("delete", post().to(delete::delete))
);
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/views/to_do/edit.rs | chapter05/injecting_css_into_html/web_app/src/views/to_do/edit.rs | use actix_web::{web, HttpResponse};
use serde_json::value::Value;
use serde_json::Map;
use crate::state::read_file;
use crate::to_do::{to_do_factory, enums::TaskStatus};
use crate::json_serialization::{to_do_item::ToDoItem,
to_do_items::ToDoItems};
use crate::processes::process_input;
use crate::jwt::JwToken;
pub async fn edit(to_do_item: web::Json<ToDoItem>, token: JwToken) -> HttpResponse {
println!("here is the message in the token: {}", token.message);
let state: Map<String, Value> = read_file("./state.json");
let status: TaskStatus;
match &state.get(&to_do_item.title) {
Some(result) => {
status = TaskStatus::from_string(result.as_str()
.unwrap()
.to_string());
}
None=> {
return HttpResponse::NotFound().json(
format!("{} not in state", &to_do_item.title))
}
}
let existing_item = to_do_factory(to_do_item.title.as_str(), status.clone());
if &status.stringify() == &TaskStatus::from_string(
to_do_item.status.as_str().to_string()).stringify() {
return HttpResponse::Ok().json(ToDoItems::get_state())
}
process_input(existing_item, "edit".to_owned(), &state);
return HttpResponse::Ok().json(ToDoItems::get_state())
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/views/to_do/create.rs | chapter05/injecting_css_into_html/web_app/src/views/to_do/create.rs | use actix_web::HttpResponse;
use serde_json::Value;
use serde_json::Map;
use actix_web::HttpRequest;
use crate::to_do::{to_do_factory, enums::TaskStatus};
use crate::json_serialization::to_do_items::ToDoItems;
use crate::state::read_file;
use crate::processes::process_input;
pub async fn create(req: HttpRequest) -> HttpResponse {
let state: Map<String, Value> = read_file("./state.json");
let title: String = req.match_info().get("title"
).unwrap().to_string();
let item = to_do_factory(&title.as_str(),
TaskStatus::PENDING);
process_input(item, "create".to_string(), &state);
return HttpResponse::Ok().json(ToDoItems::get_state())
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/views/to_do/get.rs | chapter05/injecting_css_into_html/web_app/src/views/to_do/get.rs | use actix_web::Responder;
use crate::json_serialization::to_do_items::ToDoItems;
pub async fn get() -> impl Responder {
return ToDoItems::get_state();
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/views/to_do/delete.rs | chapter05/injecting_css_into_html/web_app/src/views/to_do/delete.rs | use actix_web::{web, HttpResponse};
use serde_json::value::Value;
use serde_json::Map;
use crate::to_do::{to_do_factory, enums::TaskStatus};
use crate::json_serialization::{to_do_item::ToDoItem,
to_do_items::ToDoItems};
use crate::processes::process_input;
use crate::jwt::JwToken;
use crate::state::read_file;
pub async fn delete(to_do_item: web::Json<ToDoItem>, token: JwToken) -> HttpResponse {
let state: Map<String, Value> = read_file("./state.json");
let status: TaskStatus;
match &state.get(&to_do_item.title) {
Some(result) => {
status = TaskStatus::from_string(result.as_str().unwrap().to_string());
}
None=> {
return HttpResponse::NotFound().json(
format!("{} not in state", &to_do_item.title))
}
}
let existing_item = to_do_factory(to_do_item.title.as_str(), status.clone());
process_input(existing_item, "delete".to_owned(), &state);
return HttpResponse::Ok().json(ToDoItems::get_state())
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/to_do/enums.rs | chapter05/injecting_css_into_html/web_app/src/to_do/enums.rs | use serde::ser::{Serialize, SerializeStruct, Serializer};
#[derive(Clone)]
pub enum TaskStatus {
DONE,
PENDING
}
impl TaskStatus {
pub fn stringify(&self) -> String {
match &self {
&Self::DONE => {"DONE".to_string()},
&Self::PENDING => {"PENDING".to_string()}
}
}
pub fn from_string(input_string: String) -> Self {
match input_string.as_str() {
"DONE" => TaskStatus::DONE,
"PENDING" => TaskStatus::PENDING,
_ => panic!("input {} not supported",
input_string)
}
}
}
impl Serialize for TaskStatus {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut s = serializer.serialize_struct("TaskStatus", 1)?;
s.serialize_field("status", &self.stringify())?;
s.end()
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/to_do/mod.rs | chapter05/injecting_css_into_html/web_app/src/to_do/mod.rs | pub mod structs;
pub mod enums;
pub mod traits;
use enums::TaskStatus;
use structs::done::Done;
use structs::pending::Pending;
pub enum ItemTypes {
Pending(Pending),
Done(Done)
}
pub fn to_do_factory(title: &str,
status: TaskStatus) -> ItemTypes {
match status {
TaskStatus::DONE => {
ItemTypes::Done(Done::new(title))
},
TaskStatus::PENDING => {
ItemTypes::Pending(Pending::new(title))
}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/to_do/structs/pending.rs | chapter05/injecting_css_into_html/web_app/src/to_do/structs/pending.rs | use super::base::Base;
use super::super::enums::TaskStatus;
use super::super::traits::get::Get;
use super::super::traits::edit::Edit;
use super::super::traits::create::Create;
pub struct Pending {
pub super_struct: Base
}
impl Pending {
pub fn new(input_title: &str) -> Self {
let base = Base{
title: input_title.to_string(),
status: TaskStatus::PENDING
};
return Pending{super_struct: base}
}
}
impl Get for Pending {}
impl Edit for Pending {}
impl Create for Pending {}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/to_do/structs/base.rs | chapter05/injecting_css_into_html/web_app/src/to_do/structs/base.rs | use super::super::enums::TaskStatus;
use serde::Serialize;
#[derive(Serialize)]
pub struct Base {
pub title: String,
pub status: TaskStatus
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/to_do/structs/mod.rs | chapter05/injecting_css_into_html/web_app/src/to_do/structs/mod.rs | pub mod base;
pub mod done;
pub mod pending;
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/to_do/structs/done.rs | chapter05/injecting_css_into_html/web_app/src/to_do/structs/done.rs | use super::base::Base;
use super::super::enums::TaskStatus;
use super::super::traits::get::Get;
use super::super::traits::delete::Delete;
use super::super::traits::edit::Edit;
pub struct Done {
pub super_struct: Base
}
impl Done {
pub fn new(input_title: &str) -> Self {
let base = Base {
title: input_title.to_string(),
status: TaskStatus::DONE
};
return Done{super_struct: base}
}
}
impl Get for Done {}
impl Delete for Done {}
impl Edit for Done {}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/to_do/traits/mod.rs | chapter05/injecting_css_into_html/web_app/src/to_do/traits/mod.rs | pub mod create;
pub mod delete;
pub mod edit;
pub mod get;
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/to_do/traits/edit.rs | chapter05/injecting_css_into_html/web_app/src/to_do/traits/edit.rs | use serde_json::Map;
use serde_json::value::Value;
use serde_json::json;
use crate::state::write_to_file;
use super::super::enums::TaskStatus;
pub trait Edit {
fn set_to_done(&self, title: &String,
state: &mut Map<String, Value>) {
state.insert(title.to_string(),
json!(TaskStatus::DONE.stringify()));
write_to_file("./state.json", state);
println!("\n\n{} is being set to done\n\n", title);
}
fn set_to_pending(&self, title: &String,
state: &mut Map<String, Value>) {
state.insert(title.to_string(),
json!(TaskStatus::PENDING.stringify()));
write_to_file("./state.json", state);
println!("\n\n{} is being set to pending\n\n", title);
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/to_do/traits/create.rs | chapter05/injecting_css_into_html/web_app/src/to_do/traits/create.rs | use serde_json::Map;
use serde_json::value::Value;
use serde_json::json;
use crate::state::write_to_file;
pub trait Create {
fn create(&self, title: &String, status: &String,
state: &mut Map<String, Value>) {
state.insert(title.to_string(), json!(status));
write_to_file("./state.json", state);
println!("\n\n{} is being created\n\n", title);
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/to_do/traits/get.rs | chapter05/injecting_css_into_html/web_app/src/to_do/traits/get.rs | use serde_json::Map;
use serde_json::value::Value;
pub trait Get {
fn get(&self, title: &String, state: &Map<String, Value>) {
let item: Option<&Value> = state.get(title);
match item {
Some(result) => {
println!("\n\nItem: {}", title);
println!("Status: {}\n\n", result);
},
None => println!("item: {} was not found", title)
}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/injecting_css_into_html/web_app/src/to_do/traits/delete.rs | chapter05/injecting_css_into_html/web_app/src/to_do/traits/delete.rs | use serde_json::Map;
use serde_json::value::Value;
use crate::state::write_to_file;
pub trait Delete {
fn delete(&self, title: &String,
state: &mut Map<String, Value>) {
state.remove(title);
write_to_file("./state.json", state);
println!("\n\n{} is being deleted\n\n", title);
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/making_api_calls_in_react/web_app/src/jwt.rs | chapter05/making_api_calls_in_react/web_app/src/jwt.rs | use actix_web::dev::Payload;
use actix_web::{Error, FromRequest, HttpRequest};
use futures::future::{Ready, ok};
pub struct JwToken {
pub message: String
}
impl FromRequest for JwToken {
type Error = Error;
type Future = Ready<Result<JwToken, Error>>;
fn from_request(req: &HttpRequest, _: &mut Payload)
-> Self::Future {
match req.headers().get("token") {
Some(data) => {
let token = JwToken{
message: data.to_str().unwrap().to_string()
};
ok(token)
},
None => {
let token = JwToken{
message: String::from("nothing found")
};
ok(token)
}
}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/making_api_calls_in_react/web_app/src/state.rs | chapter05/making_api_calls_in_react/web_app/src/state.rs | use std::fs::File;
use std::fs;
use std::io::Read;
use serde_json::Map;
use serde_json::value::Value;
use serde_json::json;
pub fn read_file(file_name: &str) -> Map<String, Value> {
let mut file = File::open(file_name.to_string()).unwrap();
let mut data = String::new();
file.read_to_string(&mut data).unwrap();
let json: Value = serde_json::from_str(&data).unwrap();
let state: Map<String, Value> = json.as_object().unwrap().clone();
return state
}
pub fn write_to_file(file_name: &str,
state: &mut Map<String, Value>) {
let new_data = json!(state);
fs::write(
file_name.to_string(),
new_data.to_string()
).expect("Unable to write file");
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/making_api_calls_in_react/web_app/src/processes.rs | chapter05/making_api_calls_in_react/web_app/src/processes.rs | use serde_json::Map;
use serde_json::value::Value;
use super::to_do::ItemTypes;
use super::to_do::structs::done::Done;
use super::to_do::structs::pending::Pending;
use super::to_do::traits::get::Get;
use super::to_do::traits::create::Create;
use super::to_do::traits::delete::Delete;
use super::to_do::traits::edit::Edit;
fn process_pending(item: Pending, command: String, state: &Map<String, Value>) {
let mut state = state.clone();
match command.as_str() {
"get" => item.get(&item.super_struct.title, &state),
"create" => item.create(&item.super_struct.title,
&item.super_struct.status.stringify(), &mut state),
"edit" => item.set_to_done(&item.super_struct.title,
&mut state),
_ => println!("command: {} not supported", command)
}
}
fn process_done(item: Done, command: String, state: &Map<String, Value>) {
let mut state = state.clone();
match command.as_str() {
"get" => item.get(&item.super_struct.title, &state),
"delete" => item.delete(&item.super_struct.title, &mut state),
"edit" => item.set_to_pending(&item.super_struct.title, &mut state),
_ => println!("command: {} not supported", command)
}
}
pub fn process_input(item: ItemTypes, command: String, state: &Map<String, Value>) {
match item {
ItemTypes::Pending(item) => process_pending(item, command, state),
ItemTypes::Done(item) => process_done(item, command, state)
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/making_api_calls_in_react/web_app/src/main.rs | chapter05/making_api_calls_in_react/web_app/src/main.rs | use actix_web::{App, HttpServer};
use actix_service::Service;
use actix_cors::Cors;
mod views;
mod to_do;
mod state;
mod processes;
mod json_serialization;
mod jwt;
#[actix_web::main]
async fn main() -> std::io::Result<()> {
HttpServer::new(|| {
let cors = Cors::default().allow_any_origin().allow_any_method().allow_any_header();
let app = App::new()
.wrap_fn(|req, srv|{
println!("{:?}", req);
let future = srv.call(req);
async {
let result = future.await?;
Ok(result)
}
}).configure(views::views_factory).wrap(cors);
return app
})
.bind("127.0.0.1:8000")?
.run()
.await
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/making_api_calls_in_react/web_app/src/json_serialization/to_do_item.rs | chapter05/making_api_calls_in_react/web_app/src/json_serialization/to_do_item.rs | use serde::Deserialize;
#[derive(Deserialize)]
pub struct ToDoItem {
pub title: String,
pub status: String
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/making_api_calls_in_react/web_app/src/json_serialization/to_do_items.rs | chapter05/making_api_calls_in_react/web_app/src/json_serialization/to_do_items.rs | use serde::Serialize;
use std::vec::Vec;
use serde_json::value::Value;
use serde_json::Map;
use actix_web::{
body::BoxBody, http::header::ContentType,
HttpRequest, HttpResponse, Responder,
};
use crate::to_do::ItemTypes;
use crate::to_do::structs::base::Base;
use crate::state::read_file;
use crate::to_do::{to_do_factory, enums::TaskStatus};
#[derive(Serialize)]
pub struct ToDoItems {
pub pending_items: Vec<Base>,
pub done_items: Vec<Base>,
pub pending_item_count: i8,
pub done_item_count: i8
}
impl ToDoItems {
pub fn new(input_items: Vec<ItemTypes>) -> ToDoItems {
let mut pending_array_buffer = Vec::new();
let mut done_array_buffer = Vec::new();
for item in input_items {
match item {
ItemTypes::Pending(packed) => pending_array_buffer.
push(packed.super_struct),
ItemTypes::Done(packed) => done_array_buffer.push(
packed.super_struct)
}
}
let done_count: i8 = done_array_buffer.len() as i8;
let pending_count: i8 = pending_array_buffer.len() as i8;
return ToDoItems{
pending_items: pending_array_buffer,
done_item_count: done_count,
pending_item_count: pending_count,
done_items: done_array_buffer
}
}
pub fn get_state() -> ToDoItems {
let state: Map<String, Value> = read_file("./state.json");
let mut array_buffer = Vec::new();
for (key, value) in state {
let status = TaskStatus::from_string(value.as_str().unwrap().to_string());
let item = to_do_factory(
&key, status);
array_buffer.push(item);
}
return ToDoItems::new(array_buffer)
}
}
impl Responder for ToDoItems {
type Body = BoxBody;
fn respond_to(self, _req: &HttpRequest)
-> HttpResponse<Self::Body> {
let body = serde_json::to_string(&self).unwrap();
HttpResponse::Ok()
.content_type(ContentType::json())
.body(body)
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/making_api_calls_in_react/web_app/src/json_serialization/mod.rs | chapter05/making_api_calls_in_react/web_app/src/json_serialization/mod.rs | pub mod to_do_items;
pub mod to_do_item;
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/making_api_calls_in_react/web_app/src/views/mod.rs | chapter05/making_api_calls_in_react/web_app/src/views/mod.rs | mod auth;
mod to_do;
mod app;
use auth::auth_views_factory;
use to_do::to_do_views_factory; // import the factory
use actix_web::web::ServiceConfig;
pub fn views_factory(app: &mut ServiceConfig) {
auth_views_factory(app);
to_do_views_factory(app); // pass the ServiceConfig
app::app_views_factory(app);
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/making_api_calls_in_react/web_app/src/views/auth/login.rs | chapter05/making_api_calls_in_react/web_app/src/views/auth/login.rs |
pub async fn login() -> String {
format!("Login view")
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/making_api_calls_in_react/web_app/src/views/auth/mod.rs | chapter05/making_api_calls_in_react/web_app/src/views/auth/mod.rs | mod login;
mod logout;
use actix_web::web::{ServiceConfig, get, scope};
pub fn auth_views_factory(app: &mut ServiceConfig) {
app.service(
scope("v1/auth")
.route("login", get().to(login::login))
.route("logout", get().to(logout::logout))
);
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/making_api_calls_in_react/web_app/src/views/auth/logout.rs | chapter05/making_api_calls_in_react/web_app/src/views/auth/logout.rs |
pub async fn logout() -> String {
format!("Logout view")
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/making_api_calls_in_react/web_app/src/views/app/items.rs | chapter05/making_api_calls_in_react/web_app/src/views/app/items.rs | use actix_web::HttpResponse;
use super::content_loader::read_file;
use super::content_loader::add_component;
pub async fn items() -> HttpResponse {
let mut html_data = read_file(
"./templates/main.html");
let javascript_data: String = read_file(
"./javascript/main.js");
let css_data: String = read_file(
"./css/main.css");
let base_css_data: String = read_file(
"./css/base.css");
html_data = html_data.replace("{{JAVASCRIPT}}", &javascript_data);
html_data = html_data.replace("{{CSS}}", &css_data);
html_data = html_data.replace("{{BASE_CSS}}", &base_css_data);
html_data = add_component(String::from("header"), html_data);
HttpResponse::Ok()
.content_type("text/html; charset=utf-8")
.body(html_data)
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/making_api_calls_in_react/web_app/src/views/app/content_loader.rs | chapter05/making_api_calls_in_react/web_app/src/views/app/content_loader.rs | use std::fs;
pub fn read_file(file_path: &str) -> String {
let data: String = fs::read_to_string(
file_path).expect("Unable to read file");
return data
}
pub fn add_component(component_tag: String, html_data: String) -> String {
let css_tag: String = component_tag.to_uppercase() + "_CSS";
let html_tag: String = component_tag.to_uppercase() + "_HTML";
let css_path = String::from("./templates/components/") +
&component_tag.to_lowercase() + ".css";
let css_loaded = read_file(&css_path);
let html_path = String::from("./templates/components/") +
&component_tag.to_lowercase() + ".html";
let html_loaded = read_file(&html_path);
let html_data = html_data.replace(html_tag.as_str(), &html_loaded);
let html_data = html_data.replace(css_tag.as_str(), &css_loaded);
return html_data
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/making_api_calls_in_react/web_app/src/views/app/mod.rs | chapter05/making_api_calls_in_react/web_app/src/views/app/mod.rs | use actix_web::web;
mod items;
mod content_loader;
pub fn app_views_factory(app: &mut web::ServiceConfig) {
app.route("/", web::get().to(items::items));
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/making_api_calls_in_react/web_app/src/views/to_do/mod.rs | chapter05/making_api_calls_in_react/web_app/src/views/to_do/mod.rs | mod create;
mod get;
mod edit;
mod delete;
use actix_web::web::{ServiceConfig, post, get, scope};
pub fn to_do_views_factory(app: &mut ServiceConfig) {
app.service(
scope("v1/item")
.route("create/{title}", post().to(create::create))
.route("get", get().to(get::get))
.route("edit", post().to(edit::edit))
.route("delete", post().to(delete::delete))
);
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/making_api_calls_in_react/web_app/src/views/to_do/edit.rs | chapter05/making_api_calls_in_react/web_app/src/views/to_do/edit.rs | use actix_web::{web, HttpResponse};
use serde_json::value::Value;
use serde_json::Map;
use crate::state::read_file;
use crate::to_do::{to_do_factory, enums::TaskStatus};
use crate::json_serialization::{to_do_item::ToDoItem,
to_do_items::ToDoItems};
use crate::processes::process_input;
use crate::jwt::JwToken;
pub async fn edit(to_do_item: web::Json<ToDoItem>, token: JwToken) -> HttpResponse {
println!("here is the message in the token: {}", token.message);
let state: Map<String, Value> = read_file("./state.json");
let status: TaskStatus;
match &state.get(&to_do_item.title) {
Some(result) => {
status = TaskStatus::from_string(result.as_str()
.unwrap()
.to_string());
}
None=> {
return HttpResponse::NotFound().json(
format!("{} not in state", &to_do_item.title))
}
}
let existing_item = to_do_factory(to_do_item.title.as_str(), status.clone());
if &status.stringify() == &TaskStatus::from_string(
to_do_item.status.as_str().to_string()).stringify() {
return HttpResponse::Ok().json(ToDoItems::get_state())
}
process_input(existing_item, "edit".to_owned(), &state);
return HttpResponse::Ok().json(ToDoItems::get_state())
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/making_api_calls_in_react/web_app/src/views/to_do/create.rs | chapter05/making_api_calls_in_react/web_app/src/views/to_do/create.rs | use actix_web::HttpResponse;
use serde_json::Value;
use serde_json::Map;
use actix_web::HttpRequest;
use crate::to_do::{to_do_factory, enums::TaskStatus};
use crate::json_serialization::to_do_items::ToDoItems;
use crate::state::read_file;
use crate::processes::process_input;
pub async fn create(req: HttpRequest) -> HttpResponse {
let state: Map<String, Value> = read_file("./state.json");
let title: String = req.match_info().get("title"
).unwrap().to_string();
let item = to_do_factory(&title.as_str(),
TaskStatus::PENDING);
process_input(item, "create".to_string(), &state);
return HttpResponse::Ok().json(ToDoItems::get_state())
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/making_api_calls_in_react/web_app/src/views/to_do/get.rs | chapter05/making_api_calls_in_react/web_app/src/views/to_do/get.rs | use actix_web::Responder;
use crate::json_serialization::to_do_items::ToDoItems;
pub async fn get() -> impl Responder {
return ToDoItems::get_state();
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/making_api_calls_in_react/web_app/src/views/to_do/delete.rs | chapter05/making_api_calls_in_react/web_app/src/views/to_do/delete.rs | use actix_web::{web, HttpResponse};
use serde_json::value::Value;
use serde_json::Map;
use crate::to_do::{to_do_factory, enums::TaskStatus};
use crate::json_serialization::{to_do_item::ToDoItem,
to_do_items::ToDoItems};
use crate::processes::process_input;
use crate::jwt::JwToken;
use crate::state::read_file;
pub async fn delete(to_do_item: web::Json<ToDoItem>, token: JwToken) -> HttpResponse {
let state: Map<String, Value> = read_file("./state.json");
let status: TaskStatus;
match &state.get(&to_do_item.title) {
Some(result) => {
status = TaskStatus::from_string(result.as_str().unwrap().to_string());
}
None=> {
return HttpResponse::NotFound().json(
format!("{} not in state", &to_do_item.title))
}
}
let existing_item = to_do_factory(to_do_item.title.as_str(), status.clone());
process_input(existing_item, "delete".to_owned(), &state);
return HttpResponse::Ok().json(ToDoItems::get_state())
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/making_api_calls_in_react/web_app/src/to_do/enums.rs | chapter05/making_api_calls_in_react/web_app/src/to_do/enums.rs | use serde::ser::{Serialize, SerializeStruct, Serializer};
#[derive(Clone)]
pub enum TaskStatus {
DONE,
PENDING
}
impl TaskStatus {
pub fn stringify(&self) -> String {
match &self {
&Self::DONE => {"DONE".to_string()},
&Self::PENDING => {"PENDING".to_string()}
}
}
pub fn from_string(input_string: String) -> Self {
match input_string.as_str() {
"DONE" => TaskStatus::DONE,
"PENDING" => TaskStatus::PENDING,
_ => panic!("input {} not supported",
input_string)
}
}
}
impl Serialize for TaskStatus {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut s = serializer.serialize_struct("TaskStatus", 1)?;
s.serialize_field("status", &self.stringify())?;
s.end()
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/making_api_calls_in_react/web_app/src/to_do/mod.rs | chapter05/making_api_calls_in_react/web_app/src/to_do/mod.rs | pub mod structs;
pub mod enums;
pub mod traits;
use enums::TaskStatus;
use structs::done::Done;
use structs::pending::Pending;
pub enum ItemTypes {
Pending(Pending),
Done(Done)
}
pub fn to_do_factory(title: &str,
status: TaskStatus) -> ItemTypes {
match status {
TaskStatus::DONE => {
ItemTypes::Done(Done::new(title))
},
TaskStatus::PENDING => {
ItemTypes::Pending(Pending::new(title))
}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/making_api_calls_in_react/web_app/src/to_do/structs/pending.rs | chapter05/making_api_calls_in_react/web_app/src/to_do/structs/pending.rs | use super::base::Base;
use super::super::enums::TaskStatus;
use super::super::traits::get::Get;
use super::super::traits::edit::Edit;
use super::super::traits::create::Create;
pub struct Pending {
pub super_struct: Base
}
impl Pending {
pub fn new(input_title: &str) -> Self {
let base = Base{
title: input_title.to_string(),
status: TaskStatus::PENDING
};
return Pending{super_struct: base}
}
}
impl Get for Pending {}
impl Edit for Pending {}
impl Create for Pending {}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/making_api_calls_in_react/web_app/src/to_do/structs/base.rs | chapter05/making_api_calls_in_react/web_app/src/to_do/structs/base.rs | use super::super::enums::TaskStatus;
use serde::Serialize;
#[derive(Serialize)]
pub struct Base {
pub title: String,
pub status: TaskStatus
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/making_api_calls_in_react/web_app/src/to_do/structs/mod.rs | chapter05/making_api_calls_in_react/web_app/src/to_do/structs/mod.rs | pub mod base;
pub mod done;
pub mod pending;
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/making_api_calls_in_react/web_app/src/to_do/structs/done.rs | chapter05/making_api_calls_in_react/web_app/src/to_do/structs/done.rs | use super::base::Base;
use super::super::enums::TaskStatus;
use super::super::traits::get::Get;
use super::super::traits::delete::Delete;
use super::super::traits::edit::Edit;
pub struct Done {
pub super_struct: Base
}
impl Done {
pub fn new(input_title: &str) -> Self {
let base = Base {
title: input_title.to_string(),
status: TaskStatus::DONE
};
return Done{super_struct: base}
}
}
impl Get for Done {}
impl Delete for Done {}
impl Edit for Done {}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.