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/chapter17/messages_and_runner_actor/web_app/src/json_serialization/to_do_item.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/json_serialization/login_response.rs | chapter17/messages_and_runner_actor/web_app/src/json_serialization/login_response.rs | use serde::Serialize;
#[derive(Serialize)]
pub struct LoginResponse {
pub token: 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/chapter17/messages_and_runner_actor/web_app/src/json_serialization/to_do_items.rs | chapter17/messages_and_runner_actor/web_app/src/json_serialization/to_do_items.rs | use crate::diesel;
use diesel::prelude::*;
use serde::Serialize;
use std::vec::Vec;
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::to_do::{to_do_factory, enums::TaskStatus};
use crate::database::DBCONNECTION;
use crate::models::item::item::Item;
use crate::schema::to_do;
/// This struct is responsible
#[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(user_id: i32) -> ToDoItems {
let connection = DBCONNECTION.db_connection.get().unwrap();
let mut array_buffer = Vec::new();
let items = to_do::table
.filter(to_do::columns::user_id.eq(&user_id))
.order(to_do::columns::id.asc())
.load::<Item>(&connection)
.unwrap();
for item in items {
let status = TaskStatus::new(&item.status.as_str());
let item = to_do_factory(&item.title, status);
array_buffer.push(item);
}
return ToDoItems::new(array_buffer)
}
}
impl Responder for ToDoItems {
type Body = BoxBody;
/// This function gets fired when the struct is being returned in an actix view.
///
/// # Arguments
/// * _req (&HttpRequest): the request belonging to the view
///
/// # Returns
/// * (Self::Future): a OK HTTP response with the serialized struct in the body
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/chapter17/messages_and_runner_actor/web_app/src/json_serialization/login.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/json_serialization/mod.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/json_serialization/new_user.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/models/mod.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/models/user/user.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/models/user/mod.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/models/user/new_user.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/models/item/mod.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/models/item/item.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/models/item/new_item.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/views/mod.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/views/auth/login.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/views/auth/mod.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/views/auth/logout.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/views/app/items.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/views/app/content_loader.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/views/app/mod.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/views/users/mod.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/views/users/create.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/views/to_do/mod.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/views/to_do/edit.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/views/to_do/create.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/views/to_do/get.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/views/to_do/delete.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/to_do/enums.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/to_do/mod.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/to_do/structs/pending.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/to_do/structs/base.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/to_do/structs/mod.rs | chapter17/messages_and_runner_actor/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/chapter17/messages_and_runner_actor/web_app/src/to_do/structs/done.rs | chapter17/messages_and_runner_actor/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/chapter17/http_server/echo_server/server/src/main.rs | chapter17/http_server/echo_server/server/src/main.rs | use tokio::net::TcpListener;
use tokio_util::codec::{BytesCodec, Decoder};
use futures::StreamExt;
use futures::sink::SinkExt;
use bytes::Bytes;
use serde::{Serialize, Deserialize};
use bincode;
#[derive(Serialize, Deserialize, Debug)]
struct Message {
pub ticker: String,
pub amount: f32
}
#[tokio::main]
async fn main() {
let addr = "127.0.0.1:8080".to_string();
let listener = TcpListener::bind(&addr).await.unwrap();
println!("Listening on: {}", addr);
loop {
let (socket, _) = listener.accept().await.unwrap();
tokio::spawn(async move {
let mut framed = BytesCodec::new().framed(socket);
let message = framed.next().await.unwrap();
match message {
Ok(bytes) => {
let message = bincode::deserialize::<Message>(&bytes).unwrap();
println!("{:?}", message);
let message_bin = bincode::serialize(&message).unwrap();
let sending_message = Bytes::from(message_bin);
framed.send(sending_message).await.unwrap();
},
Err(err) => println!("Socket closed with error: {:?}", err),
}
println!("Socket received FIN packet and closed connection");
});
}
}
| 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/chapter17/http_server/echo_server/client/src/main.rs | chapter17/http_server/echo_server/client/src/main.rs | use tokio::net::TcpStream;
use tokio_util::codec::{BytesCodec, Decoder};
use futures::sink::SinkExt;
use futures::StreamExt;
use bytes::Bytes;
use serde::{Serialize, Deserialize};
use bincode;
use std::error::Error;
#[derive(Serialize, Deserialize, Debug)]
struct Message {
pub ticker: String,
pub amount: f32
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
let stream = TcpStream::connect("127.0.0.1:8080").await?;
let mut framed = BytesCodec::new().framed(stream);
let message = Message{ticker: String::from("BYND"), amount: 3.2};
let message_bin = bincode::serialize(&message).unwrap();
let sending_message = Bytes::from(message_bin);
framed.send(sending_message).await.unwrap();
let message = framed.next().await.unwrap().unwrap();
let message = bincode::deserialize::<Message>(&message).unwrap();
println!("{:?}", message);
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/chapter17/http_server/simulation/src/actors.rs | chapter17/http_server/simulation/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 {
return 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).await;
}
}
}
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/chapter17/http_server/simulation/src/main.rs | chapter17/http_server/simulation/src/main.rs | use tokio::net::TcpListener;
use tokio::io::{BufReader, AsyncBufReadExt, AsyncWriteExt};
use tokio::sync::mpsc;
mod actors;
mod order_tracker;
use actors::{OrderBookActor, BuyOrder, Message};
use order_tracker::{TrackerActor, GetTrackerActor, TrackerMessage};
#[tokio::main]
async fn main() {
let addr = "127.0.0.1:8080".to_string();
let socket = TcpListener::bind(&addr).await.unwrap();
println!("Listening on: {}", addr);
let (tx, rx) = mpsc::channel::<Message>(1);
let (tracker_tx, tracker_rx) = mpsc::channel::<TrackerMessage>(1);
let tracker_tx_one = tracker_tx.clone();
tokio::spawn(async move {
let tracker_actor = TrackerActor::new(tracker_rx);
tracker_actor.run().await;
});
tokio::spawn(async move {
let order_book_actor = OrderBookActor::new(rx, tracker_tx_one.clone(), 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();
let tracker_tx_two = tracker_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();
println!("here is the data {:?}", data);
let command = data[0].clone();
match command.as_str() {
"BUY" => {
println!("buy order command processed");
let amount = data[1].parse::<f32>().unwrap();
let order_actor = BuyOrder::new(amount, data[2].clone(), tx_one.clone());
println!("{}: {}", order_actor.ticker, order_actor.amount);
order_actor.send().await;
},
"GET" => {
println!("get order command processed");
let get_actor = GetTrackerActor{sender: tracker_tx_two.clone()};
let state = get_actor.send().await;
println!("sending back: {:?}", state);
writer.write_all(state.as_bytes()).await.unwrap();
},
_ => {
panic!("{} command not supported", command);
}
}
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/chapter17/http_server/simulation/src/order_tracker.rs | chapter17/http_server/simulation/src/order_tracker.rs | use tokio::sync::{mpsc, oneshot};
use std::collections::HashMap;
pub struct TrackerMessage {
pub command: String,
pub ticker: Option<String>,
pub amount: Option<f32>,
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: "GET".to_string(), ticker: None, amount: None, 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 {
let db: HashMap<String, f32> = HashMap::new();
return TrackerActor { receiver, db}
}
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(key.clone());
buffer.push(":".to_string());
buffer.push(format!("{};", amount));
}
buffer.push("\n".to_string());
println!("sending state: {}", buffer.join(""));
let _ = respond_to.send(buffer.join(""));
}
fn handle_message(&mut self, message: TrackerMessage) {
match message.command.as_str() {
"GET" => {
println!("getting state");
self.send_state(message.respond_to);
},
"BUY" => {
let ticker = message.ticker.unwrap();
let amount = message.amount.unwrap();
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);
},
_ => {
panic!("{} command is not supported", message.command);
}
}
}
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/chapter17/http_server/clean_web_app/src/jwt.rs | chapter17/http_server/clean_web_app/src/jwt.rs | use actix_web::dev::Payload;
use actix_web::{Error, FromRequest, HttpRequest};
use actix_web::error::ErrorUnauthorized;
use futures::future::{Ready, ok, err};
use serde::{Deserialize, Serialize};
use jsonwebtoken::{encode, decode, Header, EncodingKey, DecodingKey, Validation};
use chrono::Utc;
use std::env;
/// The attributes extracted from the auth token hiding in the header.
///
/// # Attributes
/// * user_id (i32): the ID of the user who's token it belongs to
/// * language (Option<String>): the language of the user
/// * class_id (Option<i32>): the ID of the class the user is associated with
///
/// # Usage
/// This can be inserted into a view function like the following example:
///
/// ```rust
/// async fn test(token: jwt::JwToken) -> String {
/// let user_id: i32 = token.user_id;
/// return String::from("it's working")
/// }
/// ```
/// What this does is extract the JWT from the header before it hits the view and passes it as a parameters into the
/// view.
// #[serde_as]
#[derive(Debug, Serialize, Deserialize)]
pub struct JwToken {
pub user_id: i32,
pub exp: usize,
}
impl JwToken {
pub fn get_key() -> String {
let key_str = env::var("SECRET_KEY").unwrap();
return key_str.to_owned()
}
pub fn encode(self) -> String {
let key = EncodingKey::from_secret(JwToken::get_key().as_ref());
let token = encode(&Header::default(), &self, &key).unwrap();
return token
}
pub fn new(user_id: i32) -> Self {
let minutes = env::var("EXPIRE_MINUTES").unwrap().parse::<i64>().unwrap();
let expiration = Utc::now()
.checked_add_signed(chrono::Duration::minutes(minutes))
.expect("valid timestamp")
.timestamp();
return JwToken { user_id, exp: expiration as usize };
}
pub fn from_token(token: String) -> Result<Self, String> {
let key = DecodingKey::from_secret(JwToken::get_key().as_ref());
let token_result = decode::<JwToken>(&token.as_str(), &key, &Validation::default());
match token_result {
Ok(data) => {
return Ok(data.claims)
},
Err(error) => {
let message = format!("{}", error);
return Err(message)
}
}
}
}
impl FromRequest for JwToken {
type Error = Error;
type Future = Ready<Result<JwToken, Error>>;
/// This gets fired when the JwToken is attached to a request. It fires before the request hits the view.
/// # Arguments
/// The arguments are needed in order for the impl of FromRequest to work.
///
/// * req (&HttpRequest): the request that the token is going to be extracted from
/// * _ (Payload): the payload stream (not used in this function but is needed)
fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
match req.headers().get("token") {
Some(data) => {
let raw_token = data.to_str().unwrap().to_string();
let token_result = JwToken::from_token(raw_token);
match token_result {
Ok(token) => {
return ok(token)
},
Err(message) => {
if message == "ExpiredSignature".to_owned() {
return err(ErrorUnauthorized("token expired"))
}
return err(ErrorUnauthorized("token can't be decoded"))
}
}
},
None => {
return err(ErrorUnauthorized("token not in header under key 'token'"))
}
}
}
}
#[cfg(test)]
mod jwt_tests {
use std::str::FromStr;
use super::JwToken;
use actix_web::{HttpRequest, HttpResponse, test::TestRequest, web, App};
use actix_web::http::header::{HeaderValue, HeaderName, ContentType};
use actix_web::test::{init_service, call_service};
use actix_web;
use serde_json::json;
use serde::{Deserialize, Serialize};
#[derive(Debug, Serialize, Deserialize)]
pub struct ResponseFromTest {
pub user_id: i32,
}
#[test]
fn get_key() {
assert_eq!(String::from("secret"), JwToken::get_key());
}
#[test]
fn decode_incorrect_token() {
let encoded_token: String = String::from("test");
match JwToken::from_token(encoded_token) {
Err(message) => assert_eq!("InvalidToken", message),
_ => panic!(
"Incorrect token should not be able to be encoded"
)
}
}
#[test]
fn encode_decode() {
let test_token = JwToken::new(5);
let encoded_token = test_token.encode();
let new_token = JwToken::from_token(encoded_token).unwrap();
assert_eq!(5, new_token.user_id);
}
async fn test_handler(token: JwToken, _: HttpRequest) -> HttpResponse {
return HttpResponse::Ok().json(json!({"user_id": token.user_id}))
}
#[actix_web::test]
async fn test_no_token_request() {
let app = init_service(App::new().route("/", web::get().to(test_handler))).await;
let req = TestRequest::default()
.insert_header(ContentType::plaintext())
.to_request();
let resp = call_service(&app, req).await;
assert_eq!("401", resp.status().as_str());
}
#[actix_web::test]
async fn test_passing_token_request() {
let test_token = JwToken::new(5);
let encoded_token = test_token.encode();
let app = init_service(App::new().route("/", web::get().to(test_handler))).await;
let mut req = TestRequest::default()
.insert_header(ContentType::plaintext())
.to_request();
let header_name = HeaderName::from_str("token").unwrap();
let header_value = HeaderValue::from_str(encoded_token.as_str()).unwrap();
req.headers_mut().insert(header_name, header_value);
let resp: ResponseFromTest = actix_web::test::call_and_read_body_json(&app, req).await;
assert_eq!(5, resp.user_id);
}
#[actix_web::test]
async fn test_false_token_request() {
let app = init_service(App::new().route("/", web::get().to(test_handler))).await;
let mut req = TestRequest::default()
.insert_header(ContentType::plaintext())
.to_request();
let header_name = HeaderName::from_str("token").unwrap();
let header_value = HeaderValue::from_str("test").unwrap();
req.headers_mut().insert(header_name, header_value);
let resp = call_service(&app, req).await;
assert_eq!("401", resp.status().as_str());
}
} | 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/chapter17/http_server/clean_web_app/src/database.rs | chapter17/http_server/clean_web_app/src/database.rs | use actix_web::dev::Payload;
use actix_web::error::ErrorServiceUnavailable;
use actix_web::{Error, FromRequest, HttpRequest};
use futures::future::{Ready, ok, err};
use lazy_static::lazy_static;
use diesel::{
r2d2::{Pool, ConnectionManager, PooledConnection},
pg::PgConnection,
};
use std::env;
type PgPool = Pool<ConnectionManager<PgConnection>>;
/// This struct is responsble handling a pooled database connection.
///
/// # Attributes
/// * db_connection (PgPool): the connection pool for the database
pub struct DbConnection {
pub db_connection: PgPool,
}
lazy_static! {
pub static ref DBCONNECTION: DbConnection = {
let connection_string = env::var("DB_URL").unwrap();
DbConnection {
db_connection: PgPool::builder()
.max_size(8)
.build(ConnectionManager::new(connection_string))
.expect("failed to create db connection_pool")
}
};
}
/// This struct is responsible for getting a pooled database connection for a web request.ConnectionManager
///
/// # Attribtes
/// * connection (PooledConnection<ConnectionManager<PgConnection>>): a pooled connection for the database
pub struct DB {
pub connection: PooledConnection<ConnectionManager<PgConnection>>
}
impl FromRequest for DB {
type Error = Error;
type Future = Ready<Result<DB, Error>>;
// type Config = ();
/// This gets fired before the request in order to get the database connection for the view.
///
/// # Usage
/// This can be inserted into a view function like the following example:
///
/// ```rust
/// async fn test(db: database::DB) -> String {
/// let connection: PooledConnection<ConnectionManager<PgConnection>> = db.connection;
/// return String::from("it's working")
/// }
/// ```
fn from_request(_: &HttpRequest, _: &mut Payload) -> Self::Future {
match DBCONNECTION.db_connection.get() {
Ok(connection) => {
return ok(DB{connection})
},
Err(_) => {
return err(ErrorServiceUnavailable("could not make connection to database"))
}
}
}
} | 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/chapter17/http_server/clean_web_app/src/schema.rs | chapter17/http_server/clean_web_app/src/schema.rs | table! {
to_do (id) {
id -> Int4,
title -> Varchar,
status -> Varchar,
date -> Timestamp,
user_id -> Int4,
}
}
table! {
users (id) {
id -> Int4,
username -> Varchar,
email -> Varchar,
password -> Varchar,
unique_id -> Varchar,
}
}
joinable!(to_do -> users (user_id));
allow_tables_to_appear_in_same_query!(
to_do,
users,
);
| 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/chapter17/http_server/clean_web_app/src/counter.rs | chapter17/http_server/clean_web_app/src/counter.rs | extern crate serde_pickle;
use serde::{Deserialize, Serialize};
use std::env;
#[derive(Serialize, Deserialize, Debug)]
pub struct Counter {
pub count: i32
}
impl Counter {
fn get_redis_url() -> String {
let redis_url = env::var("REDIS_URL").unwrap();
return redis_url
}
pub fn save(self) {
let serialized = serde_pickle::to_vec(&self, Default::default()).unwrap();
let client = redis::Client::open(Counter::get_redis_url()).unwrap();
let mut con = client.get_connection().unwrap();
let _ : () = redis::cmd("SET").arg("COUNTER").arg(serialized).query(&mut con).unwrap();
}
pub fn load() -> Counter {
let client = redis::Client::open(Counter::get_redis_url()).unwrap();
let mut con = client.get_connection().unwrap();
let byte_data: Vec<u8> = redis::cmd("GET").arg("COUNTER").query(&mut con).unwrap();
let deserialized: Counter = serde_pickle::from_slice(&byte_data, Default::default()).unwrap();
return deserialized
}
} | 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/chapter17/http_server/clean_web_app/src/main.rs | chapter17/http_server/clean_web_app/src/main.rs | #[macro_use] extern crate diesel;
extern crate dotenv;
use actix_web::{App, HttpServer, HttpResponse, middleware::Logger};
use actix_service::Service;
use futures::future::{ok, Either};
use actix_cors::Cors;
mod schema;
mod database;
mod views;
mod to_do;
mod json_serialization;
mod jwt;
mod models;
mod counter;
#[actix_web::main]
async fn main() -> std::io::Result<()> {
const ALLOWED_VERSION: &'static str = "v1";
let site_counter = counter::Counter{count: 0};
site_counter.save();
env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
HttpServer::new(|| {
let cors = Cors::default().allow_any_origin().allow_any_method().allow_any_header();
let app = App::new()
.wrap_fn(|req, srv|{
let passed: bool;
let mut site_counter = counter::Counter::load();
site_counter.count += 1;
site_counter.save();
if *&req.path().contains(&format!("/{}/", ALLOWED_VERSION)) {
passed = true;
} else {
passed = false;
}
let end_result = match passed {
true => {
Either::Left(srv.call(req))
},
false => {
let resp = HttpResponse::NotImplemented().body(format!("only {} API is supported {}", ALLOWED_VERSION, &req.path()));
Either::Right(
ok(req.into_response(resp).map_into_boxed_body())
)
}
};
async move {
let result = end_result.await?;
Ok(result)
}
}).configure(views::views_factory).wrap(cors).wrap(Logger::new("%a %{User-Agent}i %r %s %D"));
return app
})
.bind("0.0.0.0: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/chapter17/http_server/clean_web_app/src/json_serialization/to_do_item.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/json_serialization/login_response.rs | chapter17/http_server/clean_web_app/src/json_serialization/login_response.rs | use serde::Serialize;
#[derive(Serialize)]
pub struct LoginResponse {
pub token: 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/chapter17/http_server/clean_web_app/src/json_serialization/to_do_items.rs | chapter17/http_server/clean_web_app/src/json_serialization/to_do_items.rs | use crate::diesel;
use diesel::prelude::*;
use serde::Serialize;
use std::vec::Vec;
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::to_do::{to_do_factory, enums::TaskStatus};
use crate::database::DBCONNECTION;
use crate::models::item::item::Item;
use crate::schema::to_do;
/// This struct is responsible
#[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(user_id: i32) -> ToDoItems {
let connection = DBCONNECTION.db_connection.get().unwrap();
let mut array_buffer = Vec::new();
let items = to_do::table
.filter(to_do::columns::user_id.eq(&user_id))
.order(to_do::columns::id.asc())
.load::<Item>(&connection)
.unwrap();
for item in items {
let status = TaskStatus::new(&item.status.as_str());
let item = to_do_factory(&item.title, status);
array_buffer.push(item);
}
return ToDoItems::new(array_buffer)
}
}
impl Responder for ToDoItems {
type Body = BoxBody;
/// This function gets fired when the struct is being returned in an actix view.
///
/// # Arguments
/// * _req (&HttpRequest): the request belonging to the view
///
/// # Returns
/// * (Self::Future): a OK HTTP response with the serialized struct in the body
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/chapter17/http_server/clean_web_app/src/json_serialization/login.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/json_serialization/mod.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/json_serialization/new_user.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/models/mod.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/models/user/user.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/models/user/mod.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/models/user/new_user.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/models/item/mod.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/models/item/item.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/models/item/new_item.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/views/mod.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/views/auth/login.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/views/auth/mod.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/views/auth/logout.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/views/app/items.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/views/app/content_loader.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/views/app/mod.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/views/users/mod.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/views/users/create.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/views/to_do/mod.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/views/to_do/edit.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/views/to_do/create.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/views/to_do/get.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/views/to_do/delete.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/to_do/enums.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/to_do/mod.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/to_do/structs/pending.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/to_do/structs/base.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/to_do/structs/mod.rs | chapter17/http_server/clean_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/chapter17/http_server/clean_web_app/src/to_do/structs/done.rs | chapter17/http_server/clean_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/chapter17/http_server/hyper_actors/src/main.rs | chapter17/http_server/hyper_actors/src/main.rs | use tokio::sync::{mpsc, mpsc::Sender};
use hyper::{Body, Request, Response, Server};
use hyper::body;
use hyper::service::{make_service_fn, service_fn};
use serde_json;
use serde::Deserialize;
use std::net::SocketAddr;
mod actors;
use actors::state::StateActor;
use actors::runner::RunnerActor;
use actors::messages::StateActorMessage;
use actors::messages::MessageType;
/// This struct is responsible for deserializing JSON data from incoming HTTP requests.
///
/// # Fields
/// * chat_id: the ID of the patient the chat data belongs to
/// * turn: the turn that the chat data belongs to
/// * input: the question asked to the chatbot
/// * output: the output that the chatbot gave to the question asked
#[derive(Deserialize, Debug)]
struct IncomingBody {
pub chat_id: i32,
pub turn: i32,
pub input: String,
pub output: String
}
/// Handles the incoming requests for the server.
///
/// # Arguments
/// * req: the HTTP request that the server has accepted
/// * channel_sender: the sender to enable messages to be sent over a channel to the state actor
async fn handle(req: Request<Body>, channel_sender: Sender<StateActorMessage>) -> Result<Response<Body>, &'static str> {
println!("incoming message from the outside");
let method = req.method().clone();
println!("{}", method);
let uri = req.uri();
println!("{}", uri);
let bytes = body::to_bytes(req.into_body()).await.unwrap();
let string_body = String::from_utf8(bytes.to_vec()).expect("response was not valid utf-8");
let value: IncomingBody = serde_json::from_str(&string_body.as_str()).unwrap();
let message = StateActorMessage {
message_type: MessageType::INPUT,
chat_id: Some(value.chat_id),
single_data: Some(format!("{}>>{}>>{}>>", value.input, value.output, value.turn)),
block_data: None
};
channel_sender.send(message).await.unwrap();
Ok(Response::new(format!("{:?}", value).into()))
}
#[tokio::main]
async fn main() {
let addr = SocketAddr::from(([0, 0, 0, 0], 3000));
// define the two channels to enable communication throughout
let (state_tx, state_rx) = mpsc::channel::<StateActorMessage>(1);
let (runner_tx, runner_rx) = mpsc::channel::<StateActorMessage>(1);
let channel_sender = state_tx.clone();
// spin off a thread for our state actor
tokio::spawn(async move {
let state_actor = StateActor::new(state_rx, runner_tx);
state_actor.run().await;
});
// spin off a thread for our lib runner actor
tokio::spawn(async move {
let lib_runner_actor = RunnerActor::new(runner_rx, state_tx, 30);
lib_runner_actor.run().await;
});
// run the server
let server = Server::bind(&addr).serve(make_service_fn( |_conn| {
let channel = channel_sender.clone();
async {
// async block is only executed once, so just pass it on to the closure
Ok::<_, hyper::Error>(service_fn( move |req| {
// but this closure may also be called multiple times, so make
// a clone for each call, and move the clone into the async block
let channel = channel.clone();
// async move { handle(req, channel).await }
async {handle(req, channel).await}
}))
}
}));
if let Err(e) = server.await {
eprintln!("server error: {}", e);
}
}
| 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/chapter17/http_server/hyper_actors/src/actors/messages.rs | chapter17/http_server/hyper_actors/src/actors/messages.rs | use serde::Serialize;
use std::env;
/// The type of message being send across a channel.
///
/// # Fields
/// * INPUT: to denote messages that are inserting data into the state actor
/// * OUTPUT: to denote messages that are asking for data output from the state
/// * EMPTY: to denote messages that are returning nothing from the state because the state is empty
#[derive(Debug, Serialize)]
pub enum MessageType {
INPUT,
OUTPUT,
EMPTY
}
/// JSON body that is going to be sent via HTTP to the librarian server.
///
/// # Fields
/// * chat_id: the ID of the chat the chat data belongs to
/// * block_data: the chat history of the patient
#[derive(Debug, Serialize)]
struct PostBody {
pub chat_id: i32,
pub block_data: String
}
/// This struct defines messages being sent to the state actor.
///
/// # Fields
/// * message_type: the type of message, if we are sending an input or output message
/// * chat_id: the ID of the chat in which we update the data for
/// * single_data: if input, this field will be populated to be inserted
/// * block_data: if output, the entire chat history of the patient to be sent to the librarian server
#[derive(Debug, Serialize)]
pub struct StateActorMessage {
pub message_type: MessageType,
pub chat_id: Option<i32>,
pub single_data: Option<String>,
pub block_data: Option<Vec<String>>
}
impl StateActorMessage {
/// Sends ```self.block_data``` to another server.
pub async fn send_to_server(&self) {
let lib_url = env::var("SERVER_URL").unwrap();
let joined = self.block_data.clone().unwrap().join("$");
let body = PostBody {
chat_id: self.chat_id.unwrap(),
block_data: joined
};
let client = reqwest::Client::new();
let res = client.post(lib_url)
.json(&body)
.send()
.await.unwrap();
println!("{:?}", res);
}
}
| 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/chapter17/http_server/hyper_actors/src/actors/runner.rs | chapter17/http_server/hyper_actors/src/actors/runner.rs | use super::messages::{MessageType, StateActorMessage};
use tokio::sync::mpsc;
use std::{thread, time};
type Receiver = mpsc::Receiver<StateActorMessage>;
type Sender = mpsc::Sender<StateActorMessage>;
/// This struct is an actor that periodically pings the state actor throughout the program to send batches of data to another server.
///
/// # Fields
/// * interval: the number of seconds between each loop iteration
/// * receiver: the channel receiver in which the actor receives messages from
/// * sender: the channel sender in which the actor sends messages to
pub struct RunnerActor {
pub interval: i32,
pub receiver: Receiver,
pub sender: Sender,
}
impl RunnerActor {
/// The constructor for the LibRunnerActor struct.
///
/// # Arguments
/// * receiver: the channel receiver in which the actor receives messages from
/// * sender: the channel sender in which the actor sends messages to
/// * interval: the number of seconds between each loop iteration
pub fn new(receiver: Receiver, sender: Sender, interval: i32) -> RunnerActor {
return RunnerActor { interval, receiver, sender }
}
/// Runs the actor throughout the lifetime of the program.
pub async fn run(mut self) {
println!("runner actor is running");
let seconds = time::Duration::from_secs(self.interval as u64);
loop {
thread::sleep(seconds);
let message = StateActorMessage {
message_type: MessageType::OUTPUT,
chat_id: None,
single_data: None,
block_data: None
};
match self.sender.send(message).await {
Ok(_) => {
let message = self.receiver.recv().await.unwrap();
match message.message_type {
MessageType::OUTPUT => {
message.send_to_server().await;
},
_ => {
println!("state is empty");
}
}
},
Err(_) => {
println!("runner is failed to send message");
}
};
}
}
}
| 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/chapter17/http_server/hyper_actors/src/actors/state.rs | chapter17/http_server/hyper_actors/src/actors/state.rs | use std::collections::{HashMap, VecDeque};
use std::mem;
use tokio::sync::mpsc;
use super::messages::{MessageType, StateActorMessage};
type Receiver = mpsc::Receiver<StateActorMessage>;
type Sender = mpsc::Sender<StateActorMessage>;
/// This actor is responsible for managing the state of all the chat logs for all chat IDs.
///
/// # Fields
/// * chat_queue: the order in which the chats were inserted into the state
/// * chats_logs: the chat logs in relation to the patient
/// * receiver: the receiver that accepts INPUT and OUTPUT messages through a channel
/// * sender: the sender that sends messages through a channel
#[derive(Debug)]
pub struct StateActor {
pub chat_queue: VecDeque<i32>,
pub chat_logs: HashMap<i32, Vec<String>>,
pub receiver: Receiver,
pub sender: Sender,
}
impl StateActor {
/// The constructor for the StateActor struct.
///
/// # Arguments
/// * receiver: the receiver that accepts INPUT and OUTPUT messages through a channel
/// * sender: the sender that sends messages through a channel
///
/// # Returns
/// The constructed state actor
pub fn new(receiver: Receiver, sender: Sender) -> StateActor {
let chat_queue: VecDeque<i32> = VecDeque::new();
let chat_logs: HashMap<i32, Vec<String>> = HashMap::new();
return StateActor {chat_queue, chat_logs, receiver, sender}
}
/// Gets message data from the ```self.chat_logs```.
///
/// # Arguments
/// * chat_id: the ID of the patient's chat logs to be extracted
///
/// # Returns
/// * chat log data that belongs to the patient
pub fn get_message_data(&mut self, chat_id: i32) -> Vec<String> {
let reference = self.chat_logs.get_mut(&chat_id).unwrap();
let data = mem::take(reference);
self.chat_logs.remove(&chat_id);
return data
}
/// Inserts a message into the ```self.chat_logs```.
///
/// # Arguments
/// * chat_id: the ID of the patient's chat logs to be inserted
/// * message_data: the message data that is going to be inserted into the chat log
pub fn insert_message(&mut self, chat_id: i32, message_data: String) {
match self.chat_logs.get_mut(&chat_id) {
Some(patient_log) => {
patient_log.push(message_data);
},
None => {
self.chat_queue.push_back(chat_id);
let mut patient_log = Vec::new();
patient_log.push(message_data);
self.chat_logs.insert(chat_id, patient_log);
}
}
}
/// Processes an incoming message to either send chat log data out or insert new chat data.
///
/// # Arguments
/// message: the message to be processed
async fn handle_message(&mut self, message: StateActorMessage) {
println!("state actor is receiving a message");
match message.message_type {
MessageType::INPUT => {
self.insert_message(message.chat_id.unwrap(), message.single_data.unwrap());
},
MessageType::OUTPUT => {
match self.chat_queue.pop_front() {
Some(chat_id) => {
let data = self.get_message_data(chat_id);
let message = StateActorMessage {
message_type: MessageType::OUTPUT,
chat_id: Some(chat_id),
single_data: None,
block_data: Some(data)
};
let _ = self.sender.send(message).await.unwrap();
},
None => {
let message = StateActorMessage {
message_type: MessageType::EMPTY,
chat_id: None,
single_data: None,
block_data: None
};
let _ = self.sender.send(message).await.unwrap();
}
}
},
MessageType::EMPTY => {
panic!("empty messages should not be sent to the state actor");
}
}
println!("{:?}", self.chat_logs);
println!("{:?}", self.chat_queue);
}
/// Runs the actor throughout the lifetime of the program accepting messages.
pub async fn run(mut self) {
println!("state actor is running");
while let Some(msg) = self.receiver.recv().await {
self.handle_message(msg).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/chapter17/http_server/hyper_actors/src/actors/mod.rs | chapter17/http_server/hyper_actors/src/actors/mod.rs | pub mod messages;
pub mod runner;
pub mod 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/chapter17/http_server/task_scheduler/src/main.rs | chapter17/http_server/task_scheduler/src/main.rs |
fn main() {
println!("Hello world");
}
| 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/chapter17/http_server/simulation_client/src/main.rs | chapter17/http_server/simulation_client/src/main.rs | use tokio::net::TcpStream;
use tokio::io::{BufReader, AsyncBufReadExt, 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?;
let (reader, mut writer) = stream.split();
println!("stream starting");
writer.write_all(b"BUY;8.0;BYND;\nBUY;9.0;PLTR\nBUY;9.0;PLTR\nGET\n").await?;
println!("sent data");
let mut buf_reader = BufReader::new(reader);
let mut buf = vec![];
println!("reading data");
let _ = buf_reader.read_until(b'\n', &mut buf).await.unwrap();
let state_string = String::from_utf8_lossy(&buf);
println!("{}", state_string);
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/chapter17/http_server/rocket_app/src/config.rs | chapter17/http_server/rocket_app/src/config.rs | use std::collections::HashMap;
use std::env;
use serde_yaml;
/// Holds configuration parameters for the application
///
/// # Attributes
/// * map (HashMap<String, serde_yaml::Value>): the map of parameters for the app
pub struct Config {
pub map: HashMap<String, serde_yaml::Value>
}
impl Config {
/// Creates a new Config map with loaded data from a yml file where the path is from the last argument
/// passed into the program.
///
/// # Arguments
/// None
///
/// # Returns
/// (Config): a loaded Config struct
#[cfg(not(test))]
pub fn new() -> Config {
let args: Vec<String> = env::args().collect();
let file_path = &args[args.len() - 1];
let file = std::fs::File::open(file_path).unwrap();
let map: HashMap<String, serde_yaml::Value> = serde_yaml::from_reader(file).unwrap();
return Config{map}
}
#[cfg(test)]
pub fn new() -> Config {
let mut map = HashMap::new();
map.insert(String::from("DB_URL"), serde_yaml::from_str("postgres://username:password@localhost:5433/to_do").unwrap());
map.insert(String::from("SECRET_KEY"), serde_yaml::from_str("secret").unwrap());
map.insert(String::from("EXPIRE_MINUTES"), serde_yaml::from_str("120").unwrap());
map.insert(String::from("REDIS_URL"), serde_yaml::from_str("redis://127.0.0.1/").unwrap());
return Config {map}
}
}
| 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/chapter17/http_server/rocket_app/src/jwt.rs | chapter17/http_server/rocket_app/src/jwt.rs | use rocket::http::Status;
use rocket::request::{Outcome, Request, FromRequest};
use serde::{Deserialize, Serialize};
use jsonwebtoken::{encode, decode, Header, EncodingKey, DecodingKey, Validation};
use chrono::Utc;
use crate::config::Config;
#[derive(Debug)]
pub enum JwTokenError {
Missing,
Invalid,
Expired
}
/// The attributes extracted from the auth token hidding in the header.
///
/// # Attributes
/// * user_id (i32): the ID of the user who's token it belongs to
/// * language (Option<String>): the language of the user
/// * class_id (Option<i32>): the ID of the class the user is associated with
///
/// # Usage
/// This can be inserted into a view function like the following example:
///
/// ```rust
/// async fn test(token: jwt::JwToken) -> String {
/// let user_id: i32 = token.user_id;
/// return String::from("it's working")
/// }
/// ```
/// What this does is extract the JWT from the header before it hits the view and passes it as a parameters into the
/// view.
// #[serde_as]
#[derive(Debug, Serialize, Deserialize)]
pub struct JwToken {
pub user_id: i32,
pub exp: usize,
}
impl JwToken {
pub fn get_key() -> String {
let config = Config::new();
let key_str = config.map.get("SECRET_KEY").unwrap().as_str().unwrap();
return key_str.to_owned()
}
pub fn encode(self) -> String {
let key = EncodingKey::from_secret(JwToken::get_key().as_ref());
let token = encode(&Header::default(), &self, &key).unwrap();
return token
}
pub fn new(user_id: i32) -> Self {
let config = Config::new();
let minutes = config.map.get("EXPIRE_MINUTES").unwrap().as_i64().unwrap();
let expiration = Utc::now()
.checked_add_signed(chrono::Duration::minutes(minutes))
.expect("valid timestamp")
.timestamp();
return JwToken { user_id, exp: expiration as usize };
}
pub fn from_token(token: String) -> Result<Self, String> {
let key = DecodingKey::from_secret(JwToken::get_key().as_ref());
let token_result = decode::<JwToken>(&token.as_str(), &key, &Validation::default());
match token_result {
Ok(data) => {
return Ok(data.claims)
},
Err(error) => {
let message = format!("{}", error);
return Err(message)
}
}
}
}
#[rocket::async_trait]
impl<'r> FromRequest<'r> for JwToken {
type Error = JwTokenError;
async fn from_request(req: &'r Request<'_>) -> Outcome<Self, Self::Error> {
match req.headers().get_one("token") {
Some(data) => {
let raw_token = data.to_string();
let token_result = JwToken::from_token(raw_token);
match token_result {
Ok(token) => {
return Outcome::Success(token)
},
Err(message) => {
if message == "ExpiredSignature".to_owned() {
return Outcome::Failure((Status::BadRequest, JwTokenError::Expired))
}
return Outcome::Failure((Status::BadRequest, JwTokenError::Invalid))
}
}
},
None => {
return Outcome::Failure((Status::BadRequest, JwTokenError::Missing))
}
}
}
}
| 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/chapter17/http_server/rocket_app/src/database.rs | chapter17/http_server/rocket_app/src/database.rs | use rocket::http::Status;
use rocket::request::{Outcome, Request, FromRequest};
use lazy_static::lazy_static;
use diesel::{
r2d2::{Pool, ConnectionManager, PooledConnection},
pg::PgConnection,
};
use crate::config::Config;
#[derive(Debug)]
pub enum DBError {
Unavailable
}
type PgPool = Pool<ConnectionManager<PgConnection>>;
/// This struct is responsble handling a pooled database connection.
///
/// # Attributes
/// * db_connection (PgPool): the connection pool for the database
pub struct DbConnection {
pub db_connection: PgPool,
}
lazy_static! {
pub static ref DBCONNECTION: DbConnection = {
let connection_string = Config::new().map.get("DB_URL").unwrap().as_str().unwrap().to_string();
DbConnection {
db_connection: PgPool::builder()
.max_size(8)
.build(ConnectionManager::new(connection_string))
.expect("failed to create db connection_pool")
}
};
}
/// This struct is responsible for getting a pooled database connection for a web request.ConnectionManager
///
/// # Attribtes
/// * connection (PooledConnection<ConnectionManager<PgConnection>>): a pooled connection for the database
pub struct DB {
pub connection: PooledConnection<ConnectionManager<PgConnection>>
}
#[rocket::async_trait]
impl<'r> FromRequest<'r> for DB {
type Error = DBError;
async fn from_request(_: &'r Request<'_>) -> Outcome<Self, Self::Error> {
match DBCONNECTION.db_connection.get() {
Ok(connection) => {
return Outcome::Success(DB{connection})
},
Err(_) => {
return Outcome::Failure((Status::BadRequest, DBError::Unavailable))
}
}
}
}
| 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/chapter17/http_server/rocket_app/src/schema.rs | chapter17/http_server/rocket_app/src/schema.rs | table! {
to_do (id) {
id -> Int4,
title -> Varchar,
status -> Varchar,
date -> Timestamp,
user_id -> Int4,
}
}
table! {
users (id) {
id -> Int4,
username -> Varchar,
email -> Varchar,
password -> Varchar,
unique_id -> Varchar,
}
}
joinable!(to_do -> users (user_id));
allow_tables_to_appear_in_same_query!(
to_do,
users,
);
| 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/chapter17/http_server/rocket_app/src/main.rs | chapter17/http_server/rocket_app/src/main.rs | #[macro_use] extern crate rocket;
#[macro_use] extern crate diesel;
use rocket::http::Header;
use rocket::{Request, Response};
use rocket::fairing::{Fairing, Info, Kind};
mod schema;
mod database;
mod json_serialization;
mod models;
mod to_do;
mod config;
mod jwt;
mod views;
use views::auth::{login::{login, login_get}, logout::logout};
use views::to_do::{create::create, delete::delete, edit::edit, get::get};
use views::users::create::create_user;
#[get("/")]
fn index() -> &'static str {
"Hello, world!"
}
#[get("/hello/<name>/<age>")]
fn hello(name: String, age: u8) -> String {
format!("Hello, {} year old named {}!", age, name)
}
#[get("/bye/<name>/<age>")]
fn bye(name: String, age: u8) -> String {
format!("Goodbye, {} year old named {}!", age,
name)
}
pub struct CORS;
#[rocket::async_trait]
impl Fairing for CORS {
fn info(&self) -> Info {
Info {
name: "Add CORS headers to responses",
kind: Kind::Response
}
}
async fn on_response<'r>(&self, _request: &'r Request<'_>, response: &mut Response<'r>) {
response.set_header(Header::new("Access-Control-Allow-Origin", "*"));
response.set_header(Header::new("Access-Control-Allow-Methods", "POST, GET, PATCH, OPTIONS"));
response.set_header(Header::new("Access-Control-Allow-Headers", "*"));
response.set_header(Header::new("Access-Control-Allow-Credentials", "true"));
}
}
#[launch]
fn rocket() -> _ {
rocket::build().mount("/", routes![index, hello, bye])
.mount("/v1/item/", routes![create, delete, edit, get])
.mount("/v1/auth/", routes![login, logout, login_get])
.mount("/v1/user/", routes![create_user])
.attach(CORS)
.manage(CORS)
}
| 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/chapter17/http_server/rocket_app/src/json_serialization/to_do_item.rs | chapter17/http_server/rocket_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/chapter17/http_server/rocket_app/src/json_serialization/login_response.rs | chapter17/http_server/rocket_app/src/json_serialization/login_response.rs | use serde::Serialize;
#[derive(Serialize)]
pub struct LoginResponse {
pub token: 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/chapter17/http_server/rocket_app/src/json_serialization/to_do_items.rs | chapter17/http_server/rocket_app/src/json_serialization/to_do_items.rs | use crate::diesel;
use diesel::prelude::*;
use serde::Serialize;
use std::vec::Vec;
// 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::to_do::{to_do_factory, enums::TaskStatus};
use crate::database::DBCONNECTION;
use crate::models::item::item::Item;
use crate::schema::to_do;
/// This struct is responsible
#[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(user_id: i32) -> ToDoItems {
let mut array_buffer = Vec::new();
let connection = DBCONNECTION.db_connection.get().unwrap();
let items = to_do::table
.filter(to_do::columns::user_id.eq(&user_id))
.order(to_do::columns::id.asc())
.load::<Item>(&connection)
.unwrap();
for item in items {
let status = TaskStatus::new(&item.status.as_str());
let item = to_do_factory(&item.title, status);
array_buffer.push(item);
}
return ToDoItems::new(array_buffer)
}
}
| 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/chapter17/http_server/rocket_app/src/json_serialization/login.rs | chapter17/http_server/rocket_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/chapter17/http_server/rocket_app/src/json_serialization/mod.rs | chapter17/http_server/rocket_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/chapter17/http_server/rocket_app/src/json_serialization/new_user.rs | chapter17/http_server/rocket_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/chapter17/http_server/rocket_app/src/json_serialization/json_serialization/to_do_item.rs | chapter17/http_server/rocket_app/src/json_serialization/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/chapter17/http_server/rocket_app/src/json_serialization/json_serialization/login_response.rs | chapter17/http_server/rocket_app/src/json_serialization/json_serialization/login_response.rs | use serde::Serialize;
#[derive(Serialize)]
pub struct LoginResponse {
pub token: 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/chapter17/http_server/rocket_app/src/json_serialization/json_serialization/to_do_items.rs | chapter17/http_server/rocket_app/src/json_serialization/json_serialization/to_do_items.rs | use crate::diesel;
use diesel::prelude::*;
use serde::Serialize;
use std::vec::Vec;
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::to_do::{to_do_factory, enums::TaskStatus};
use crate::database::DBCONNECTION;
use crate::models::item::item::Item;
use crate::schema::to_do;
/// This struct is responsible
#[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(user_id: i32) -> ToDoItems {
let connection = DBCONNECTION.db_connection.get().unwrap();
let mut array_buffer = Vec::new();
let items = to_do::table
.filter(to_do::columns::user_id.eq(&user_id))
.order(to_do::columns::id.asc())
.load::<Item>(&connection)
.unwrap();
for item in items {
let status = TaskStatus::new(&item.status.as_str());
let item = to_do_factory(&item.title, status);
array_buffer.push(item);
}
return ToDoItems::new(array_buffer)
}
}
impl Responder for ToDoItems {
type Body = BoxBody;
/// This function gets fired when the struct is being returned in an actix view.
///
/// # Arguments
/// * _req (&HttpRequest): the request belonging to the view
///
/// # Returns
/// * (Self::Future): a OK HTTP response with the serialized struct in the body
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/chapter17/http_server/rocket_app/src/json_serialization/json_serialization/login.rs | chapter17/http_server/rocket_app/src/json_serialization/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/chapter17/http_server/rocket_app/src/json_serialization/json_serialization/mod.rs | chapter17/http_server/rocket_app/src/json_serialization/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/chapter17/http_server/rocket_app/src/json_serialization/json_serialization/new_user.rs | chapter17/http_server/rocket_app/src/json_serialization/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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.