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/chapter18/integrating_routing_in_the_http_server/redis_queue/src/main.rs | chapter18/integrating_routing_in_the_http_server/redis_queue/src/main.rs | use hyper::{Body, Request, Response, Server};
use hyper::body;
use hyper::http::StatusCode;
use hyper::service::{make_service_fn, service_fn};
use std::net::SocketAddr;
use std::env;
use serde::{Serialize, Deserialize};
use serde_json;
use bytes::{BufMut, BytesMut};
use std::{thread, time};
mod tasks;
use tasks::{
add::AddTask,
multiply::MultiplyTask,
subtract::SubtractTask,
TaskType,
TaskMessage
};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IncomingBody {
pub one: i32,
pub two: i32
}
async fn handle(req: Request<Body>) -> Result<Response<Body>, &'static str> {
let client = redis::Client::open("redis://127.0.0.1/").unwrap();
let task_type = req.uri().to_string().replace("/", "");
let body_bytes = body::to_bytes(req.into_body()).await.unwrap();
let body: IncomingBody = serde_json::from_slice(&body_bytes).unwrap();
let message_type: TaskType;
match task_type.as_str() {
"add" => {
let body = AddTask{one: body.one,
two: body.two};
message_type = TaskType::ADD(body);
},
"multiply" => {
let body = MultiplyTask{one: body.one,
two: body.two};
message_type = TaskType::MULTIPLY(body);
},
"subtract" => {
let body = SubtractTask{one: body.one,
two: body.two};
message_type = TaskType::SUBTRACT(body);
},
_ => {
let response = Response::builder().status(StatusCode::NOT_FOUND)
.body(Body::from("task not found"));
return Ok(response.unwrap())
}
}
let message = TaskMessage{task: message_type};
let serialized_message = bincode::serialize(&message).unwrap();
let mut con = client.get_connection().unwrap();
let _ : () = redis::cmd("LPUSH").arg("some_queue")
.arg(serialized_message
.clone())
.query(&mut con).unwrap();
Ok(Response::new(Body::from("task sent")))
}
#[tokio::main]
async fn main() {
let app_type = env::var("APP_TYPE").unwrap();
match app_type.as_str() {
"server" => {
let addr = SocketAddr::from(([0, 0, 0, 0], 3000));
let server = Server::bind(&addr).serve(make_service_fn( |_conn| {
async {
Ok::<_, hyper::Error>(service_fn( move |req| {
async {handle(req).await}
}))
}
}));
if let Err(e) = server.await {
eprintln!("server error: {}", e);
}
},
"worker" => {
let client = redis::Client::open("redis://127.0.0.1/").unwrap();
loop {
let outcome: Option<Vec<u8>> = {
let mut con = client.get_connection().unwrap();
// pop our task from the queue
redis::cmd("RPOP").arg("some_queue").query(&mut con)
.unwrap()
};
match outcome {
Some(data) => {
let deserialized_message: TaskMessage = bincode::deserialize(&data).unwrap();
match deserialized_message.task {
TaskType::ADD(task) => {
println!("{:?}", task.run());
},
TaskType::MULTIPLY(task) => {
println!("{:?}", task.run());
},
TaskType::SUBTRACT(task) => {
println!("{:?}", task.run());
}
}
},
None => {
let duration = tokio::time::Duration::from_secs(5);
tokio::time::sleep(duration).await;
}
}
}
}
_ => {
panic!("{} app type not supported", app_type);
}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter18/integrating_routing_in_the_http_server/redis_queue/src/tasks/mod.rs | chapter18/integrating_routing_in_the_http_server/redis_queue/src/tasks/mod.rs | pub mod add;
pub mod multiply;
pub mod subtract;
use serde::{Serialize, Deserialize};
use add::AddTask;
use multiply::MultiplyTask;
use subtract::SubtractTask;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum TaskType {
ADD(AddTask),
MULTIPLY(MultiplyTask),
SUBTRACT(SubtractTask)
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TaskMessage {
pub task: TaskType
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter18/integrating_routing_in_the_http_server/redis_queue/src/tasks/subtract.rs | chapter18/integrating_routing_in_the_http_server/redis_queue/src/tasks/subtract.rs | use std::{thread, time};
use serde::{Serialize, Deserialize};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SubtractTask {
pub one: i32,
pub two: i32
}
impl SubtractTask {
pub fn run(self) -> i32 {
let duration = time::Duration::from_secs(20);
thread::sleep(duration);
return self.one - self.two
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter18/integrating_routing_in_the_http_server/redis_queue/src/tasks/add.rs | chapter18/integrating_routing_in_the_http_server/redis_queue/src/tasks/add.rs | use std::{thread, time};
use serde::{Serialize, Deserialize};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AddTask {
pub one: i32,
pub two: i32
}
impl AddTask {
pub fn run(self) -> i32 {
let duration = time::Duration::from_secs(20);
thread::sleep(duration);
return self.one + self.two
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter18/integrating_routing_in_the_http_server/redis_queue/src/tasks/multiply.rs | chapter18/integrating_routing_in_the_http_server/redis_queue/src/tasks/multiply.rs | use std::{thread, time};
use serde::{Serialize, Deserialize};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MultiplyTask {
pub one: i32,
pub two: i32
}
impl MultiplyTask {
pub fn run(self) -> i32 {
let duration = time::Duration::from_secs(20);
thread::sleep(duration);
return self.one * self.two
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter18/defining_tasks_for_workers/redis_queue/src/main.rs | chapter18/defining_tasks_for_workers/redis_queue/src/main.rs | use hyper::{Body, Request, Response, Server};
use hyper::body;
use hyper::service::{make_service_fn, service_fn};
use std::net::SocketAddr;
use std::env;
use serde::{Serialize, Deserialize};
use serde_json;
use bytes::{BufMut, BytesMut};
use std::{thread, time};
mod tasks;
use tasks::{
add::AddTask,
subtract::SubtractTask,
multiply::MultiplyTask
};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IncomingBody {
pub one: String,
pub two: i32
}
async fn handle(req: Request<Body>) -> Result<Response<Body>, &'static str> {
let bytes = body::to_bytes(req.into_body()).await.unwrap();
let response_body: IncomingBody = serde_json::from_slice(&bytes).unwrap();
let mut buf = BytesMut::new().writer();
serde_json::to_writer(&mut buf, &response_body).unwrap();
Ok(Response::new(Body::from(buf.into_inner().freeze())))
}
#[tokio::main]
async fn main() {
let app_type = env::var("APP_TYPE").unwrap();
match app_type.as_str() {
"server" => {
let addr = SocketAddr::from(([0, 0, 0, 0], 3000));
let server = Server::bind(&addr).serve(make_service_fn( |_conn| {
async {
Ok::<_, hyper::Error>(service_fn( move |req| {
async {handle(req).await}
}))
}
}));
if let Err(e) = server.await {
eprintln!("server error: {}", e);
}
},
"worker" => {
let client = redis::Client::open("redis://127.0.0.1/").unwrap();
loop {
let body = AddTask{one: 1, two: 2};
let bytes = bincode::serialize(&body).unwrap();
let outcome: Option<Vec<u8>>;
{
let mut con = client.get_connection().unwrap();
let _ : () = redis::cmd("LPUSH").arg("some_queue")
.arg(bytes.clone())
.query(&mut con)
.unwrap();
// pop our task from the queue
outcome = redis::cmd("LPOP").arg("some_queue")
.query(&mut con)
.unwrap();
}
match outcome {
Some(data) => {
let deserialized_struct: AddTask = bincode::deserialize(&data).unwrap();
println!("{:?}", deserialized_struct.run());
},
None => {
let duration = tokio::time::Duration::from_secs(5);
tokio::time::sleep(duration).await;
}
}
}
}
_ => {
panic!("{} app type not supported", app_type);
}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter18/defining_tasks_for_workers/redis_queue/src/tasks/mod.rs | chapter18/defining_tasks_for_workers/redis_queue/src/tasks/mod.rs | pub mod add;
pub mod multiply;
pub mod subtract;
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter18/defining_tasks_for_workers/redis_queue/src/tasks/subtract.rs | chapter18/defining_tasks_for_workers/redis_queue/src/tasks/subtract.rs | use std::{thread, time};
use serde::{Serialize, Deserialize};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SubtractTask {
pub one: i32,
pub two: i32
}
impl SubtractTask {
pub fn run(self) -> i32 {
let duration = time::Duration::from_secs(20);
thread::sleep(duration);
return self.one - self.two
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter18/defining_tasks_for_workers/redis_queue/src/tasks/add.rs | chapter18/defining_tasks_for_workers/redis_queue/src/tasks/add.rs | use std::{thread, time};
use serde::{Serialize, Deserialize};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AddTask {
pub one: i32,
pub two: i32
}
impl AddTask {
pub fn run(self) -> i32 {
let duration = time::Duration::from_secs(20);
thread::sleep(duration);
return self.one + self.two
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter18/defining_tasks_for_workers/redis_queue/src/tasks/multiply.rs | chapter18/defining_tasks_for_workers/redis_queue/src/tasks/multiply.rs | use std::{thread, time};
use serde::{Serialize, Deserialize};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MultiplyTask {
pub one: i32,
pub two: i32
}
impl MultiplyTask {
pub fn run(self) -> i32 {
let duration = time::Duration::from_secs(20);
thread::sleep(duration);
return self.one * self.two
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter18/defining_messages_for_the_redis_queue/redis_queue/src/main.rs | chapter18/defining_messages_for_the_redis_queue/redis_queue/src/main.rs | use hyper::{Body, Request, Response, Server};
use hyper::body;
use hyper::service::{make_service_fn, service_fn};
use std::net::SocketAddr;
use std::env;
use serde::{Serialize, Deserialize};
use serde_json;
use bytes::{BufMut, BytesMut};
use std::{thread, time};
mod tasks;
use tasks::{
add::AddTask,
TaskType,
TaskMessage
};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IncomingBody {
pub one: String,
pub two: i32
}
async fn handle(req: Request<Body>) -> Result<Response<Body>, &'static str> {
let bytes = body::to_bytes(req.into_body()).await.unwrap();
let response_body: IncomingBody = serde_json::from_slice(&bytes).unwrap();
let mut buf = BytesMut::new().writer();
serde_json::to_writer(&mut buf, &response_body).unwrap();
Ok(Response::new(Body::from(buf.into_inner().freeze())))
}
#[tokio::main]
async fn main() {
let app_type = env::var("APP_TYPE").unwrap();
match app_type.as_str() {
"server" => {
let addr = SocketAddr::from(([0, 0, 0, 0], 3000));
let server = Server::bind(&addr).serve(make_service_fn( |_conn| {
async {
Ok::<_, hyper::Error>(service_fn( move |req| {
async {handle(req).await}
}))
}
}));
if let Err(e) = server.await {
eprintln!("server error: {}", e);
}
},
"worker" => {
let client = redis::Client::open("redis://127.0.0.1/").unwrap();
let outcome: Option<Vec<u8>>;
loop {
let body = AddTask{one: 1, two: 2};
let message = TaskMessage{task: TaskType::ADD(body)};
let serialized_message = bincode::serialize(&message).unwrap();
let outcome: Option<Vec<u8>>;
{
let mut con = client.get_connection().unwrap();
let _ : () = redis::cmd("LPUSH").arg("some_queue")
.arg(serialized_message
.clone())
.query(&mut con).unwrap();
// pop our task from the queue
outcome = redis::cmd("RPOP").arg("some_queue").query(&mut con)
.unwrap();
}
match outcome {
Some(data) => {
let deserialized_message: TaskMessage = bincode::deserialize(&data).unwrap();
match deserialized_message.task {
TaskType::ADD(task) => {
println!("{:?}", task.run());
},
TaskType::MULTIPLY(task) => {
println!("{:?}", task.run());
},
TaskType::SUBTRACT(task) => {
println!("{:?}", task.run());
}
}
},
None => {
let duration = tokio::time::Duration::from_secs(5);
tokio::time::sleep(duration).await;
}
}
}
}
_ => {
panic!("{} app type not supported", app_type);
}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter18/defining_messages_for_the_redis_queue/redis_queue/src/tasks/mod.rs | chapter18/defining_messages_for_the_redis_queue/redis_queue/src/tasks/mod.rs | pub mod add;
pub mod multiply;
pub mod subtract;
use serde::{Serialize, Deserialize};
use add::AddTask;
use multiply::MultiplyTask;
use subtract::SubtractTask;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum TaskType {
ADD(AddTask),
MULTIPLY(MultiplyTask),
SUBTRACT(SubtractTask)
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TaskMessage {
pub task: TaskType
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter18/defining_messages_for_the_redis_queue/redis_queue/src/tasks/subtract.rs | chapter18/defining_messages_for_the_redis_queue/redis_queue/src/tasks/subtract.rs | use std::{thread, time};
use serde::{Serialize, Deserialize};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SubtractTask {
pub one: i32,
pub two: i32
}
impl SubtractTask {
pub fn run(self) -> i32 {
let duration = time::Duration::from_secs(20);
thread::sleep(duration);
return self.one - self.two
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter18/defining_messages_for_the_redis_queue/redis_queue/src/tasks/add.rs | chapter18/defining_messages_for_the_redis_queue/redis_queue/src/tasks/add.rs | use std::{thread, time};
use serde::{Serialize, Deserialize};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AddTask {
pub one: i32,
pub two: i32
}
impl AddTask {
pub fn run(self) -> i32 {
let duration = time::Duration::from_secs(20);
thread::sleep(duration);
return self.one + self.two
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter18/defining_messages_for_the_redis_queue/redis_queue/src/tasks/multiply.rs | chapter18/defining_messages_for_the_redis_queue/redis_queue/src/tasks/multiply.rs | use std::{thread, time};
use serde::{Serialize, Deserialize};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MultiplyTask {
pub one: i32,
pub two: i32
}
impl MultiplyTask {
pub fn run(self) -> i32 {
let duration = time::Duration::from_secs(20);
thread::sleep(duration);
return self.one * self.two
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter18/breaking_down_our_project/redis_queue/src/main.rs | chapter18/breaking_down_our_project/redis_queue/src/main.rs | fn main() {
println!("Hello, world!");
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter18/breaking_down_our_project/redis_queue/src/tasks/mod.rs | chapter18/breaking_down_our_project/redis_queue/src/tasks/mod.rs | rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false | |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter18/breaking_down_our_project/redis_queue/src/tasks/subtract.rs | chapter18/breaking_down_our_project/redis_queue/src/tasks/subtract.rs | rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false | |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter18/breaking_down_our_project/redis_queue/src/tasks/add.rs | chapter18/breaking_down_our_project/redis_queue/src/tasks/add.rs | rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false | |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter18/breaking_down_our_project/redis_queue/src/tasks/multiply.rs | chapter18/breaking_down_our_project/redis_queue/src/tasks/multiply.rs | rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false | |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_jwt_tests/web_app/build.rs | chapter09/building_jwt_tests/web_app/build.rs | use std::fs::File;
use std::io::Write;
use std::collections::HashMap;
use serde_yaml;
fn main() {
let file = std::fs::File::open("./build_config.yml").unwrap();
let map: HashMap<String, serde_yaml::Value> = serde_yaml::from_reader(file).unwrap();
let version = map.get("ALLOWED_VERSION").unwrap().as_str().unwrap();
let mut f = File::create("./src/output_data.txt").unwrap();
write!(f, "{}", version).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/chapter09/building_jwt_tests/web_app/src/config.rs | chapter09/building_jwt_tests/web_app/src/config.rs | use std::collections::HashMap;
use std::env;
use serde_yaml;
pub struct Config {
pub map: HashMap<String, serde_yaml::Value>
}
impl Config {
// existing function reading from file
#[cfg(not(test))]
pub fn new() -> Config {
let args: Vec<String> = env::args().collect();
let file_path = &args[args.len() - 1];
let file = std::fs::File::open(file_path).unwrap();
let map: HashMap<String, serde_yaml::Value> = serde_yaml::
from_reader(file).unwrap();
return Config{map}
}
// new function for testing
#[cfg(test)]
pub fn new() -> Config {
let mut map = HashMap::new();
map.insert(String::from("DB_URL"),
serde_yaml::from_str(
"postgres://username:password@localhost:5433/to_do")
.unwrap());
map.insert(String::from("SECRET_KEY"),
serde_yaml::from_str("secret").unwrap());
map.insert(String::from("EXPIRE_MINUTES"),
serde_yaml::from_str("120").unwrap());
map.insert(String::from("REDIS_URL"),
serde_yaml::from_str("redis://127.0.0.1/").unwrap());
return Config {map}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_jwt_tests/web_app/src/jwt.rs | chapter09/building_jwt_tests/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 crate::config::Config;
#[derive(Debug, Serialize, Deserialize)]
pub struct JwToken {
pub user_id: i32,
pub exp: usize,
}
impl JwToken {
pub fn get_key() -> String {
let config = Config::new();
let key_str = config.map.get("SECRET_KEY").unwrap().as_str().unwrap();
return key_str.to_owned()
}
pub fn encode(self) -> String {
let key = EncodingKey::from_secret(JwToken::get_key().as_ref());
let token = encode(&Header::default(), &self, &key).unwrap();
return token
}
pub fn new(user_id: i32) -> Self {
let config = Config::new();
let minutes = config.map.get("EXPIRE_MINUTES")
.unwrap().as_i64().unwrap();
let expiration = Utc::now()
.checked_add_signed(chrono::Duration::minutes(minutes))
.expect("valid timestamp")
.timestamp();
return JwToken { user_id, exp: expiration as usize };
}
pub fn from_token(token: String) -> Result<Self, String> {
let key = DecodingKey::from_secret(JwToken::get_key().as_ref());
let token_result = decode::<JwToken>(&token.as_str(), &key,
&Validation::default());
match token_result {
Ok(data) => {
return Ok(data.claims)
},
Err(error) => {
let message = format!("{}", error);
return Err(message)
}
}
}
}
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, Config};
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,
pub exp_minutes: i32
}
#[test]
fn get_key() {
assert_eq!(String::from("secret"), JwToken::get_key());
}
#[test]
fn get_exp() {
let config = Config::new();
let minutes = config.map.get("EXPIRE_MINUTES")
.unwrap()
.as_i64()
.unwrap();
assert_eq!(120, minutes);
}
#[test]
fn decode_incorrect_token() {
let encoded_token: String = String::from("invalid_token");
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, "exp_minutes": 60}))
}
#[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/chapter09/building_jwt_tests/web_app/src/database.rs | chapter09/building_jwt_tests/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 crate::config::Config;
type PgPool = Pool<ConnectionManager<PgConnection>>;
pub struct DbConnection {
pub db_connection: PgPool,
}
lazy_static! {
pub static ref DBCONNECTION: DbConnection = {
let connection_string = Config::new().map.get("DB_URL")
.unwrap().as_str()
.unwrap().to_string();
DbConnection {
db_connection: PgPool::builder()
.max_size(8)
.build(ConnectionManager::new(connection_string))
.expect("failed to create db connection_pool")
}
};
}
pub fn establish_connection() -> PooledConnection<ConnectionManager<PgConnection>>{
return DBCONNECTION.db_connection.get().unwrap()
}
pub struct DB {
pub connection: PooledConnection<ConnectionManager<PgConnection>>
}
impl FromRequest for DB {
type Error = Error;
type Future = Ready<Result<DB, Error>>;
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/chapter09/building_jwt_tests/web_app/src/schema.rs | chapter09/building_jwt_tests/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/chapter09/building_jwt_tests/web_app/src/counter.rs | chapter09/building_jwt_tests/web_app/src/counter.rs | use serde::{Deserialize, Serialize};
use crate::config::Config;
#[derive(Serialize, Deserialize, Debug)]
pub struct Counter {
pub count: i32
}
impl Counter {
fn get_redis_url() -> String {
let config = Config::new();
config.map.get("REDIS_URL").unwrap().as_str().unwrap().to_owned()
}
pub fn save(self) -> Result<(), redis::RedisError> {
let serialized = serde_yaml::to_vec(&self).unwrap();
let client = match redis::Client::open(
Counter::get_redis_url()) {
Ok(client) => client,
Err(error) => return Err(error)
};
let mut con = match client.get_connection() {
Ok(con) => con,
Err(error) => return Err(error)
};
match redis::cmd("SET").arg("COUNTER")
.arg(serialized)
.query::<Vec<u8>>(&mut con) {
Ok(_) => Ok(()),
Err(error) => Err(error)
}
}
pub fn load() -> Result<Counter, redis::RedisError> {
let client = match redis::Client::open(
Counter::get_redis_url()){
Ok(client) => client,
Err(error) => return Err(error)
};
let mut con = match client.get_connection() {
Ok(con) => con,
Err(error) => return Err(error)
};
let byte_data: Vec<u8> = match redis::cmd("GET").arg("COUNTER").query(&mut con) {
Ok(data) => data,
Err(error) => return Err(error)
};
Ok(serde_yaml::from_slice(&byte_data).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/chapter09/building_jwt_tests/web_app/src/main.rs | chapter09/building_jwt_tests/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 config;
mod counter;
#[actix_web::main]
async fn main() -> std::io::Result<()> {
const ALLOWED_VERSION: &'static str = include_str!("./output_data.txt");
let site_counter = counter::Counter{count: 0};
let _ = 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().unwrap();
site_counter.count += 1;
println!("{:?}", &site_counter);
let _ = site_counter.save();
if *&req.path().contains(&format!("/{}/", ALLOWED_VERSION)) {
passed = true;
} else {
passed = false;
}
println!("{:?}", req);
let end_result = match passed {
true => {
Either::Left(srv.call(req))
},
false => {
let resp = HttpResponse::NotImplemented().body(format!(
"only {} API is supported", ALLOWED_VERSION
));
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("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/chapter09/building_jwt_tests/web_app/src/json_serialization/to_do_item.rs | chapter09/building_jwt_tests/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/chapter09/building_jwt_tests/web_app/src/json_serialization/to_do_items.rs | chapter09/building_jwt_tests/web_app/src/json_serialization/to_do_items.rs | use crate::diesel;
use diesel::prelude::*;
use crate::database::DBCONNECTION;
use crate::models::item::item::Item;
use crate::schema::to_do;
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};
#[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 items = to_do::table.filter(to_do::columns::user_id.eq(&user_id))
.order(to_do::columns::id.asc())
.load::<Item>(&connection)
.unwrap();
let mut array_buffer = Vec::with_capacity(items.len());
for item in items {
let status = TaskStatus::from_string(item.status.as_str().to_string());
let item = to_do_factory(&item.title, 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/chapter09/building_jwt_tests/web_app/src/json_serialization/login.rs | chapter09/building_jwt_tests/web_app/src/json_serialization/login.rs | use serde::{Deserialize, Serialize};
#[derive(Deserialize)]
pub struct Login {
pub username: String,
pub password: String
}
#[derive(Serialize)]
pub struct LoginResponse {
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/chapter09/building_jwt_tests/web_app/src/json_serialization/mod.rs | chapter09/building_jwt_tests/web_app/src/json_serialization/mod.rs | pub mod to_do_items;
pub mod to_do_item;
pub mod new_user;
pub mod login;
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_jwt_tests/web_app/src/json_serialization/new_user.rs | chapter09/building_jwt_tests/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/chapter09/building_jwt_tests/web_app/src/models/mod.rs | chapter09/building_jwt_tests/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/chapter09/building_jwt_tests/web_app/src/models/user/user.rs | chapter09/building_jwt_tests/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 {
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/chapter09/building_jwt_tests/web_app/src/models/user/mod.rs | chapter09/building_jwt_tests/web_app/src/models/user/mod.rs | pub mod new_user;
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/chapter09/building_jwt_tests/web_app/src/models/user/new_user.rs | chapter09/building_jwt_tests/web_app/src/models/user/new_user.rs | 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/chapter09/building_jwt_tests/web_app/src/models/item/mod.rs | chapter09/building_jwt_tests/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/chapter09/building_jwt_tests/web_app/src/models/item/item.rs | chapter09/building_jwt_tests/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/chapter09/building_jwt_tests/web_app/src/models/item/new_item.rs | chapter09/building_jwt_tests/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();
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/chapter09/building_jwt_tests/web_app/src/views/mod.rs | chapter09/building_jwt_tests/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;
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/chapter09/building_jwt_tests/web_app/src/views/auth/login.rs | chapter09/building_jwt_tests/web_app/src/views/auth/login.rs | use crate::diesel;
use diesel::prelude::*;
use actix_web::{web, HttpResponse};
use crate::database::DB;
use crate::models::user::user::User;
use crate::json_serialization::login::Login;
use crate::schema::users;
use crate::jwt::JwToken;
use std::collections::HashMap;
pub async fn login(credentials: web::Json<Login>, db: DB) -> HttpResponse {
let password = credentials.password.clone();
let users = users::table.filter(users::columns::username.eq(credentials.username.clone()))
.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].verify(password) {
true => {
let token = JwToken::new(users[0].id);
let raw_token = token.encode();
let mut body = HashMap::new();
body.insert("token", raw_token);
HttpResponse::Ok().json(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/chapter09/building_jwt_tests/web_app/src/views/auth/mod.rs | chapter09/building_jwt_tests/web_app/src/views/auth/mod.rs | mod login;
mod logout;
use actix_web::web::{ServiceConfig, get, post, scope};
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))
);
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_jwt_tests/web_app/src/views/auth/logout.rs | chapter09/building_jwt_tests/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/chapter09/building_jwt_tests/web_app/src/views/app/items.rs | chapter09/building_jwt_tests/web_app/src/views/app/items.rs | use actix_web::HttpResponse;
use super::content_loader::read_file;
use super::content_loader::add_component;
pub async fn items() -> HttpResponse {
let mut html_data = read_file(
"./templates/main.html");
let javascript_data: String = read_file(
"./javascript/main.js");
let css_data: String = read_file(
"./css/main.css");
let base_css_data: String = read_file(
"./css/base.css");
html_data = html_data.replace("{{JAVASCRIPT}}", &javascript_data);
html_data = html_data.replace("{{CSS}}", &css_data);
html_data = html_data.replace("{{BASE_CSS}}", &base_css_data);
html_data = add_component(String::from("header"), html_data);
HttpResponse::Ok()
.content_type("text/html; charset=utf-8")
.body(html_data)
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_jwt_tests/web_app/src/views/app/content_loader.rs | chapter09/building_jwt_tests/web_app/src/views/app/content_loader.rs | use std::fs;
pub fn read_file(file_path: &str) -> String {
let data: String = fs::read_to_string(
file_path).expect("Unable to read file");
return data
}
pub fn add_component(component_tag: String, html_data: String) -> String {
let css_tag: String = component_tag.to_uppercase() + "_CSS";
let html_tag: String = component_tag.to_uppercase() + "_HTML";
let css_path = String::from("./templates/components/") +
&component_tag.to_lowercase() + ".css";
let css_loaded = read_file(&css_path);
let html_path = String::from("./templates/components/") +
&component_tag.to_lowercase() + ".html";
let html_loaded = read_file(&html_path);
let html_data = html_data.replace(html_tag.as_str(), &html_loaded);
let html_data = html_data.replace(css_tag.as_str(), &css_loaded);
return html_data
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_jwt_tests/web_app/src/views/app/mod.rs | chapter09/building_jwt_tests/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/chapter09/building_jwt_tests/web_app/src/views/users/mod.rs | chapter09/building_jwt_tests/web_app/src/views/users/mod.rs | mod create;
use actix_web::web::{ServiceConfig, post, scope};
pub fn user_views_factory(app: &mut ServiceConfig) {
app.service(
scope("v1/user")
.route("create", post().to(create::create))
);
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_jwt_tests/web_app/src/views/users/create.rs | chapter09/building_jwt_tests/web_app/src/views/users/create.rs | use crate::diesel;
use diesel::prelude::*;
use actix_web::{web, HttpResponse, Responder};
use crate::database::DB;
use crate::json_serialization::new_user::NewUserSchema;
use crate::models::user::new_user::NewUser;
use crate::schema::users;
pub async fn create(new_user: web::Json<NewUserSchema>, db: DB) -> impl Responder {
let new_user = NewUser::new(
new_user.name.clone(),
new_user.email.clone(),
new_user.password.clone()
);
let insert_result = diesel::insert_into(users::table).values(&new_user).execute(&db.connection);
match insert_result {
Ok(_) => HttpResponse::Created(),
Err(_) => HttpResponse::Conflict()
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_jwt_tests/web_app/src/views/to_do/mod.rs | chapter09/building_jwt_tests/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/chapter09/building_jwt_tests/web_app/src/views/to_do/edit.rs | chapter09/building_jwt_tests/web_app/src/views/to_do/edit.rs | use crate::diesel;
use diesel::prelude::*;
use actix_web::{web, HttpResponse};
use crate::json_serialization::{to_do_item::ToDoItem,
to_do_items::ToDoItems};
use crate::jwt::JwToken;
use crate::schema::to_do;
use crate::database::DB;
pub async fn edit(to_do_item: web::Json<ToDoItem>, token: JwToken, db: DB) -> HttpResponse {
let results = to_do::table.filter(to_do::columns::title
.eq(&to_do_item.title))
.filter(to_do::columns::user_id
.eq(&token.user_id));
let _ = diesel::update(results)
.set(to_do::columns::status.eq("DONE"))
.execute(&db.connection);
return HttpResponse::Ok().json(ToDoItems::get_state(token.user_id))
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_jwt_tests/web_app/src/views/to_do/create.rs | chapter09/building_jwt_tests/web_app/src/views/to_do/create.rs | use crate::diesel;
use diesel::prelude::*;
use actix_web::HttpResponse;
use actix_web::HttpRequest;
use crate::json_serialization::to_do_items::ToDoItems;
use crate::database::DB;
use crate::models::item::new_item::NewItem;
use crate::models::item::item::Item;
use crate::schema::to_do;
use crate::jwt::JwToken;
pub async fn create(token: JwToken, req: HttpRequest, db: DB) -> HttpResponse {
let title: String = req.match_info().get("title").unwrap().to_string();
let items = to_do::table.filter(to_do::columns::title.eq(&title.as_str()))
.order(to_do::columns::id.asc())
.load::<Item>(&db.connection)
.unwrap();
if items.len() == 0 {
let new_post = NewItem::new(title, token.user_id);
let _ = diesel::insert_into(to_do::table).values(&new_post)
.execute(&db.connection);
}
return HttpResponse::Ok().json(ToDoItems::get_state(token.user_id))
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_jwt_tests/web_app/src/views/to_do/get.rs | chapter09/building_jwt_tests/web_app/src/views/to_do/get.rs | use actix_web::Responder;
use crate::json_serialization::to_do_items::ToDoItems;
use crate::jwt::JwToken;
pub async fn get(token: JwToken) -> impl Responder {
ToDoItems::get_state(token.user_id)
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_jwt_tests/web_app/src/views/to_do/delete.rs | chapter09/building_jwt_tests/web_app/src/views/to_do/delete.rs | use crate::diesel;
use diesel::prelude::*;
use actix_web::{web, HttpResponse};
use crate::schema::to_do;
use crate::json_serialization::{to_do_item::ToDoItem,
to_do_items::ToDoItems};
use crate::jwt::JwToken;
use crate::models::item::item::Item;
use crate::database::DB;
pub async fn delete(to_do_item: web::Json<ToDoItem>, token: JwToken, db: DB) -> HttpResponse {
let items = to_do::table
.filter(to_do::columns::title.eq(
&to_do_item.title.as_str())
)
.filter(to_do::columns::user_id.eq(&token.user_id))
.order(to_do::columns::id.asc())
.load::<Item>(&db.connection)
.unwrap();
let _ = diesel::delete(&items[0]).execute(&db.connection);
return HttpResponse::Ok().json(ToDoItems::get_state(token.user_id))
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_jwt_tests/web_app/src/to_do/enums.rs | chapter09/building_jwt_tests/web_app/src/to_do/enums.rs | use serde::ser::{Serialize, SerializeStruct, Serializer};
#[derive(Clone, Eq, Debug)]
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()
}
}
impl PartialEq for TaskStatus {
fn eq(&self, other: &Self) -> bool {
match self {
TaskStatus::DONE => {
match other {
&TaskStatus::DONE => return true,
&TaskStatus::PENDING => false
}
},
TaskStatus::PENDING => {
match other {
&TaskStatus::DONE => return false,
&TaskStatus::PENDING => true
}
}
}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_jwt_tests/web_app/src/to_do/mod.rs | chapter09/building_jwt_tests/web_app/src/to_do/mod.rs | pub mod structs;
pub mod enums;
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/chapter09/building_jwt_tests/web_app/src/to_do/structs/pending.rs | chapter09/building_jwt_tests/web_app/src/to_do/structs/pending.rs | use super::base::Base;
use super::super::enums::TaskStatus;
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}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_jwt_tests/web_app/src/to_do/structs/base.rs | chapter09/building_jwt_tests/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
}
#[cfg(test)]
mod base_tests {
use super::Base;
use super::TaskStatus;
#[test]
fn new() {
let expected_title = String::from("test title");
let expected_status = TaskStatus::DONE;
let new_base_struct = Base{
title: expected_title.clone(),
status: TaskStatus::DONE
};
assert_eq!(expected_title, new_base_struct.title);
assert_eq!(expected_status, new_base_struct.status);
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_jwt_tests/web_app/src/to_do/structs/mod.rs | chapter09/building_jwt_tests/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/chapter09/building_jwt_tests/web_app/src/to_do/structs/done.rs | chapter09/building_jwt_tests/web_app/src/to_do/structs/done.rs | use super::base::Base;
use super::super::enums::TaskStatus;
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}
}
}
#[cfg(test)]
mod done_tests {
use super::Done;
use super::TaskStatus;
#[test]
fn new() {
let new_base_struct = Done::new("test title");
assert_eq!(String::from("test title"),
new_base_struct.super_struct.title);
assert_eq!(TaskStatus::DONE,
new_base_struct.super_struct.status);
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_unit_tests/web_app/build.rs | chapter09/building_unit_tests/web_app/build.rs | use std::fs::File;
use std::io::Write;
use std::collections::HashMap;
use serde_yaml;
fn main() {
let file = std::fs::File::open("./build_config.yml").unwrap();
let map: HashMap<String, serde_yaml::Value> = serde_yaml::from_reader(file).unwrap();
let version = map.get("ALLOWED_VERSION").unwrap().as_str().unwrap();
let mut f = File::create("./src/output_data.txt").unwrap();
write!(f, "{}", version).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/chapter09/building_unit_tests/web_app/src/config.rs | chapter09/building_unit_tests/web_app/src/config.rs | use std::collections::HashMap;
use std::env;
use serde_yaml;
pub struct Config {
pub map: HashMap<String, serde_yaml::Value>
}
impl Config {
pub fn new() -> Config {
let args: Vec<String> = env::args().collect();
let file_path = &args[args.len() - 1];
let file = std::fs::File::open(file_path).unwrap();
let map: HashMap<String, serde_yaml::Value> = serde_yaml::
from_reader(file).unwrap();
return Config{map}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_unit_tests/web_app/src/jwt.rs | chapter09/building_unit_tests/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 crate::config::Config;
#[derive(Debug, Serialize, Deserialize)]
pub struct JwToken {
pub user_id: i32,
pub exp: usize,
}
impl JwToken {
pub fn get_key() -> String {
let config = Config::new();
let key_str = config.map.get("SECRET_KEY").unwrap().as_str().unwrap();
return key_str.to_owned()
}
pub fn encode(self) -> String {
let key = EncodingKey::from_secret(JwToken::get_key().as_ref());
let token = encode(&Header::default(), &self, &key).unwrap();
return token
}
pub fn new(user_id: i32) -> Self {
let config = Config::new();
let minutes = config.map.get("EXPIRE_MINUTES")
.unwrap().as_i64().unwrap();
let expiration = Utc::now()
.checked_add_signed(chrono::Duration::minutes(minutes))
.expect("valid timestamp")
.timestamp();
return JwToken { user_id, exp: expiration as usize };
}
pub fn from_token(token: String) -> Result<Self, String> {
let key = DecodingKey::from_secret(JwToken::get_key().as_ref());
let token_result = decode::<JwToken>(&token.as_str(), &key,
&Validation::default());
match token_result {
Ok(data) => {
return Ok(data.claims)
},
Err(error) => {
let message = format!("{}", error);
return Err(message)
}
}
}
}
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'"))
}
}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_unit_tests/web_app/src/database.rs | chapter09/building_unit_tests/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 crate::config::Config;
type PgPool = Pool<ConnectionManager<PgConnection>>;
pub struct DbConnection {
pub db_connection: PgPool,
}
lazy_static! {
pub static ref DBCONNECTION: DbConnection = {
let connection_string = Config::new().map.get("DB_URL")
.unwrap().as_str()
.unwrap().to_string();
DbConnection {
db_connection: PgPool::builder()
.max_size(8)
.build(ConnectionManager::new(connection_string))
.expect("failed to create db connection_pool")
}
};
}
pub fn establish_connection() -> PooledConnection<ConnectionManager<PgConnection>>{
return DBCONNECTION.db_connection.get().unwrap()
}
pub struct DB {
pub connection: PooledConnection<ConnectionManager<PgConnection>>
}
impl FromRequest for DB {
type Error = Error;
type Future = Ready<Result<DB, Error>>;
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/chapter09/building_unit_tests/web_app/src/schema.rs | chapter09/building_unit_tests/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/chapter09/building_unit_tests/web_app/src/counter.rs | chapter09/building_unit_tests/web_app/src/counter.rs | use serde::{Deserialize, Serialize};
use crate::config::Config;
#[derive(Serialize, Deserialize, Debug)]
pub struct Counter {
pub count: i32
}
impl Counter {
fn get_redis_url() -> String {
let config = Config::new();
config.map.get("REDIS_URL").unwrap().as_str().unwrap().to_owned()
}
pub fn save(self) -> Result<(), redis::RedisError> {
let serialized = serde_yaml::to_vec(&self).unwrap();
let client = match redis::Client::open(
Counter::get_redis_url()) {
Ok(client) => client,
Err(error) => return Err(error)
};
let mut con = match client.get_connection() {
Ok(con) => con,
Err(error) => return Err(error)
};
match redis::cmd("SET").arg("COUNTER")
.arg(serialized)
.query::<Vec<u8>>(&mut con) {
Ok(_) => Ok(()),
Err(error) => Err(error)
}
}
pub fn load() -> Result<Counter, redis::RedisError> {
let client = match redis::Client::open(
Counter::get_redis_url()){
Ok(client) => client,
Err(error) => return Err(error)
};
let mut con = match client.get_connection() {
Ok(con) => con,
Err(error) => return Err(error)
};
let byte_data: Vec<u8> = match redis::cmd("GET").arg("COUNTER").query(&mut con) {
Ok(data) => data,
Err(error) => return Err(error)
};
Ok(serde_yaml::from_slice(&byte_data).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/chapter09/building_unit_tests/web_app/src/main.rs | chapter09/building_unit_tests/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 config;
mod counter;
#[actix_web::main]
async fn main() -> std::io::Result<()> {
const ALLOWED_VERSION: &'static str = include_str!("./output_data.txt");
let site_counter = counter::Counter{count: 0};
let _ = 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().unwrap();
site_counter.count += 1;
println!("{:?}", &site_counter);
let _ = site_counter.save();
if *&req.path().contains(&format!("/{}/", ALLOWED_VERSION)) {
passed = true;
} else {
passed = false;
}
println!("{:?}", req);
let end_result = match passed {
true => {
Either::Left(srv.call(req))
},
false => {
let resp = HttpResponse::NotImplemented().body(format!(
"only {} API is supported", ALLOWED_VERSION
));
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("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/chapter09/building_unit_tests/web_app/src/json_serialization/to_do_item.rs | chapter09/building_unit_tests/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/chapter09/building_unit_tests/web_app/src/json_serialization/to_do_items.rs | chapter09/building_unit_tests/web_app/src/json_serialization/to_do_items.rs | use crate::diesel;
use diesel::prelude::*;
use crate::database::DBCONNECTION;
use crate::models::item::item::Item;
use crate::schema::to_do;
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};
#[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 items = to_do::table.filter(to_do::columns::user_id.eq(&user_id))
.order(to_do::columns::id.asc())
.load::<Item>(&connection)
.unwrap();
let mut array_buffer = Vec::with_capacity(items.len());
for item in items {
let status = TaskStatus::from_string(item.status.as_str().to_string());
let item = to_do_factory(&item.title, 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/chapter09/building_unit_tests/web_app/src/json_serialization/login.rs | chapter09/building_unit_tests/web_app/src/json_serialization/login.rs | use serde::{Deserialize, Serialize};
#[derive(Deserialize)]
pub struct Login {
pub username: String,
pub password: String
}
#[derive(Serialize)]
pub struct LoginResponse {
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/chapter09/building_unit_tests/web_app/src/json_serialization/mod.rs | chapter09/building_unit_tests/web_app/src/json_serialization/mod.rs | pub mod to_do_items;
pub mod to_do_item;
pub mod new_user;
pub mod login;
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_unit_tests/web_app/src/json_serialization/new_user.rs | chapter09/building_unit_tests/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/chapter09/building_unit_tests/web_app/src/models/mod.rs | chapter09/building_unit_tests/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/chapter09/building_unit_tests/web_app/src/models/user/user.rs | chapter09/building_unit_tests/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 {
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/chapter09/building_unit_tests/web_app/src/models/user/mod.rs | chapter09/building_unit_tests/web_app/src/models/user/mod.rs | pub mod new_user;
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/chapter09/building_unit_tests/web_app/src/models/user/new_user.rs | chapter09/building_unit_tests/web_app/src/models/user/new_user.rs | 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/chapter09/building_unit_tests/web_app/src/models/item/mod.rs | chapter09/building_unit_tests/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/chapter09/building_unit_tests/web_app/src/models/item/item.rs | chapter09/building_unit_tests/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/chapter09/building_unit_tests/web_app/src/models/item/new_item.rs | chapter09/building_unit_tests/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();
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/chapter09/building_unit_tests/web_app/src/views/mod.rs | chapter09/building_unit_tests/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;
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/chapter09/building_unit_tests/web_app/src/views/auth/login.rs | chapter09/building_unit_tests/web_app/src/views/auth/login.rs | use crate::diesel;
use diesel::prelude::*;
use actix_web::{web, HttpResponse};
use crate::database::DB;
use crate::models::user::user::User;
use crate::json_serialization::login::Login;
use crate::schema::users;
use crate::jwt::JwToken;
use std::collections::HashMap;
pub async fn login(credentials: web::Json<Login>, db: DB) -> HttpResponse {
let password = credentials.password.clone();
let users = users::table.filter(users::columns::username.eq(credentials.username.clone()))
.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].verify(password) {
true => {
let token = JwToken::new(users[0].id);
let raw_token = token.encode();
let mut body = HashMap::new();
body.insert("token", raw_token);
HttpResponse::Ok().json(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/chapter09/building_unit_tests/web_app/src/views/auth/mod.rs | chapter09/building_unit_tests/web_app/src/views/auth/mod.rs | mod login;
mod logout;
use actix_web::web::{ServiceConfig, get, post, scope};
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))
);
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_unit_tests/web_app/src/views/auth/logout.rs | chapter09/building_unit_tests/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/chapter09/building_unit_tests/web_app/src/views/app/items.rs | chapter09/building_unit_tests/web_app/src/views/app/items.rs | use actix_web::HttpResponse;
use super::content_loader::read_file;
use super::content_loader::add_component;
pub async fn items() -> HttpResponse {
let mut html_data = read_file(
"./templates/main.html");
let javascript_data: String = read_file(
"./javascript/main.js");
let css_data: String = read_file(
"./css/main.css");
let base_css_data: String = read_file(
"./css/base.css");
html_data = html_data.replace("{{JAVASCRIPT}}", &javascript_data);
html_data = html_data.replace("{{CSS}}", &css_data);
html_data = html_data.replace("{{BASE_CSS}}", &base_css_data);
html_data = add_component(String::from("header"), html_data);
HttpResponse::Ok()
.content_type("text/html; charset=utf-8")
.body(html_data)
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_unit_tests/web_app/src/views/app/content_loader.rs | chapter09/building_unit_tests/web_app/src/views/app/content_loader.rs | use std::fs;
pub fn read_file(file_path: &str) -> String {
let data: String = fs::read_to_string(
file_path).expect("Unable to read file");
return data
}
pub fn add_component(component_tag: String, html_data: String) -> String {
let css_tag: String = component_tag.to_uppercase() + "_CSS";
let html_tag: String = component_tag.to_uppercase() + "_HTML";
let css_path = String::from("./templates/components/") +
&component_tag.to_lowercase() + ".css";
let css_loaded = read_file(&css_path);
let html_path = String::from("./templates/components/") +
&component_tag.to_lowercase() + ".html";
let html_loaded = read_file(&html_path);
let html_data = html_data.replace(html_tag.as_str(), &html_loaded);
let html_data = html_data.replace(css_tag.as_str(), &css_loaded);
return html_data
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_unit_tests/web_app/src/views/app/mod.rs | chapter09/building_unit_tests/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/chapter09/building_unit_tests/web_app/src/views/users/mod.rs | chapter09/building_unit_tests/web_app/src/views/users/mod.rs | mod create;
use actix_web::web::{ServiceConfig, post, scope};
pub fn user_views_factory(app: &mut ServiceConfig) {
app.service(
scope("v1/user")
.route("create", post().to(create::create))
);
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_unit_tests/web_app/src/views/users/create.rs | chapter09/building_unit_tests/web_app/src/views/users/create.rs | use crate::diesel;
use diesel::prelude::*;
use actix_web::{web, HttpResponse, Responder};
use crate::database::DB;
use crate::json_serialization::new_user::NewUserSchema;
use crate::models::user::new_user::NewUser;
use crate::schema::users;
pub async fn create(new_user: web::Json<NewUserSchema>, db: DB) -> impl Responder {
let new_user = NewUser::new(
new_user.name.clone(),
new_user.email.clone(),
new_user.password.clone()
);
let insert_result = diesel::insert_into(users::table).values(&new_user).execute(&db.connection);
match insert_result {
Ok(_) => HttpResponse::Created(),
Err(_) => HttpResponse::Conflict()
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_unit_tests/web_app/src/views/to_do/mod.rs | chapter09/building_unit_tests/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/chapter09/building_unit_tests/web_app/src/views/to_do/edit.rs | chapter09/building_unit_tests/web_app/src/views/to_do/edit.rs | use crate::diesel;
use diesel::prelude::*;
use actix_web::{web, HttpResponse};
use crate::json_serialization::{to_do_item::ToDoItem,
to_do_items::ToDoItems};
use crate::jwt::JwToken;
use crate::schema::to_do;
use crate::database::DB;
pub async fn edit(to_do_item: web::Json<ToDoItem>, token: JwToken, db: DB) -> HttpResponse {
let results = to_do::table.filter(to_do::columns::title
.eq(&to_do_item.title))
.filter(to_do::columns::user_id
.eq(&token.user_id));
let _ = diesel::update(results)
.set(to_do::columns::status.eq("DONE"))
.execute(&db.connection);
return HttpResponse::Ok().json(ToDoItems::get_state(token.user_id))
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_unit_tests/web_app/src/views/to_do/create.rs | chapter09/building_unit_tests/web_app/src/views/to_do/create.rs | use crate::diesel;
use diesel::prelude::*;
use actix_web::HttpResponse;
use actix_web::HttpRequest;
use crate::json_serialization::to_do_items::ToDoItems;
use crate::database::DB;
use crate::models::item::new_item::NewItem;
use crate::models::item::item::Item;
use crate::schema::to_do;
use crate::jwt::JwToken;
pub async fn create(token: JwToken, req: HttpRequest, db: DB) -> HttpResponse {
let title: String = req.match_info().get("title").unwrap().to_string();
let items = to_do::table.filter(to_do::columns::title.eq(&title.as_str()))
.order(to_do::columns::id.asc())
.load::<Item>(&db.connection)
.unwrap();
if items.len() == 0 {
let new_post = NewItem::new(title, token.user_id);
let _ = diesel::insert_into(to_do::table).values(&new_post)
.execute(&db.connection);
}
return HttpResponse::Ok().json(ToDoItems::get_state(token.user_id))
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_unit_tests/web_app/src/views/to_do/get.rs | chapter09/building_unit_tests/web_app/src/views/to_do/get.rs | use actix_web::Responder;
use crate::json_serialization::to_do_items::ToDoItems;
use crate::jwt::JwToken;
pub async fn get(token: JwToken) -> impl Responder {
ToDoItems::get_state(token.user_id)
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_unit_tests/web_app/src/views/to_do/delete.rs | chapter09/building_unit_tests/web_app/src/views/to_do/delete.rs | use crate::diesel;
use diesel::prelude::*;
use actix_web::{web, HttpResponse};
use crate::schema::to_do;
use crate::json_serialization::{to_do_item::ToDoItem,
to_do_items::ToDoItems};
use crate::jwt::JwToken;
use crate::models::item::item::Item;
use crate::database::DB;
pub async fn delete(to_do_item: web::Json<ToDoItem>, token: JwToken, db: DB) -> HttpResponse {
let items = to_do::table
.filter(to_do::columns::title.eq(
&to_do_item.title.as_str())
)
.filter(to_do::columns::user_id.eq(&token.user_id))
.order(to_do::columns::id.asc())
.load::<Item>(&db.connection)
.unwrap();
let _ = diesel::delete(&items[0]).execute(&db.connection);
return HttpResponse::Ok().json(ToDoItems::get_state(token.user_id))
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_unit_tests/web_app/src/to_do/enums.rs | chapter09/building_unit_tests/web_app/src/to_do/enums.rs | use serde::ser::{Serialize, SerializeStruct, Serializer};
#[derive(Clone, Eq, Debug)]
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()
}
}
impl PartialEq for TaskStatus {
fn eq(&self, other: &Self) -> bool {
match self {
TaskStatus::DONE => {
match other {
&TaskStatus::DONE => return true,
&TaskStatus::PENDING => false
}
},
TaskStatus::PENDING => {
match other {
&TaskStatus::DONE => return false,
&TaskStatus::PENDING => true
}
}
}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_unit_tests/web_app/src/to_do/mod.rs | chapter09/building_unit_tests/web_app/src/to_do/mod.rs | pub mod structs;
pub mod enums;
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/chapter09/building_unit_tests/web_app/src/to_do/structs/pending.rs | chapter09/building_unit_tests/web_app/src/to_do/structs/pending.rs | use super::base::Base;
use super::super::enums::TaskStatus;
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}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_unit_tests/web_app/src/to_do/structs/base.rs | chapter09/building_unit_tests/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
}
#[cfg(test)]
mod base_tests {
use super::Base;
use super::TaskStatus;
#[test]
fn new() {
let expected_title = String::from("test title");
let expected_status = TaskStatus::DONE;
let new_base_struct = Base{
title: expected_title.clone(),
status: TaskStatus::DONE
};
assert_eq!(expected_title, new_base_struct.title);
assert_eq!(expected_status, new_base_struct.status);
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/building_unit_tests/web_app/src/to_do/structs/mod.rs | chapter09/building_unit_tests/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/chapter09/building_unit_tests/web_app/src/to_do/structs/done.rs | chapter09/building_unit_tests/web_app/src/to_do/structs/done.rs | use super::base::Base;
use super::super::enums::TaskStatus;
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}
}
}
#[cfg(test)]
mod done_tests {
use super::Done;
use super::TaskStatus;
#[test]
fn new() {
let new_base_struct = Done::new("test title");
assert_eq!(String::from("test title"),
new_base_struct.super_struct.title);
assert_eq!(TaskStatus::DONE,
new_base_struct.super_struct.status);
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
PacktPublishing/Rust-Web-Programming-2nd-Edition | https://github.com/PacktPublishing/Rust-Web-Programming-2nd-Edition/blob/9b90563dcdb5e7e546c99b441b9d8f2616cc7c89/chapter09/writing_tests_in_postman/web_app/build.rs | chapter09/writing_tests_in_postman/web_app/build.rs | use std::fs::File;
use std::io::Write;
use std::collections::HashMap;
use serde_yaml;
fn main() {
let file = std::fs::File::open("./build_config.yml").unwrap();
let map: HashMap<String, serde_yaml::Value> = serde_yaml::from_reader(file).unwrap();
let version = map.get("ALLOWED_VERSION").unwrap().as_str().unwrap();
let mut f = File::create("./src/output_data.txt").unwrap();
write!(f, "{}", version).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/chapter09/writing_tests_in_postman/web_app/src/config.rs | chapter09/writing_tests_in_postman/web_app/src/config.rs | use std::collections::HashMap;
use std::env;
use serde_yaml;
pub struct Config {
pub map: HashMap<String, serde_yaml::Value>
}
impl Config {
// existing function reading from file
#[cfg(not(test))]
pub fn new() -> Config {
let args: Vec<String> = env::args().collect();
let file_path = &args[args.len() - 1];
let file = std::fs::File::open(file_path).unwrap();
let map: HashMap<String, serde_yaml::Value> = serde_yaml::
from_reader(file).unwrap();
return Config{map}
}
// new function for testing
#[cfg(test)]
pub fn new() -> Config {
let mut map = HashMap::new();
map.insert(String::from("DB_URL"),
serde_yaml::from_str(
"postgres://username:password@localhost:5433/to_do")
.unwrap());
map.insert(String::from("SECRET_KEY"),
serde_yaml::from_str("secret").unwrap());
map.insert(String::from("EXPIRE_MINUTES"),
serde_yaml::from_str("120").unwrap());
map.insert(String::from("REDIS_URL"),
serde_yaml::from_str("redis://127.0.0.1/").unwrap());
return Config {map}
}
}
| rust | MIT | 9b90563dcdb5e7e546c99b441b9d8f2616cc7c89 | 2026-01-04T20:15:31.275007Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.