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/chapter05/wrapping_in_electron/web_app/src/views/to_do/delete.rs | chapter05/wrapping_in_electron/web_app/src/views/to_do/delete.rs | use actix_web::{web, HttpResponse};
use serde_json::value::Value;
use serde_json::Map;
use crate::to_do::{to_do_factory, enums::TaskStatus};
use crate::json_serialization::{to_do_item::ToDoItem,
to_do_items::ToDoItems};
use crate::processes::process_input;
use crate::jwt::JwToken;
use crate::state::read_file;
pub async fn delete(to_do_item: web::Json<ToDoItem>, token: JwToken) -> HttpResponse {
let state: Map<String, Value> = read_file("./state.json");
let status: TaskStatus;
match &state.get(&to_do_item.title) {
Some(result) => {
status = TaskStatus::from_string(result.as_str().unwrap().to_string());
}
None=> {
return HttpResponse::NotFound().json(
format!("{} not in state", &to_do_item.title))
}
}
let existing_item = to_do_factory(to_do_item.title.as_str(), status.clone());
process_input(existing_item, "delete".to_owned(), &state);
return HttpResponse::Ok().json(ToDoItems::get_state())
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/wrapping_in_electron/web_app/src/to_do/enums.rs | chapter05/wrapping_in_electron/web_app/src/to_do/enums.rs | use serde::ser::{Serialize, SerializeStruct, Serializer};
#[derive(Clone)]
pub enum TaskStatus {
DONE,
PENDING
}
impl TaskStatus {
pub fn stringify(&self) -> String {
match &self {
&Self::DONE => {"DONE".to_string()},
&Self::PENDING => {"PENDING".to_string()}
}
}
pub fn from_string(input_string: String) -> Self {
match input_string.as_str() {
"DONE" => TaskStatus::DONE,
"PENDING" => TaskStatus::PENDING,
_ => panic!("input {} not supported",
input_string)
}
}
}
impl Serialize for TaskStatus {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut s = serializer.serialize_struct("TaskStatus", 1)?;
s.serialize_field("status", &self.stringify())?;
s.end()
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/wrapping_in_electron/web_app/src/to_do/mod.rs | chapter05/wrapping_in_electron/web_app/src/to_do/mod.rs | pub mod structs;
pub mod enums;
pub mod traits;
use enums::TaskStatus;
use structs::done::Done;
use structs::pending::Pending;
pub enum ItemTypes {
Pending(Pending),
Done(Done)
}
pub fn to_do_factory(title: &str,
status: TaskStatus) -> ItemTypes {
match status {
TaskStatus::DONE => {
ItemTypes::Done(Done::new(title))
},
TaskStatus::PENDING => {
ItemTypes::Pending(Pending::new(title))
}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/wrapping_in_electron/web_app/src/to_do/structs/pending.rs | chapter05/wrapping_in_electron/web_app/src/to_do/structs/pending.rs | use super::base::Base;
use super::super::enums::TaskStatus;
use super::super::traits::get::Get;
use super::super::traits::edit::Edit;
use super::super::traits::create::Create;
pub struct Pending {
pub super_struct: Base
}
impl Pending {
pub fn new(input_title: &str) -> Self {
let base = Base{
title: input_title.to_string(),
status: TaskStatus::PENDING
};
return Pending{super_struct: base}
}
}
impl Get for Pending {}
impl Edit for Pending {}
impl Create for Pending {}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/wrapping_in_electron/web_app/src/to_do/structs/base.rs | chapter05/wrapping_in_electron/web_app/src/to_do/structs/base.rs | use super::super::enums::TaskStatus;
use serde::Serialize;
#[derive(Serialize)]
pub struct Base {
pub title: String,
pub status: TaskStatus
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/wrapping_in_electron/web_app/src/to_do/structs/mod.rs | chapter05/wrapping_in_electron/web_app/src/to_do/structs/mod.rs | pub mod base;
pub mod done;
pub mod pending;
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/wrapping_in_electron/web_app/src/to_do/structs/done.rs | chapter05/wrapping_in_electron/web_app/src/to_do/structs/done.rs | use super::base::Base;
use super::super::enums::TaskStatus;
use super::super::traits::get::Get;
use super::super::traits::delete::Delete;
use super::super::traits::edit::Edit;
pub struct Done {
pub super_struct: Base
}
impl Done {
pub fn new(input_title: &str) -> Self {
let base = Base {
title: input_title.to_string(),
status: TaskStatus::DONE
};
return Done{super_struct: base}
}
}
impl Get for Done {}
impl Delete for Done {}
impl Edit for Done {}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/wrapping_in_electron/web_app/src/to_do/traits/mod.rs | chapter05/wrapping_in_electron/web_app/src/to_do/traits/mod.rs | pub mod create;
pub mod delete;
pub mod edit;
pub mod get;
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/wrapping_in_electron/web_app/src/to_do/traits/edit.rs | chapter05/wrapping_in_electron/web_app/src/to_do/traits/edit.rs | use serde_json::Map;
use serde_json::value::Value;
use serde_json::json;
use crate::state::write_to_file;
use super::super::enums::TaskStatus;
pub trait Edit {
fn set_to_done(&self, title: &String,
state: &mut Map<String, Value>) {
state.insert(title.to_string(),
json!(TaskStatus::DONE.stringify()));
write_to_file("./state.json", state);
println!("\n\n{} is being set to done\n\n", title);
}
fn set_to_pending(&self, title: &String,
state: &mut Map<String, Value>) {
state.insert(title.to_string(),
json!(TaskStatus::PENDING.stringify()));
write_to_file("./state.json", state);
println!("\n\n{} is being set to pending\n\n", title);
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/wrapping_in_electron/web_app/src/to_do/traits/create.rs | chapter05/wrapping_in_electron/web_app/src/to_do/traits/create.rs | use serde_json::Map;
use serde_json::value::Value;
use serde_json::json;
use crate::state::write_to_file;
pub trait Create {
fn create(&self, title: &String, status: &String,
state: &mut Map<String, Value>) {
state.insert(title.to_string(), json!(status));
write_to_file("./state.json", state);
println!("\n\n{} is being created\n\n", title);
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/wrapping_in_electron/web_app/src/to_do/traits/get.rs | chapter05/wrapping_in_electron/web_app/src/to_do/traits/get.rs | use serde_json::Map;
use serde_json::value::Value;
pub trait Get {
fn get(&self, title: &String, state: &Map<String, Value>) {
let item: Option<&Value> = state.get(title);
match item {
Some(result) => {
println!("\n\nItem: {}", title);
println!("Status: {}\n\n", result);
},
None => println!("item: {} was not found", title)
}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/wrapping_in_electron/web_app/src/to_do/traits/delete.rs | chapter05/wrapping_in_electron/web_app/src/to_do/traits/delete.rs | use serde_json::Map;
use serde_json::value::Value;
use crate::state::write_to_file;
pub trait Delete {
fn delete(&self, title: &String,
state: &mut Map<String, Value>) {
state.remove(title);
write_to_file("./state.json", state);
println!("\n\n{} is being deleted\n\n", title);
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/jwt.rs | chapter05/adding_the_delete_endpoint/web_app/src/jwt.rs | use actix_web::dev::Payload;
use actix_web::{Error, FromRequest, HttpRequest};
use futures::future::{Ready, ok};
pub struct JwToken {
pub message: String
}
impl FromRequest for JwToken {
type Error = Error;
type Future = Ready<Result<JwToken, Error>>;
fn from_request(req: &HttpRequest, _: &mut Payload)
-> Self::Future {
match req.headers().get("token") {
Some(data) => {
let token = JwToken{
message: data.to_str().unwrap().to_string()
};
ok(token)
},
None => {
let token = JwToken{
message: String::from("nothing found")
};
ok(token)
}
}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/state.rs | chapter05/adding_the_delete_endpoint/web_app/src/state.rs | use std::fs::File;
use std::fs;
use std::io::Read;
use serde_json::Map;
use serde_json::value::Value;
use serde_json::json;
pub fn read_file(file_name: &str) -> Map<String, Value> {
let mut file = File::open(file_name.to_string()).unwrap();
let mut data = String::new();
file.read_to_string(&mut data).unwrap();
let json: Value = serde_json::from_str(&data).unwrap();
let state: Map<String, Value> = json.as_object().unwrap().clone();
return state
}
pub fn write_to_file(file_name: &str,
state: &mut Map<String, Value>) {
let new_data = json!(state);
fs::write(
file_name.to_string(),
new_data.to_string()
).expect("Unable to write file");
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/processes.rs | chapter05/adding_the_delete_endpoint/web_app/src/processes.rs | use serde_json::Map;
use serde_json::value::Value;
use super::to_do::ItemTypes;
use super::to_do::structs::done::Done;
use super::to_do::structs::pending::Pending;
use super::to_do::traits::get::Get;
use super::to_do::traits::create::Create;
use super::to_do::traits::delete::Delete;
use super::to_do::traits::edit::Edit;
fn process_pending(item: Pending, command: String, state: &Map<String, Value>) {
let mut state = state.clone();
match command.as_str() {
"get" => item.get(&item.super_struct.title, &state),
"create" => item.create(&item.super_struct.title,
&item.super_struct.status.stringify(), &mut state),
"edit" => item.set_to_done(&item.super_struct.title,
&mut state),
_ => println!("command: {} not supported", command)
}
}
fn process_done(item: Done, command: String, state: &Map<String, Value>) {
let mut state = state.clone();
match command.as_str() {
"get" => item.get(&item.super_struct.title, &state),
"delete" => item.delete(&item.super_struct.title, &mut state),
"edit" => item.set_to_pending(&item.super_struct.title, &mut state),
_ => println!("command: {} not supported", command)
}
}
pub fn process_input(item: ItemTypes, command: String, state: &Map<String, Value>) {
match item {
ItemTypes::Pending(item) => process_pending(item, command, state),
ItemTypes::Done(item) => process_done(item, command, state)
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/main.rs | chapter05/adding_the_delete_endpoint/web_app/src/main.rs | use actix_web::{App, HttpServer};
use actix_service::Service;
mod views;
mod to_do;
mod state;
mod processes;
mod json_serialization;
mod jwt;
#[actix_web::main]
async fn main() -> std::io::Result<()> {
HttpServer::new(|| {
let app = App::new()
.wrap_fn(|req, srv|{
println!("{:?}", req);
let future = srv.call(req);
async {
let result = future.await?;
Ok(result)
}
}).configure(views::views_factory);
return app
})
.bind("127.0.0.1:8000")?
.run()
.await
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/json_serialization/to_do_item.rs | chapter05/adding_the_delete_endpoint/web_app/src/json_serialization/to_do_item.rs | use serde::Deserialize;
#[derive(Deserialize)]
pub struct ToDoItem {
pub title: String,
pub status: String
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/json_serialization/to_do_items.rs | chapter05/adding_the_delete_endpoint/web_app/src/json_serialization/to_do_items.rs | use serde::Serialize;
use std::vec::Vec;
use serde_json::value::Value;
use serde_json::Map;
use actix_web::{
body::BoxBody, http::header::ContentType,
HttpRequest, HttpResponse, Responder,
};
use crate::to_do::ItemTypes;
use crate::to_do::structs::base::Base;
use crate::state::read_file;
use crate::to_do::{to_do_factory, enums::TaskStatus};
#[derive(Serialize)]
pub struct ToDoItems {
pub pending_items: Vec<Base>,
pub done_items: Vec<Base>,
pub pending_item_count: i8,
pub done_item_count: i8
}
impl ToDoItems {
pub fn new(input_items: Vec<ItemTypes>) -> ToDoItems {
let mut pending_array_buffer = Vec::new();
let mut done_array_buffer = Vec::new();
for item in input_items {
match item {
ItemTypes::Pending(packed) => pending_array_buffer.
push(packed.super_struct),
ItemTypes::Done(packed) => done_array_buffer.push(
packed.super_struct)
}
}
let done_count: i8 = done_array_buffer.len() as i8;
let pending_count: i8 = pending_array_buffer.len() as i8;
return ToDoItems{
pending_items: pending_array_buffer,
done_item_count: done_count,
pending_item_count: pending_count,
done_items: done_array_buffer
}
}
pub fn get_state() -> ToDoItems {
let state: Map<String, Value> = read_file("./state.json");
let mut array_buffer = Vec::new();
for (key, value) in state {
let status = TaskStatus::from_string(value.as_str().unwrap().to_string());
let item = to_do_factory(
&key, status);
array_buffer.push(item);
}
return ToDoItems::new(array_buffer)
}
}
impl Responder for ToDoItems {
type Body = BoxBody;
fn respond_to(self, _req: &HttpRequest)
-> HttpResponse<Self::Body> {
let body = serde_json::to_string(&self).unwrap();
HttpResponse::Ok()
.content_type(ContentType::json())
.body(body)
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/json_serialization/mod.rs | chapter05/adding_the_delete_endpoint/web_app/src/json_serialization/mod.rs | pub mod to_do_items;
pub mod to_do_item;
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/views/mod.rs | chapter05/adding_the_delete_endpoint/web_app/src/views/mod.rs | mod auth;
mod to_do;
mod app;
use auth::auth_views_factory;
use to_do::to_do_views_factory; // import the factory
use actix_web::web::ServiceConfig;
pub fn views_factory(app: &mut ServiceConfig) {
auth_views_factory(app);
to_do_views_factory(app); // pass the ServiceConfig
app::app_views_factory(app);
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/views/auth/login.rs | chapter05/adding_the_delete_endpoint/web_app/src/views/auth/login.rs |
pub async fn login() -> String {
format!("Login view")
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/views/auth/mod.rs | chapter05/adding_the_delete_endpoint/web_app/src/views/auth/mod.rs | mod login;
mod logout;
use actix_web::web::{ServiceConfig, get, scope};
pub fn auth_views_factory(app: &mut ServiceConfig) {
app.service(
scope("v1/auth")
.route("login", get().to(login::login))
.route("logout", get().to(logout::logout))
);
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/views/auth/logout.rs | chapter05/adding_the_delete_endpoint/web_app/src/views/auth/logout.rs |
pub async fn logout() -> String {
format!("Logout view")
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/views/app/items.rs | chapter05/adding_the_delete_endpoint/web_app/src/views/app/items.rs | use actix_web::HttpResponse;
use super::content_loader::read_file;
pub async fn items() -> HttpResponse {
let html_data = read_file(
"./templates/main.html");
HttpResponse::Ok()
.content_type("text/html; charset=utf-8")
.body(html_data)
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/views/app/content_loader.rs | chapter05/adding_the_delete_endpoint/web_app/src/views/app/content_loader.rs | use std::fs;
pub fn read_file(file_path: &str) -> String {
let data: String = fs::read_to_string(
file_path).expect("Unable to read file");
return data
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/views/app/mod.rs | chapter05/adding_the_delete_endpoint/web_app/src/views/app/mod.rs | use actix_web::web;
mod items;
mod content_loader;
pub fn app_views_factory(app: &mut web::ServiceConfig) {
app.route("/", web::get().to(items::items));
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/views/to_do/mod.rs | chapter05/adding_the_delete_endpoint/web_app/src/views/to_do/mod.rs | mod create;
mod get;
mod edit;
mod delete;
use actix_web::web::{ServiceConfig, post, get, scope};
pub fn to_do_views_factory(app: &mut ServiceConfig) {
app.service(
scope("v1/item")
.route("create/{title}", post().to(create::create))
.route("get", get().to(get::get))
.route("edit", post().to(edit::edit))
.route("delete", post().to(delete::delete))
);
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/views/to_do/edit.rs | chapter05/adding_the_delete_endpoint/web_app/src/views/to_do/edit.rs | use actix_web::{web, HttpResponse};
use serde_json::value::Value;
use serde_json::Map;
use crate::state::read_file;
use crate::to_do::{to_do_factory, enums::TaskStatus};
use crate::json_serialization::{to_do_item::ToDoItem,
to_do_items::ToDoItems};
use crate::processes::process_input;
use crate::jwt::JwToken;
pub async fn edit(to_do_item: web::Json<ToDoItem>, token: JwToken) -> HttpResponse {
println!("here is the message in the token: {}", token.message);
let state: Map<String, Value> = read_file("./state.json");
let status: TaskStatus;
match &state.get(&to_do_item.title) {
Some(result) => {
status = TaskStatus::from_string(result.as_str()
.unwrap()
.to_string());
}
None=> {
return HttpResponse::NotFound().json(
format!("{} not in state", &to_do_item.title))
}
}
let existing_item = to_do_factory(to_do_item.title.as_str(), status.clone());
if &status.stringify() == &TaskStatus::from_string(
to_do_item.status.as_str().to_string()).stringify() {
return HttpResponse::Ok().json(ToDoItems::get_state())
}
process_input(existing_item, "edit".to_owned(), &state);
return HttpResponse::Ok().json(ToDoItems::get_state())
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/views/to_do/create.rs | chapter05/adding_the_delete_endpoint/web_app/src/views/to_do/create.rs | use actix_web::HttpResponse;
use serde_json::Value;
use serde_json::Map;
use actix_web::HttpRequest;
use crate::to_do::{to_do_factory, enums::TaskStatus};
use crate::json_serialization::to_do_items::ToDoItems;
use crate::state::read_file;
use crate::processes::process_input;
pub async fn create(req: HttpRequest) -> HttpResponse {
let state: Map<String, Value> = read_file("./state.json");
let title: String = req.match_info().get("title"
).unwrap().to_string();
let item = to_do_factory(&title.as_str(),
TaskStatus::PENDING);
process_input(item, "create".to_string(), &state);
return HttpResponse::Ok().json(ToDoItems::get_state())
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/views/to_do/get.rs | chapter05/adding_the_delete_endpoint/web_app/src/views/to_do/get.rs | use actix_web::Responder;
use crate::json_serialization::to_do_items::ToDoItems;
pub async fn get() -> impl Responder {
return ToDoItems::get_state();
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/views/to_do/delete.rs | chapter05/adding_the_delete_endpoint/web_app/src/views/to_do/delete.rs | use actix_web::{web, HttpResponse};
use serde_json::value::Value;
use serde_json::Map;
use crate::to_do::{to_do_factory, enums::TaskStatus};
use crate::json_serialization::{to_do_item::ToDoItem,
to_do_items::ToDoItems};
use crate::processes::process_input;
use crate::jwt::JwToken;
use crate::state::read_file;
pub async fn delete(to_do_item: web::Json<ToDoItem>, token: JwToken) -> HttpResponse {
let state: Map<String, Value> = read_file("./state.json");
let status: TaskStatus;
match &state.get(&to_do_item.title) {
Some(result) => {
status = TaskStatus::from_string(result.as_str().unwrap().to_string());
}
None=> {
return HttpResponse::NotFound().json(
format!("{} not in state", &to_do_item.title))
}
}
let existing_item = to_do_factory(to_do_item.title.as_str(), status.clone());
process_input(existing_item, "delete".to_owned(), &state);
return HttpResponse::Ok().json(ToDoItems::get_state())
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/to_do/enums.rs | chapter05/adding_the_delete_endpoint/web_app/src/to_do/enums.rs | use serde::ser::{Serialize, SerializeStruct, Serializer};
#[derive(Clone)]
pub enum TaskStatus {
DONE,
PENDING
}
impl TaskStatus {
pub fn stringify(&self) -> String {
match &self {
&Self::DONE => {"DONE".to_string()},
&Self::PENDING => {"PENDING".to_string()}
}
}
pub fn from_string(input_string: String) -> Self {
match input_string.as_str() {
"DONE" => TaskStatus::DONE,
"PENDING" => TaskStatus::PENDING,
_ => panic!("input {} not supported",
input_string)
}
}
}
impl Serialize for TaskStatus {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut s = serializer.serialize_struct("TaskStatus", 1)?;
s.serialize_field("status", &self.stringify())?;
s.end()
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/to_do/mod.rs | chapter05/adding_the_delete_endpoint/web_app/src/to_do/mod.rs | pub mod structs;
pub mod enums;
pub mod traits;
use enums::TaskStatus;
use structs::done::Done;
use structs::pending::Pending;
pub enum ItemTypes {
Pending(Pending),
Done(Done)
}
pub fn to_do_factory(title: &str,
status: TaskStatus) -> ItemTypes {
match status {
TaskStatus::DONE => {
ItemTypes::Done(Done::new(title))
},
TaskStatus::PENDING => {
ItemTypes::Pending(Pending::new(title))
}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/to_do/structs/pending.rs | chapter05/adding_the_delete_endpoint/web_app/src/to_do/structs/pending.rs | use super::base::Base;
use super::super::enums::TaskStatus;
use super::super::traits::get::Get;
use super::super::traits::edit::Edit;
use super::super::traits::create::Create;
pub struct Pending {
pub super_struct: Base
}
impl Pending {
pub fn new(input_title: &str) -> Self {
let base = Base{
title: input_title.to_string(),
status: TaskStatus::PENDING
};
return Pending{super_struct: base}
}
}
impl Get for Pending {}
impl Edit for Pending {}
impl Create for Pending {}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/to_do/structs/base.rs | chapter05/adding_the_delete_endpoint/web_app/src/to_do/structs/base.rs | use super::super::enums::TaskStatus;
use serde::Serialize;
#[derive(Serialize)]
pub struct Base {
pub title: String,
pub status: TaskStatus
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/to_do/structs/mod.rs | chapter05/adding_the_delete_endpoint/web_app/src/to_do/structs/mod.rs | pub mod base;
pub mod done;
pub mod pending;
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/to_do/structs/done.rs | chapter05/adding_the_delete_endpoint/web_app/src/to_do/structs/done.rs | use super::base::Base;
use super::super::enums::TaskStatus;
use super::super::traits::get::Get;
use super::super::traits::delete::Delete;
use super::super::traits::edit::Edit;
pub struct Done {
pub super_struct: Base
}
impl Done {
pub fn new(input_title: &str) -> Self {
let base = Base {
title: input_title.to_string(),
status: TaskStatus::DONE
};
return Done{super_struct: base}
}
}
impl Get for Done {}
impl Delete for Done {}
impl Edit for Done {}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/to_do/traits/mod.rs | chapter05/adding_the_delete_endpoint/web_app/src/to_do/traits/mod.rs | pub mod create;
pub mod delete;
pub mod edit;
pub mod get;
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/to_do/traits/edit.rs | chapter05/adding_the_delete_endpoint/web_app/src/to_do/traits/edit.rs | use serde_json::Map;
use serde_json::value::Value;
use serde_json::json;
use crate::state::write_to_file;
use super::super::enums::TaskStatus;
pub trait Edit {
fn set_to_done(&self, title: &String,
state: &mut Map<String, Value>) {
state.insert(title.to_string(),
json!(TaskStatus::DONE.stringify()));
write_to_file("./state.json", state);
println!("\n\n{} is being set to done\n\n", title);
}
fn set_to_pending(&self, title: &String,
state: &mut Map<String, Value>) {
state.insert(title.to_string(),
json!(TaskStatus::PENDING.stringify()));
write_to_file("./state.json", state);
println!("\n\n{} is being set to pending\n\n", title);
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/to_do/traits/create.rs | chapter05/adding_the_delete_endpoint/web_app/src/to_do/traits/create.rs | use serde_json::Map;
use serde_json::value::Value;
use serde_json::json;
use crate::state::write_to_file;
pub trait Create {
fn create(&self, title: &String, status: &String,
state: &mut Map<String, Value>) {
state.insert(title.to_string(), json!(status));
write_to_file("./state.json", state);
println!("\n\n{} is being created\n\n", title);
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/to_do/traits/get.rs | chapter05/adding_the_delete_endpoint/web_app/src/to_do/traits/get.rs | use serde_json::Map;
use serde_json::value::Value;
pub trait Get {
fn get(&self, title: &String, state: &Map<String, Value>) {
let item: Option<&Value> = state.get(title);
match item {
Some(result) => {
println!("\n\nItem: {}", title);
println!("Status: {}\n\n", result);
},
None => println!("item: {} was not found", title)
}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/adding_the_delete_endpoint/web_app/src/to_do/traits/delete.rs | chapter05/adding_the_delete_endpoint/web_app/src/to_do/traits/delete.rs | use serde_json::Map;
use serde_json::value::Value;
use crate::state::write_to_file;
pub trait Delete {
fn delete(&self, title: &String,
state: &mut Map<String, Value>) {
state.remove(title);
write_to_file("./state.json", state);
println!("\n\n{} is being deleted\n\n", title);
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/serving_html_using_rust/web_app/src/jwt.rs | chapter05/serving_html_using_rust/web_app/src/jwt.rs | use actix_web::dev::Payload;
use actix_web::{Error, FromRequest, HttpRequest};
use futures::future::{Ready, ok};
pub struct JwToken {
pub message: String
}
impl FromRequest for JwToken {
type Error = Error;
type Future = Ready<Result<JwToken, Error>>;
fn from_request(req: &HttpRequest, _: &mut Payload)
-> Self::Future {
match req.headers().get("token") {
Some(data) => {
let token = JwToken{
message: data.to_str().unwrap().to_string()
};
ok(token)
},
None => {
let token = JwToken{
message: String::from("nothing found")
};
ok(token)
}
}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/serving_html_using_rust/web_app/src/state.rs | chapter05/serving_html_using_rust/web_app/src/state.rs | use std::fs::File;
use std::fs;
use std::io::Read;
use serde_json::Map;
use serde_json::value::Value;
use serde_json::json;
pub fn read_file(file_name: &str) -> Map<String, Value> {
let mut file = File::open(file_name.to_string()).unwrap();
let mut data = String::new();
file.read_to_string(&mut data).unwrap();
let json: Value = serde_json::from_str(&data).unwrap();
let state: Map<String, Value> = json.as_object().unwrap().clone();
return state
}
pub fn write_to_file(file_name: &str,
state: &mut Map<String, Value>) {
let new_data = json!(state);
fs::write(
file_name.to_string(),
new_data.to_string()
).expect("Unable to write file");
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/serving_html_using_rust/web_app/src/processes.rs | chapter05/serving_html_using_rust/web_app/src/processes.rs | use serde_json::Map;
use serde_json::value::Value;
use super::to_do::ItemTypes;
use super::to_do::structs::done::Done;
use super::to_do::structs::pending::Pending;
use super::to_do::traits::get::Get;
use super::to_do::traits::create::Create;
use super::to_do::traits::delete::Delete;
use super::to_do::traits::edit::Edit;
fn process_pending(item: Pending, command: String, state: &Map<String, Value>) {
let mut state = state.clone();
match command.as_str() {
"get" => item.get(&item.super_struct.title, &state),
"create" => item.create(&item.super_struct.title,
&item.super_struct.status.stringify(), &mut state),
"edit" => item.set_to_done(&item.super_struct.title,
&mut state),
_ => println!("command: {} not supported", command)
}
}
fn process_done(item: Done, command: String, state: &Map<String, Value>) {
let mut state = state.clone();
match command.as_str() {
"get" => item.get(&item.super_struct.title, &state),
"delete" => item.delete(&item.super_struct.title, &mut state),
"edit" => item.set_to_pending(&item.super_struct.title, &mut state),
_ => println!("command: {} not supported", command)
}
}
pub fn process_input(item: ItemTypes, command: String, state: &Map<String, Value>) {
match item {
ItemTypes::Pending(item) => process_pending(item, command, state),
ItemTypes::Done(item) => process_done(item, command, state)
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/serving_html_using_rust/web_app/src/main.rs | chapter05/serving_html_using_rust/web_app/src/main.rs | use actix_web::{App, HttpServer};
use actix_service::Service;
mod views;
mod to_do;
mod state;
mod processes;
mod json_serialization;
mod jwt;
#[actix_web::main]
async fn main() -> std::io::Result<()> {
HttpServer::new(|| {
let app = App::new()
.wrap_fn(|req, srv|{
println!("{:?}", req);
let future = srv.call(req);
async {
let result = future.await?;
Ok(result)
}
}).configure(views::views_factory);
return app
})
.bind("127.0.0.1:8000")?
.run()
.await
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/serving_html_using_rust/web_app/src/json_serialization/to_do_item.rs | chapter05/serving_html_using_rust/web_app/src/json_serialization/to_do_item.rs | use serde::Deserialize;
#[derive(Deserialize)]
pub struct ToDoItem {
pub title: String,
pub status: String
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/serving_html_using_rust/web_app/src/json_serialization/to_do_items.rs | chapter05/serving_html_using_rust/web_app/src/json_serialization/to_do_items.rs | use serde::Serialize;
use std::vec::Vec;
use serde_json::value::Value;
use serde_json::Map;
use actix_web::{
body::BoxBody, http::header::ContentType,
HttpRequest, HttpResponse, Responder,
};
use crate::to_do::ItemTypes;
use crate::to_do::structs::base::Base;
use crate::state::read_file;
use crate::to_do::{to_do_factory, enums::TaskStatus};
#[derive(Serialize)]
pub struct ToDoItems {
pub pending_items: Vec<Base>,
pub done_items: Vec<Base>,
pub pending_item_count: i8,
pub done_item_count: i8
}
impl ToDoItems {
pub fn new(input_items: Vec<ItemTypes>) -> ToDoItems {
let mut pending_array_buffer = Vec::new();
let mut done_array_buffer = Vec::new();
for item in input_items {
match item {
ItemTypes::Pending(packed) => pending_array_buffer.
push(packed.super_struct),
ItemTypes::Done(packed) => done_array_buffer.push(
packed.super_struct)
}
}
let done_count: i8 = done_array_buffer.len() as i8;
let pending_count: i8 = pending_array_buffer.len() as i8;
return ToDoItems{
pending_items: pending_array_buffer,
done_item_count: done_count,
pending_item_count: pending_count,
done_items: done_array_buffer
}
}
pub fn get_state() -> ToDoItems {
let state: Map<String, Value> = read_file("./state.json");
let mut array_buffer = Vec::new();
for (key, value) in state {
let status = TaskStatus::from_string(value.as_str().unwrap().to_string());
let item = to_do_factory(
&key, status);
array_buffer.push(item);
}
return ToDoItems::new(array_buffer)
}
}
impl Responder for ToDoItems {
type Body = BoxBody;
fn respond_to(self, _req: &HttpRequest)
-> HttpResponse<Self::Body> {
let body = serde_json::to_string(&self).unwrap();
HttpResponse::Ok()
.content_type(ContentType::json())
.body(body)
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/serving_html_using_rust/web_app/src/json_serialization/mod.rs | chapter05/serving_html_using_rust/web_app/src/json_serialization/mod.rs | pub mod to_do_items;
pub mod to_do_item;
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/serving_html_using_rust/web_app/src/views/mod.rs | chapter05/serving_html_using_rust/web_app/src/views/mod.rs | mod auth;
mod to_do;
mod app;
use auth::auth_views_factory;
use to_do::to_do_views_factory; // import the factory
use actix_web::web::ServiceConfig;
pub fn views_factory(app: &mut ServiceConfig) {
auth_views_factory(app);
to_do_views_factory(app); // pass the ServiceConfig
app::app_views_factory(app);
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/serving_html_using_rust/web_app/src/views/auth/login.rs | chapter05/serving_html_using_rust/web_app/src/views/auth/login.rs |
pub async fn login() -> String {
format!("Login view")
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/serving_html_using_rust/web_app/src/views/auth/mod.rs | chapter05/serving_html_using_rust/web_app/src/views/auth/mod.rs | mod login;
mod logout;
use actix_web::web::{ServiceConfig, get, scope};
pub fn auth_views_factory(app: &mut ServiceConfig) {
app.service(
scope("v1/auth")
.route("login", get().to(login::login))
.route("logout", get().to(logout::logout))
);
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/serving_html_using_rust/web_app/src/views/auth/logout.rs | chapter05/serving_html_using_rust/web_app/src/views/auth/logout.rs |
pub async fn logout() -> String {
format!("Logout view")
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/serving_html_using_rust/web_app/src/views/app/items.rs | chapter05/serving_html_using_rust/web_app/src/views/app/items.rs | use actix_web::HttpResponse;
pub async fn items() -> HttpResponse {
HttpResponse::Ok()
.content_type("text/html; charset=utf-8")
.body("<h1>Items</h1>")
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/serving_html_using_rust/web_app/src/views/app/mod.rs | chapter05/serving_html_using_rust/web_app/src/views/app/mod.rs | use actix_web::web;
mod items;
pub fn app_views_factory(app: &mut web::ServiceConfig) {
app.route("/", web::get().to(items::items));
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/serving_html_using_rust/web_app/src/views/to_do/mod.rs | chapter05/serving_html_using_rust/web_app/src/views/to_do/mod.rs | mod create;
mod get;
mod edit;
use actix_web::web::{ServiceConfig, post, scope, get};
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))
);
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/serving_html_using_rust/web_app/src/views/to_do/edit.rs | chapter05/serving_html_using_rust/web_app/src/views/to_do/edit.rs | use actix_web::{web, HttpResponse};
use serde_json::value::Value;
use serde_json::Map;
use crate::state::read_file;
use crate::to_do::{to_do_factory, enums::TaskStatus};
use crate::json_serialization::{to_do_item::ToDoItem,
to_do_items::ToDoItems};
use crate::processes::process_input;
use crate::jwt::JwToken;
pub async fn edit(to_do_item: web::Json<ToDoItem>, token: JwToken) -> HttpResponse {
println!("here is the message in the token: {}", token.message);
let state: Map<String, Value> = read_file("./state.json");
let status: TaskStatus;
match &state.get(&to_do_item.title) {
Some(result) => {
status = TaskStatus::from_string(result.as_str()
.unwrap()
.to_string());
}
None=> {
return HttpResponse::NotFound().json(
format!("{} not in state", &to_do_item.title))
}
}
let existing_item = to_do_factory(to_do_item.title.as_str(), status.clone());
if &status.stringify() == &TaskStatus::from_string(
to_do_item.status.as_str().to_string()).stringify() {
return HttpResponse::Ok().json(ToDoItems::get_state())
}
process_input(existing_item, "edit".to_owned(), &state);
return HttpResponse::Ok().json(ToDoItems::get_state())
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/serving_html_using_rust/web_app/src/views/to_do/create.rs | chapter05/serving_html_using_rust/web_app/src/views/to_do/create.rs | use serde_json::value::Value;
use serde_json::Map;
use actix_web::HttpRequest;
use crate::to_do::{to_do_factory, enums::TaskStatus};
use crate::state::read_file;
use crate::processes::process_input;
pub async fn create(req: HttpRequest) -> String {
let state: Map<String, Value> = read_file(
"./state.json"); // step 1
let title: String = req.match_info().get("title"
).unwrap().to_string(); // step 2
let item = to_do_factory(&title.as_str(),
TaskStatus::PENDING); // step 3
process_input(item, "create".to_string(), &state); // step 4
return format!("{} created", title) // step 5
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/serving_html_using_rust/web_app/src/views/to_do/get.rs | chapter05/serving_html_using_rust/web_app/src/views/to_do/get.rs | use actix_web::Responder;
use crate::json_serialization::to_do_items::ToDoItems;
pub async fn get() -> impl Responder {
return ToDoItems::get_state();
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/serving_html_using_rust/web_app/src/to_do/enums.rs | chapter05/serving_html_using_rust/web_app/src/to_do/enums.rs | use serde::ser::{Serialize, SerializeStruct, Serializer};
#[derive(Clone)]
pub enum TaskStatus {
DONE,
PENDING
}
impl TaskStatus {
pub fn stringify(&self) -> String {
match &self {
&Self::DONE => {"DONE".to_string()},
&Self::PENDING => {"PENDING".to_string()}
}
}
pub fn from_string(input_string: String) -> Self {
match input_string.as_str() {
"DONE" => TaskStatus::DONE,
"PENDING" => TaskStatus::PENDING,
_ => panic!("input {} not supported",
input_string)
}
}
}
impl Serialize for TaskStatus {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut s = serializer.serialize_struct("TaskStatus", 1)?;
s.serialize_field("status", &self.stringify())?;
s.end()
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/serving_html_using_rust/web_app/src/to_do/mod.rs | chapter05/serving_html_using_rust/web_app/src/to_do/mod.rs | pub mod structs;
pub mod enums;
pub mod traits;
use enums::TaskStatus;
use structs::done::Done;
use structs::pending::Pending;
pub enum ItemTypes {
Pending(Pending),
Done(Done)
}
pub fn to_do_factory(title: &str,
status: TaskStatus) -> ItemTypes {
match status {
TaskStatus::DONE => {
ItemTypes::Done(Done::new(title))
},
TaskStatus::PENDING => {
ItemTypes::Pending(Pending::new(title))
}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/serving_html_using_rust/web_app/src/to_do/structs/pending.rs | chapter05/serving_html_using_rust/web_app/src/to_do/structs/pending.rs | use super::base::Base;
use super::super::enums::TaskStatus;
use super::super::traits::get::Get;
use super::super::traits::edit::Edit;
use super::super::traits::create::Create;
pub struct Pending {
pub super_struct: Base
}
impl Pending {
pub fn new(input_title: &str) -> Self {
let base = Base{
title: input_title.to_string(),
status: TaskStatus::PENDING
};
return Pending{super_struct: base}
}
}
impl Get for Pending {}
impl Edit for Pending {}
impl Create for Pending {}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/serving_html_using_rust/web_app/src/to_do/structs/base.rs | chapter05/serving_html_using_rust/web_app/src/to_do/structs/base.rs | use super::super::enums::TaskStatus;
use serde::Serialize;
#[derive(Serialize)]
pub struct Base {
pub title: String,
pub status: TaskStatus
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/serving_html_using_rust/web_app/src/to_do/structs/mod.rs | chapter05/serving_html_using_rust/web_app/src/to_do/structs/mod.rs | pub mod base;
pub mod done;
pub mod pending;
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/serving_html_using_rust/web_app/src/to_do/structs/done.rs | chapter05/serving_html_using_rust/web_app/src/to_do/structs/done.rs | use super::base::Base;
use super::super::enums::TaskStatus;
use super::super::traits::get::Get;
use super::super::traits::delete::Delete;
use super::super::traits::edit::Edit;
pub struct Done {
pub super_struct: Base
}
impl Done {
pub fn new(input_title: &str) -> Self {
let base = Base {
title: input_title.to_string(),
status: TaskStatus::DONE
};
return Done{super_struct: base}
}
}
impl Get for Done {}
impl Delete for Done {}
impl Edit for Done {}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/serving_html_using_rust/web_app/src/to_do/traits/mod.rs | chapter05/serving_html_using_rust/web_app/src/to_do/traits/mod.rs | pub mod create;
pub mod delete;
pub mod edit;
pub mod get;
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/serving_html_using_rust/web_app/src/to_do/traits/edit.rs | chapter05/serving_html_using_rust/web_app/src/to_do/traits/edit.rs | use serde_json::Map;
use serde_json::value::Value;
use serde_json::json;
use crate::state::write_to_file;
use super::super::enums::TaskStatus;
pub trait Edit {
fn set_to_done(&self, title: &String,
state: &mut Map<String, Value>) {
state.insert(title.to_string(),
json!(TaskStatus::DONE.stringify()));
write_to_file("./state.json", state);
println!("\n\n{} is being set to done\n\n", title);
}
fn set_to_pending(&self, title: &String,
state: &mut Map<String, Value>) {
state.insert(title.to_string(),
json!(TaskStatus::PENDING.stringify()));
write_to_file("./state.json", state);
println!("\n\n{} is being set to pending\n\n", title);
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/serving_html_using_rust/web_app/src/to_do/traits/create.rs | chapter05/serving_html_using_rust/web_app/src/to_do/traits/create.rs | use serde_json::Map;
use serde_json::value::Value;
use serde_json::json;
use crate::state::write_to_file;
pub trait Create {
fn create(&self, title: &String, status: &String,
state: &mut Map<String, Value>) {
state.insert(title.to_string(), json!(status));
write_to_file("./state.json", state);
println!("\n\n{} is being created\n\n", title);
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/serving_html_using_rust/web_app/src/to_do/traits/get.rs | chapter05/serving_html_using_rust/web_app/src/to_do/traits/get.rs | use serde_json::Map;
use serde_json::value::Value;
pub trait Get {
fn get(&self, title: &String, state: &Map<String, Value>) {
let item: Option<&Value> = state.get(title);
match item {
Some(result) => {
println!("\n\nItem: {}", title);
println!("Status: {}\n\n", result);
},
None => println!("item: {} was not found", title)
}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter05/serving_html_using_rust/web_app/src/to_do/traits/delete.rs | chapter05/serving_html_using_rust/web_app/src/to_do/traits/delete.rs | use serde_json::Map;
use serde_json::value::Value;
use crate::state::write_to_file;
pub trait Delete {
fn delete(&self, title: &String,
state: &mut Map<String, Value>) {
state.remove(title);
write_to_file("./state.json", state);
println!("\n\n{} is being deleted\n\n", title);
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter16/creating_http/echo_server/server/src/http_frame.rs | chapter16/creating_http/echo_server/server/src/http_frame.rs | use serde::{Serialize, Deserialize};
#[derive(Serialize, Deserialize, Debug)]
pub struct HttpFrame {
pub header: Header,
pub body: Body
}
#[derive(Serialize, Deserialize, Debug)]
pub struct Header {
pub method: String,
pub uri: String,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct Body {
pub ticker: String,
pub amount: f32,
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter16/creating_http/echo_server/server/src/main.rs | chapter16/creating_http/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 bincode;
mod http_frame;
use http_frame::HttpFrame;
#[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::<HttpFrame>(&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/chapter16/creating_http/echo_server/client/src/http_frame.rs | chapter16/creating_http/echo_server/client/src/http_frame.rs | use serde::{Serialize, Deserialize};
#[derive(Serialize, Deserialize, Debug)]
pub struct HttpFrame {
pub header: Header,
pub body: Body
}
#[derive(Serialize, Deserialize, Debug)]
pub struct Header {
pub method: String,
pub uri: String,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct Body {
pub ticker: String,
pub amount: f32,
} | rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter16/creating_http/echo_server/client/src/main.rs | chapter16/creating_http/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 bincode;
use std::error::Error;
mod http_frame;
use http_frame::{HttpFrame, Header, Body};
#[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 = HttpFrame{
header: Header{
method: "POST".to_string(),
uri: "www.freshcutswags.com/stock/purchase".to_string()
},
body: Body{
ticker: "BYND".to_string(),
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::<HttpFrame>(&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/chapter16/creating_http/simulation/src/actors.rs | chapter16/creating_http/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/chapter16/creating_http/simulation/src/main.rs | chapter16/creating_http/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/chapter16/creating_http/simulation/src/order_tracker.rs | chapter16/creating_http/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/chapter16/creating_http/clean_web_app/src/jwt.rs | chapter16/creating_http/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/chapter16/creating_http/clean_web_app/src/database.rs | chapter16/creating_http/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/chapter16/creating_http/clean_web_app/src/schema.rs | chapter16/creating_http/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/chapter16/creating_http/clean_web_app/src/counter.rs | chapter16/creating_http/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/chapter16/creating_http/clean_web_app/src/main.rs | chapter16/creating_http/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/chapter16/creating_http/clean_web_app/src/json_serialization/to_do_item.rs | chapter16/creating_http/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/chapter16/creating_http/clean_web_app/src/json_serialization/login_response.rs | chapter16/creating_http/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/chapter16/creating_http/clean_web_app/src/json_serialization/to_do_items.rs | chapter16/creating_http/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/chapter16/creating_http/clean_web_app/src/json_serialization/login.rs | chapter16/creating_http/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/chapter16/creating_http/clean_web_app/src/json_serialization/mod.rs | chapter16/creating_http/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/chapter16/creating_http/clean_web_app/src/json_serialization/new_user.rs | chapter16/creating_http/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/chapter16/creating_http/clean_web_app/src/models/mod.rs | chapter16/creating_http/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/chapter16/creating_http/clean_web_app/src/models/user/user.rs | chapter16/creating_http/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/chapter16/creating_http/clean_web_app/src/models/user/mod.rs | chapter16/creating_http/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/chapter16/creating_http/clean_web_app/src/models/user/new_user.rs | chapter16/creating_http/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/chapter16/creating_http/clean_web_app/src/models/item/mod.rs | chapter16/creating_http/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/chapter16/creating_http/clean_web_app/src/models/item/item.rs | chapter16/creating_http/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/chapter16/creating_http/clean_web_app/src/models/item/new_item.rs | chapter16/creating_http/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/chapter16/creating_http/clean_web_app/src/views/mod.rs | chapter16/creating_http/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/chapter16/creating_http/clean_web_app/src/views/auth/login.rs | chapter16/creating_http/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/chapter16/creating_http/clean_web_app/src/views/auth/mod.rs | chapter16/creating_http/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/chapter16/creating_http/clean_web_app/src/views/auth/logout.rs | chapter16/creating_http/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/chapter16/creating_http/clean_web_app/src/views/app/items.rs | chapter16/creating_http/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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.