bsherriff/aviation
1
1
Fork 0
Code Issues 10 Pull Requests Actions Packages Projects 1 Releases Wiki Activity

Updated versions

Browse Source
This commit is contained in:
Ben Sherriff
2024-07-12 12:19:08 -04:00
parent 5b99bc85ab
commit 32a0ecc1e6
32 changed files with 1763 additions and 995 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
.env.TEMPLATE → .env
View File

2
.gitignore vendored
View File

@@ -38,5 +38,3 @@ yarn-error.log*
target/
dist/
*.env
.env.local

2
Makefile
View File

@@ -4,6 +4,8 @@ SHELL := /bin/bash
GIT_HASH ?= $(shell git log --format="%h" -n 1)
include .env
-include .env.local
export
.PHONY: help build start stop lint

4
service/.env.TEMPLATE → service/.env
View File

@@ -11,7 +11,7 @@ DATABASE_PORT=5432
REDIS_HOST=localhost
REDIS_PORT=6379
MINIO_ROOT_USER=weather
MINIO_ROOT_USER=aviation
MINIO_ROOT_PASSWORD=
MINIO_HOST=localhost
MINIO_PORT=9000
@@ -22,6 +22,6 @@ SERVICE_PORT=5000
KEYS_DIR_PATH=
ACCESS_TOKEN_MAXAGE=5
REFRESH_TOKEN_MAXAGE=30
REFRESH_TOKEN_MAXAGE=1440
GOV_API_URL=https://aviationweather.gov/cgi-bin/data

1030
service/Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

47
service/Cargo.toml
View File

@@ -10,28 +10,29 @@ license = "GPL-3.0-or-later"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
actix-web = "4.4.0"
actix-cors = "0.6.4"
actix-web-httpauth = "0.8.1"
actix-multipart = "0.6.1"
chrono = { version = "0.4.31", features = ["serde"] }
actix-web = "4.8.0"
actix-cors = "0.7.0"
actix-web-httpauth = "0.8.2"
actix-multipart = "0.7.2"
chrono = { version = "0.4.38", features = ["serde"] }
dotenv = "0.15.0"
diesel = { version = "2.1.2", features = ["postgres", "r2d2", "uuid", "chrono", "serde_json"] }
postgis_diesel = { version = "2.2.1", features = ["serde"] }
diesel_migrations = { version = "2.1.0", features = ["postgres"] }
env_logger = "0.10.0"
lazy_static = "1.4.0"
diesel = { version = "2.2.1", features = ["postgres", "r2d2", "uuid", "chrono", "serde_json"] }
postgis_diesel = { version = "2.4.0", features = ["serde"] }
diesel_migrations = { version = "2.2.0", features = ["postgres"] }
env_logger = "0.11.3"
lazy_static = "1.5.0"
r2d2 = "0.8.10"
reqwest = "0.11.21"
serde = {version = "1.0.188", features = ["derive"]}
serde_json = "1.0.107"
tokio = { version = "1.32.0", features = ["macros", "rt", "time"] }
uuid = { version = "1.4.1", features = ["serde", "v4"] }
log = "0.4.20"
argon2 = "0.5.2"
jsonwebtoken = "9.0.0"
redis = { version = "0.23.3", features = ["tokio-comp", "connection-manager", "r2d2"] }
rustix = "0.38.19" # https://github.com/imsnif/bandwhich/issues/284
regex = "1.10.2"
futures-util = "0.3.29"
rust-s3 = "0.33.0"
reqwest = "0.12.5"
serde = {version = "1.0.204", features = ["derive"]}
serde_json = "1.0.120"
tokio = { version = "1.38.0", features = ["macros", "rt", "time"] }
uuid = { version = "1.10.0", features = ["serde", "v4"] }
log = "0.4.22"
argon2 = "0.5.3"
jsonwebtoken = "9.3.0"
redis = { version = "0.25.4", features = ["tokio-comp", "connection-manager", "r2d2"] }
#rustix = "0.38.19" # https://github.com/imsnif/bandwhich/issues/284
ahash = "0.8.11" # https://github.com/tkaitchuck/aHash/issues/200
regex = "1.10.5"
futures-util = "0.3.30"
rust-s3 = "0.34.0"

59
service/Makefile
View File

@@ -4,6 +4,8 @@ SHELL := /bin/bash
GIT_HASH ?= $(shell git log --format="%h" -n 1)
include .env
-include .env.local
export
.PHONY: help build start stop lint
@@ -12,40 +14,49 @@ help: ## This info
@cat Makefile | grep -E '^[a-zA-Z\/_-]+:.*?## .*$$' | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'
@echo
build: ## Build the Docker image
docker compose build
format: ## Format code
@echo "Formatting code..."
@cargo fmt
@echo "Format complete"
tag: ## Tag the Docker image
docker tag aviation-service:latest aviation-service:${GIT_HASH}
run: ## Run the service
@cargo run
utils: ## Start the utils
docker compose up -d db
docker compose up -d redis
docker compose up -d minio
clean: ## Cleanup
@echo "Cleaning up..."
@cargo clean
@rm -rf ../keys
@echo "Cleanup complete"
up: ## Start the Docker containers
docker compose up -d
@docker compose --profile backend up -d
down: ## Stop the Docker containers
docker compose down
@docker compose --profile backend down
connect: ## Connect to the PSQL DB
docker exec -it ${DATABASE_CONTAINER} psql -U postgres
@docker exec -it ${DATABASE_CONTAINER} psql -U postgres
clean: ## Cleanup Docker containers
docker compose down && \
docker image rm aviation-service || \
docker network rm aviation-frontend || \
docker network rm aviation-backend
docker-build: ## Build the Docker image
@docker compose build
docker-tag: ## Tag the Docker image
@docker tag aviation-service:latest aviation-service:${GIT_HASH}
docker-run: ## Start the service
@docker compose --profile service up -d
docker-clean: ## Cleanup Docker containers
@docker compose --profile backend --profile service down -v
clean-db: ## Remove database
docker exec -i ${DATABASE_CONTAINER} sh -c 'PGPASSWORD=${DATABASE_PASSWORD} psql -U ${DATABASE_USER} -d postgres -c "DROP DATABASE IF EXISTS \"${DATABASE_NAME}\";"'
docker exec -i ${DATABASE_CONTAINER} sh -c 'PGPASSWORD=${DATABASE_PASSWORD} psql -U ${DATABASE_USER} -d postgres -c "CREATE DATABASE \"${DATABASE_NAME}\";"' || true
@docker exec -i ${DATABASE_CONTAINER} sh -c 'PGPASSWORD=${DATABASE_PASSWORD} psql -U ${DATABASE_USER} -d postgres -c "DROP DATABASE IF EXISTS \"${DATABASE_NAME}\";"'
@docker exec -i ${DATABASE_CONTAINER} sh -c 'PGPASSWORD=${DATABASE_PASSWORD} psql -U ${DATABASE_USER} -d postgres -c "CREATE DATABASE \"${DATABASE_NAME}\";"' || true
generate: ## Generate RSA keys
mkdir ../keys/
openssl genrsa -out ../keys/access_private_key.pem 4096
openssl rsa -in ../keys/access_private_key.pem -pubout -outform PEM -out ../keys/access_public_key.pem
openssl genrsa -out ../keys/refresh_private_key.pem 4096
openssl rsa -in ../keys/refresh_private_key.pem -pubout -outform PEM -out ../keys/refresh_public_key.pem
generate-keys: ## Generate RSA keys
@mkdir ../keys/
@openssl genrsa -out ../keys/access_private_key.pem 4096
@openssl rsa -in ../keys/access_private_key.pem -pubout -outform PEM -out ../keys/access_public_key.pem
@openssl genrsa -out ../keys/refresh_private_key.pem 4096
@openssl rsa -in ../keys/refresh_private_key.pem -pubout -outform PEM -out ../keys/refresh_public_key.pem

20
service/docker-compose.yml
View File

@@ -1,12 +1,15 @@
version: '3'
x-env_file: &env
- path: .env
required: true
- path: .env.local
required: false
name: aviation
services:
db:
image: postgis/postgis:latest
container_name: aviation-db
env_file:
- .env
env_file: *env
environment:
POSTGRES_USER: ${DATABASE_USER}
POSTGRES_PASSWORD: ${DATABASE_PASSWORD}
@@ -18,6 +21,8 @@ services:
- "${DATABASE_PORT:-5432}:5432"
networks:
- backend
profiles:
- backend
restart: unless-stopped
redis:
image: redis:latest
@@ -28,6 +33,8 @@ services:
- ${REDIS_PORT:-6379}:6379
networks:
- backend
profiles:
- backend
restart: unless-stopped
minio:
image: minio/minio
@@ -42,13 +49,14 @@ services:
- ${MINIO_PORT_INTERNAL:-9001}:9001
networks:
- backend
profiles:
- backend
command: server --console-address ":9001" /data
restart: unless-stopped
service:
container_name: aviation-service
env_file:
- .env
env_file: *env
environment:
DATABASE_HOST: db
DATABASE_PORT: 5432
@@ -70,6 +78,8 @@ services:
networks:
- frontend
- backend
profiles:
- service
restart: unless-stopped
volumes:

3
service/rust-toolchain.toml Normal file
View File

@@ -0,0 +1,3 @@
[toolchain]
channel = "stable"
components = ["rustfmt", "clippy"]

3
service/rustfmt.toml Normal file
View File

@@ -0,0 +1,3 @@
indent_style = "Block"
reorder_imports = false
tab_spaces = 2

107
service/src/airports/model.rs
View File

@@ -67,8 +67,8 @@ impl Into<QueryAirport> for Airport {
error!("{}", err);
serde_json::Value::Null
}
}
}
},
};
}
}
@@ -95,7 +95,7 @@ pub enum AirportCategory {
#[serde(rename = "balloonport")]
Balloonport,
#[serde(rename = "unknown")]
Unknown
Unknown,
}
impl FromStr for AirportCategory {
@@ -109,7 +109,7 @@ impl FromStr for AirportCategory {
"closed" => Ok(AirportCategory::Closed),
"seaplane_base" => Ok(AirportCategory::Seaplane),
"balloonport" => Ok(AirportCategory::Balloonport),
_ => Ok(AirportCategory::Unknown)
_ => Ok(AirportCategory::Unknown),
}
}
}
@@ -124,7 +124,7 @@ impl Display for AirportCategory {
AirportCategory::Closed => write!(f, "closed"),
AirportCategory::Seaplane => write!(f, "seaplane_base"),
AirportCategory::Balloonport => write!(f, "balloonport"),
AirportCategory::Unknown => write!(f, "unknown")
AirportCategory::Unknown => write!(f, "unknown"),
}
}
}
@@ -141,7 +141,7 @@ pub struct QueryAirport {
pub municipality: String,
pub has_metar: bool,
pub point: Point,
pub data: serde_json::Value
pub data: serde_json::Value,
}
#[derive(Debug)]
@@ -151,7 +151,8 @@ pub struct QueryFilters {
pub bounds: Option<Polygon<Point>>,
pub categories: Option<Vec<AirportCategory>>,
pub order_field: Option<QueryOrderField>,
pub order_by: Option<QueryOrderBy>
pub order_by: Option<QueryOrderBy>,
pub has_metar: Option<bool>,
}
impl Default for QueryFilters {
@@ -162,7 +163,8 @@ impl Default for QueryFilters {
bounds: None,
categories: None,
order_field: None,
order_by: None
order_by: None,
has_metar: None,
}
}
}
@@ -170,7 +172,7 @@ impl Default for QueryFilters {
#[derive(Debug)]
pub enum QueryOrderBy {
Asc,
Desc
Desc,
}
impl FromStr for QueryOrderBy {
@@ -179,7 +181,7 @@ impl FromStr for QueryOrderBy {
match s {
"asc" => Ok(QueryOrderBy::Asc),
"desc" => Ok(QueryOrderBy::Desc),
_ => Err(())
_ => Err(()),
}
}
}
@@ -204,7 +206,7 @@ impl FromStr for QueryOrderField {
"iso_country" => Ok(QueryOrderField::Country),
"iso_region" => Ok(QueryOrderField::Region),
"municipality" => Ok(QueryOrderField::Municipality),
_ => Err(())
_ => Err(()),
}
}
}
@@ -229,7 +231,7 @@ impl QueryAirport {
QueryOrderField::Municipality => format!("{}, municipality ASC", query),
};
};
},
}
QueryOrderBy::Desc => {
if let Some(order_field) = &filters.order_field {
query = match order_field {
@@ -249,7 +251,12 @@ impl QueryAirport {
let airports: Vec<QueryAirport> = match sql_query(query).load(&mut conn) {
Ok(a) => a,
Err(err) => return Err(ServiceError { status: 500, message: format!("{}", err) })
Err(err) => {
return Err(ServiceError {
status: 500,
message: format!("{}", err),
})
}
};
Ok(airports)
}
@@ -268,12 +275,17 @@ impl QueryAirport {
#[derive(Debug, Queryable, QueryableByName)]
#[diesel(table_name = airports)]
struct Count {
count: i64
count: i64,
}
let count: Vec<Count> = match sql_query(query).load(&mut conn) {
Ok(a) => a,
Err(err) => return Err(ServiceError { status: 500, message: format!("{}", err) })
Err(err) => {
return Err(ServiceError {
status: 500,
message: format!("{}", err),
})
}
};
return Ok(count[0].count);
}
@@ -286,7 +298,10 @@ impl QueryAirport {
if let Some(bounds) = &filters.bounds {
// convert bounds to a WKT polygon
if bounds.rings.len() > 1 {
return Err(ServiceError { status: 400, message: "Only one polygon is allowed".to_string() })
return Err(ServiceError {
status: 400,
message: "Only one polygon is allowed".to_string(),
});
} else {
let mut points: Vec<String> = vec![];
bounds.rings.iter().for_each(|ring| {
@@ -295,28 +310,58 @@ impl QueryAirport {
});
});
let bounds = format!("POLYGON(({}))", points.join(","));
parts.push(format!("ST_Contains(ST_GeomFromText('{}', 4326), point)", bounds));
parts.push(format!(
"ST_Contains(ST_GeomFromText('{}', 4326), point)",
bounds
));
}
}
if let Some(categories) = &filters.categories {
parts.push(format!("({})", categories.iter().map(|category| format!("category = '{}'", category.to_string())).collect::<Vec<String>>().join(" OR ")));
parts.push(format!(
"({})",
categories
.iter()
.map(|category| format!("category = '{}'", category.to_string()))
.collect::<Vec<String>>()
.join(" OR ")
));
}
fn sanitize_icao(icao: &str) -> String {
// Sanitize search to only allow [a-zA-Z0-9-\\s]
icao.chars().filter(|c| c.is_alphanumeric() || *c == '-' || *c == ' ').collect::<String>()
icao
.chars()
.filter(|c| c.is_alphanumeric() || *c == '-' || *c == ' ')
.collect::<String>()
}
if &filters.icaos.is_some() == &true && &filters.name.is_some() == &true {
let icaos = filters.icaos.as_ref().unwrap();
let name = sanitize_icao(filters.name.as_ref().unwrap());
let icao_part = format!("({})", icaos.iter().map(|icao| format!("icao ILIKE '{}'", sanitize_icao(icao))).collect::<Vec<String>>().join(" OR "));
let icao_part = format!(
"({})",
icaos
.iter()
.map(|icao| format!("icao ILIKE '{}'", sanitize_icao(icao)))
.collect::<Vec<String>>()
.join(" OR ")
);
let name_part = format!("name ILIKE '%{}%'", name);
parts.push(format!("({} OR {})", icao_part, name_part));
} else if let Some(icaos) = &filters.icaos {
parts.push(format!("({})", icaos.iter().map(|icao| format!("icao ILIKE '{}'", sanitize_icao(icao))).collect::<Vec<String>>().join(" OR ")));
parts.push(format!(
"({})",
icaos
.iter()
.map(|icao| format!("icao ILIKE '{}'", sanitize_icao(icao)))
.collect::<Vec<String>>()
.join(" OR ")
));
} else if let Some(name) = &filters.name {
let search = sanitize_icao(name);
parts.push(format!("name ILIKE '%{}%'", search));
}
if let Some(has_metar) = &filters.has_metar {
parts.push(format!("has_metar = {}", has_metar));
}
if parts.len() > 0 {
query = format!("{} WHERE {}", query, parts.join(" AND "));
@@ -327,26 +372,32 @@ impl QueryAirport {
pub fn get(icao: &str) -> Result<Self, ServiceError> {
let mut conn = db::connection()?;
let airport = airports::table.filter(airports::icao.eq(icao)).first(&mut conn)?;
let airport = airports::table
.filter(airports::icao.eq(icao))
.first(&mut conn)?;
Ok(airport)
}
pub fn insert(airport: Self) -> Result<Self, ServiceError> {
let mut conn: r2d2::PooledConnection<diesel::r2d2::ConnectionManager<PgConnection>> = db::connection()?;
let mut conn: r2d2::PooledConnection<diesel::r2d2::ConnectionManager<PgConnection>> =
db::connection()?;
let airport = Self::from(airport);
let airport = diesel::insert_into(airports::table)
.values(airport)
.on_conflict_do_nothing()
.get_result(&mut conn)?;
Ok(airport)
}
pub fn insert_all (airports: Vec<Self>) -> Result<Vec<Self>, ServiceError> {
let mut conn: r2d2::PooledConnection<diesel::r2d2::ConnectionManager<PgConnection>> = db::connection()?;
pub fn insert_all(airports: Vec<Self>) -> Result<Vec<Self>, ServiceError> {
let mut conn: r2d2::PooledConnection<diesel::r2d2::ConnectionManager<PgConnection>> =
db::connection()?;
let mut inserted_airports: Vec<Self> = vec![];
for airport in airports {
let airport = Self::from(airport);
let airport = diesel::insert_into(airports::table)
.values(airport)
.on_conflict_do_nothing()
.get_result(&mut conn)?;
inserted_airports.push(airport);
}
@@ -365,8 +416,10 @@ impl QueryAirport {
pub fn delete(icao: Option<String>) -> Result<usize, ServiceError> {
let mut conn = db::connection()?;
let res = match icao {
Some(icao) => diesel::delete(airports::table.filter(airports::icao.eq(icao))).execute(&mut conn)?,
None => diesel::delete(airports::table).execute(&mut conn)?
Some(icao) => {
diesel::delete(airports::table.filter(airports::icao.eq(icao))).execute(&mut conn)?
}
None => diesel::delete(airports::table).execute(&mut conn)?,
};
Ok(res)
}

146
service/src/airports/routes.rs
View File

@@ -1,7 +1,11 @@
use std::str::FromStr;
use futures_util::stream::StreamExt as _;
use crate::{airports::{QueryAirport, QueryFilters, QueryOrderField, QueryOrderBy, Airport, AirportCategory}, db::{Response, Metadata}, auth::{JwtAuth, verify_role}};
use crate::{
airports::{QueryAirport, QueryFilters, QueryOrderField, QueryOrderBy, Airport, AirportCategory},
db::{Response, Metadata},
auth::{JwtAuth, verify_role},
};
use actix_multipart::Multipart;
use actix_web::{delete, get, post, put, web, HttpResponse, HttpRequest, ResponseError};
use log::{error, warn};
@@ -16,21 +20,22 @@ struct GetAllParameters {
categories: Option<String>,
order_field: Option<String>,
order_by: Option<String>,
has_metar: Option<String>,
limit: Option<i32>,
page: Option<i32>
page: Option<i32>,
}
#[post("/import")]
async fn import(mut payload: Multipart, auth: JwtAuth) -> HttpResponse {
if let Err(err) = verify_role(&auth, "admin") {
return ResponseError::error_response(&err)
return ResponseError::error_response(&err);
};
while let Some(item) = payload.next().await {
let mut bytes = web::BytesMut::new();
let mut field = match item {
Ok(field) => field,
Err(err) => return ResponseError::error_response(&err)
Err(err) => return ResponseError::error_response(&err),
};
// Build bytes from chunks
@@ -57,10 +62,10 @@ async fn import(mut payload: Multipart, auth: JwtAuth) -> HttpResponse {
// Convert Vec<Airport> to Vec<QueryAirport> and insert into database
let query_airports: Vec<QueryAirport> = airports.into_iter().map(|a| a.into()).collect();
match QueryAirport::insert_all(query_airports) {
Ok(_) => {},
Err(err) => return ResponseError::error_response(&err)
};
Ok(_) => {}
Err(err) => return ResponseError::error_response(&err),
};
}
HttpResponse::Ok().finish()
}
@@ -70,83 +75,117 @@ async fn get_all(req: HttpRequest) -> HttpResponse {
let mut filters = QueryFilters::default();
filters.icaos = match &params.icaos {
Some(i) => Some(i.split(",").map(|s| s.to_string()).collect()),
None => None
None => None,
};
filters.name = params.name.clone();
filters.categories = match &params.categories {
Some(c) => Some(c.split(",").map(|s| AirportCategory::from_str(s).unwrap()).collect()),
None => None
Some(c) => Some(
c.split(",")
.map(|s| AirportCategory::from_str(s).unwrap())
.collect(),
),
None => None,
};
filters.bounds = match &params.bounds {
Some(b) => {
let bounds: Vec<&str> = b.split(",").collect();
if bounds.len() != 4 {
warn!("Expected 4 bounds, received {}: {}", bounds.len(), b);
return HttpResponse::UnprocessableEntity().body(format!("Received {}; expected NE_LAT,NE_LON,SW_LAT,SW_LON", b))
return HttpResponse::UnprocessableEntity().body(format!(
"Received {}; expected NE_LAT,NE_LON,SW_LAT,SW_LON",
b
));
}
let ne_lat = match bounds[0].parse::<f64>() {
Ok(b) => b,
Err(err) => {
warn!("{}", err);
return HttpResponse::UnprocessableEntity().body(format!("{}", err))
return HttpResponse::UnprocessableEntity().body(format!("{}", err));
}
};
let ne_lon = match bounds[1].parse::<f64>() {
Ok(b) => b,
Err(err) => {
warn!("{}", err);
return HttpResponse::UnprocessableEntity().body(format!("{}", err))
return HttpResponse::UnprocessableEntity().body(format!("{}", err));
}
};
let sw_lat = match bounds[2].parse::<f64>() {
Ok(b) => b,
Err(err) => {
warn!("{}", err);
return HttpResponse::UnprocessableEntity().body(format!("{}", err))
return HttpResponse::UnprocessableEntity().body(format!("{}", err));
}
};
let sw_lon = match bounds[3].parse::<f64>() {
Ok(b) => b,
Err(err) => {
warn!("{}", err);
return HttpResponse::UnprocessableEntity().body(format!("{}", err))
return HttpResponse::UnprocessableEntity().body(format!("{}", err));
}
};
let mut polygon: Polygon<Point> = Polygon::new(Some(4326));
polygon.add_point(Point { x: sw_lon, y: sw_lat, srid: Some(4326) });
polygon.add_point(Point { x: ne_lon, y: sw_lat, srid: Some(4326) });
polygon.add_point(Point { x: ne_lon, y: ne_lat, srid: Some(4326) });
polygon.add_point(Point { x: sw_lon, y: ne_lat, srid: Some(4326) });
polygon.add_point(Point { x: sw_lon, y: sw_lat, srid: Some(4326) });
polygon.add_point(Point {
x: sw_lon,
y: sw_lat,
srid: Some(4326),
});
polygon.add_point(Point {
x: ne_lon,
y: sw_lat,
srid: Some(4326),
});
polygon.add_point(Point {
x: ne_lon,
y: ne_lat,
srid: Some(4326),
});
polygon.add_point(Point {
x: sw_lon,
y: ne_lat,
srid: Some(4326),
});
polygon.add_point(Point {
x: sw_lon,
y: sw_lat,
srid: Some(4326),
});
Some(polygon)
},
None => None
}
None => None,
};
filters.order_by = match &params.order_by {
Some(o) => Some(QueryOrderBy::from_str(&o).unwrap()),
None => None
None => None,
};
filters.order_field = match &params.order_field {
Some(o) => Some(QueryOrderField::from_str(&o).unwrap()),
None => None
None => None,
};
filters.has_metar = match &params.has_metar {
Some(h) => Some(h.parse::<bool>().unwrap()),
None => None,
};
let limit = match params.limit {
Some(l) => l,
None => 100
None => 100,
};
let page = match params.page {
Some(p) => p,
None => 1
None => 1,
};
let total = match QueryAirport::get_count(&filters) {
Ok(t) => t,
Err(_) => 0
Err(_) => 0,
};
let pages = ((total as f64) / (if limit <= 0 { 1 } else { limit} as f64)).ceil() as i64;
let pages = ((total as f64) / (if limit <= 0 { 1 } else { limit } as f64)).ceil() as i64;
match web::block(move || QueryAirport::get_all(&filters, limit, page)).await.unwrap() {
match web::block(move || QueryAirport::get_all(&filters, limit, page))
.await
.unwrap()
{
Ok(a) => {
// Convert Vec<QueryAirport> to Vec<Airport>
let mut airports: Vec<Airport> = vec![];
@@ -155,9 +194,14 @@ async fn get_all(req: HttpRequest) -> HttpResponse {
}
HttpResponse::Ok().json(Response {
data: airports,
meta: Some(Metadata { page, limit, pages, total })
meta: Some(Metadata {
page,
limit,
pages,
total,
}),
})
},
}
Err(err) => {
error!("{}", err);
err.to_http_response()
@@ -172,9 +216,14 @@ async fn get(icao: web::Path<String>) -> HttpResponse {
let airport: Airport = a.into();
HttpResponse::Ok().json(Response {
data: airport,
meta: Some(Metadata { page: 1, limit: 1, pages: 1, total: 1 })
meta: Some(Metadata {
page: 1,
limit: 1,
pages: 1,
total: 1,
}),
})
},
}
Err(err) => {
error!("{}", err);
err.to_http_response()
@@ -185,15 +234,15 @@ async fn get(icao: web::Path<String>) -> HttpResponse {
#[post("")]
async fn create(airport: web::Json<Airport>, auth: JwtAuth) -> HttpResponse {
let _ = match verify_role(&auth, "admin") {
Ok(_) => {},
Err(err) => return ResponseError::error_response(&err)
Ok(_) => {}
Err(err) => return ResponseError::error_response(&err),
};
let query_airport: QueryAirport = airport.into_inner().into();
match QueryAirport::insert(query_airport) {
Ok(a) => {
let airport: Airport = a.into();
HttpResponse::Ok().json(airport)
},
}
Err(err) => {
error!("{}", err);
err.to_http_response()
@@ -202,17 +251,21 @@ async fn create(airport: web::Json<Airport>, auth: JwtAuth) -> HttpResponse {
}
#[put("/{icao}")]
async fn update(_icao: web::Path<String>, airport: web::Json<Airport>, auth: JwtAuth) -> HttpResponse {
async fn update(
_icao: web::Path<String>,
airport: web::Json<Airport>,
auth: JwtAuth,
) -> HttpResponse {
let _ = match verify_role(&auth, "admin") {
Ok(_) => {},
Err(err) => return ResponseError::error_response(&err)
Ok(_) => {}
Err(err) => return ResponseError::error_response(&err),
};
let query_airport: QueryAirport = airport.into_inner().into();
match QueryAirport::update(query_airport) {
Ok(a) => {
let airport: Airport = a.into();
HttpResponse::Ok().json(airport)
},
}
Err(err) => {
error!("{}", err);
err.to_http_response()
@@ -223,8 +276,8 @@ async fn update(_icao: web::Path<String>, airport: web::Json<Airport>, auth: Jwt
#[delete("")]
async fn delete_all(auth: JwtAuth) -> HttpResponse {
let _ = match verify_role(&auth, "admin") {
Ok(_) => {},
Err(err) => return ResponseError::error_response(&err)
Ok(_) => {}
Err(err) => return ResponseError::error_response(&err),
};
match QueryAirport::delete(None) {
Ok(_) => HttpResponse::NoContent().finish(),
@@ -238,8 +291,8 @@ async fn delete_all(auth: JwtAuth) -> HttpResponse {
#[delete("/{icao}")]
async fn delete(icao: web::Path<String>, auth: JwtAuth) -> HttpResponse {
let _ = match verify_role(&auth, "admin") {
Ok(_) => {},
Err(err) => return ResponseError::error_response(&err)
Ok(_) => {}
Err(err) => return ResponseError::error_response(&err),
};
match QueryAirport::delete(Some(icao.into_inner())) {
Ok(_) => HttpResponse::NoContent().finish(),
@@ -251,13 +304,14 @@ async fn delete(icao: web::Path<String>, auth: JwtAuth) -> HttpResponse {
}
pub fn init_routes(config: &mut web::ServiceConfig) {
config.service(web::scope("airports")
config.service(
web::scope("airports")
.service(get_all)
.service(get)
.service(create)
.service(update)
.service(delete)
.service(delete_all)
.service(import)
.service(import),
);
}

37
service/src/auth/mod.rs
View File

@@ -1,6 +1,11 @@
use std::env;
use argon2::{password_hash::{rand_core::OsRng, PasswordHasher, PasswordVerifier, SaltString, Error as HashError}, Argon2, PasswordHash};
use argon2::{
password_hash::{
rand_core::OsRng, PasswordHasher, PasswordVerifier, SaltString, Error as HashError,
},
Argon2, PasswordHash,
};
use jsonwebtoken::{DecodingKey, EncodingKey, Header, encode, decode, Validation, Algorithm};
use serde::{Deserialize, Serialize};
@@ -18,7 +23,7 @@ struct TokenClaims {
iss: String, // Issuer
exp: i64, // Expiration time
iat: i64, // Issued At
nbf: i64 // Not Before
nbf: i64, // Not Before
}
#[derive(Debug, Serialize, Deserialize)]
@@ -26,7 +31,7 @@ pub struct TokenDetails {
pub token: Option<String>,
pub token_uuid: uuid::Uuid,
pub email: String,
pub expires_in: Option<i64>
pub expires_in: Option<i64>,
}
pub fn verify_token(token: &str, public_key: &str) -> Result<TokenDetails, ServiceError> {
@@ -35,7 +40,12 @@ pub fn verify_token(token: &str, public_key: &str) -> Result<TokenDetails, Servi
let decoded = decode::<TokenClaims>(token, &key, &validation)?;
let email = decoded.claims.sub;
let token_uuid = uuid::Uuid::parse_str(decoded.claims.token_uuid.as_str()).unwrap();
Ok(TokenDetails { token: None, token_uuid, email, expires_in: None })
Ok(TokenDetails {
token: None,
token_uuid,
email,
expires_in: None,
})
}
pub fn generate_access_token(email: &str) -> Result<TokenDetails, ServiceError> {
@@ -54,17 +64,22 @@ pub fn generate_refresh_token(email: &str) -> Result<TokenDetails, ServiceError>
.parse::<i64>()
.expect("REFRESH_TOKEN_MAXAGE must be an integer");
let keys_dir = env::var("KEYS_DIR_PATH")?;
let refresh_private_key = std::fs::read_to_string(format!("{}/refresh_private_key.pem", keys_dir))?;
let refresh_private_key =
std::fs::read_to_string(format!("{}/refresh_private_key.pem", keys_dir))?;
generate_token(&email, refresh_token_max_age, &refresh_private_key)
}
pub fn generate_token(email: &str, ttl: i64, private_key: &str) -> Result<TokenDetails, ServiceError> {
pub fn generate_token(
email: &str,
ttl: i64,
private_key: &str,
) -> Result<TokenDetails, ServiceError> {
let now = chrono::Utc::now();
let mut token_details = TokenDetails {
token: None,
token_uuid: uuid::Uuid::new_v4(),
email: email.to_string(),
expires_in: Some((now + chrono::Duration::minutes(ttl)).timestamp())
expires_in: Some((now + chrono::Duration::minutes(ttl)).timestamp()),
};
let claims = TokenClaims {
sub: token_details.email.clone(),
@@ -72,7 +87,7 @@ pub fn generate_token(email: &str, ttl: i64, private_key: &str) -> Result<TokenD
token_uuid: token_details.token_uuid.to_string(),
exp: token_details.expires_in.unwrap(),
iat: now.timestamp(),
nbf: now.timestamp()
nbf: now.timestamp(),
};
let header = Header::new(Algorithm::RS256);
let key = EncodingKey::from_rsa_pem(private_key.as_bytes())?;
@@ -83,7 +98,11 @@ pub fn generate_token(email: &str, ttl: i64, private_key: &str) -> Result<TokenD
pub fn hash_password(password: &[u8]) -> Result<String, HashError> {
let salt = SaltString::generate(&mut OsRng);
Ok(Argon2::default().hash_password(password, &salt)?.to_string())
Ok(
Argon2::default()
.hash_password(password, &salt)?
.to_string(),
)
}
pub fn verify_password(hash: &str, password: &[u8]) -> Result<(), HashError> {

53
service/src/auth/model.rs
View File

@@ -1,4 +1,7 @@
use std::{future::{ready, Ready}, env};
use std::{
future::{ready, Ready},
env,
};
use actix_web::{FromRequest, Error as ActixError, HttpRequest, dev::Payload, http};
use diesel::prelude::*;
use log::error;
@@ -93,7 +96,10 @@ impl InsertUser {
Ok(user)
}
pub fn update_profile_picture(email: &str, profile_picture: Option<&str>) -> Result<QueryUser, ServiceError> {
pub fn update_profile_picture(
email: &str,
profile_picture: Option<&str>,
) -> Result<QueryUser, ServiceError> {
let mut conn = connection()?;
let user = diesel::update(users::table)
.filter(users::email.eq(&email))
@@ -136,7 +142,7 @@ impl From<QueryUser> for ResponseUser {
#[derive(Debug, Serialize, Deserialize)]
pub struct JwtAuth {
pub token: uuid::Uuid,
pub user: ResponseUser
pub user: ResponseUser,
}
impl FromRequest for JwtAuth {
@@ -147,18 +153,23 @@ impl FromRequest for JwtAuth {
.cookie("access_token")
.map(|c| c.value().to_string())
.or_else(|| {
req.headers().get(http::header::AUTHORIZATION)
req
.headers()
.get(http::header::AUTHORIZATION)
.map(|h| h.to_str().unwrap().split_at(7).1.to_string())
}) {
Some(token) => token,
None => return ready(Err(ActixError::from(ServiceError {
None => {
return ready(Err(ActixError::from(ServiceError {
status: 401,
message: "Unauthorized".to_string()
message: "Unauthorized".to_string(),
})))
}
};
let keys_dir = env::var("KEYS_DIR_PATH").expect("KEYS_DIR_PATH must be set");
let public_key = std::fs::read_to_string(format!("{}/access_public_key.pem", keys_dir)).expect("Failed to read access public key");
let public_key = std::fs::read_to_string(format!("{}/access_public_key.pem", keys_dir))
.expect("Failed to read access public key");
let access_token_details = match verify_token(&access_token, &public_key) {
Ok(token_details) => token_details,
@@ -166,12 +177,13 @@ impl FromRequest for JwtAuth {
error!("Failed to verify access token: {}", err);
return ready(Err(ActixError::from(ServiceError {
status: 401,
message: format!("Failed to verify access token: {}", err)
})))
message: format!("Failed to verify access token: {}", err),
})));
}
};
let access_token_uuid = uuid::Uuid::parse_str(&access_token_details.token_uuid.to_string()).unwrap();
let access_token_uuid =
uuid::Uuid::parse_str(&access_token_details.token_uuid.to_string()).unwrap();
let mut conn = match crate::db::redis_connection() {
Ok(conn) => conn,
@@ -179,8 +191,8 @@ impl FromRequest for JwtAuth {
error!("Failed to get redis connection: {}", err);
return ready(Err(ActixError::from(ServiceError {
status: 500,
message: format!("Failed to get redis connection: {}", err)
})))
message: format!("Failed to get redis connection: {}", err),
})));
}
};
let user_email = match conn.get::<_, String>(access_token_uuid.clone().to_string()) {
@@ -188,21 +200,24 @@ impl FromRequest for JwtAuth {
Err(_) => {
return ready(Err(ActixError::from(ServiceError {
status: 401,
message: format!("Access token was not found")
message: format!("Access token was not found"),
})))
}
};
match QueryUser::get_by_email(&user_email) {
Ok(user) => {
ready(Ok(JwtAuth { token: access_token_uuid, user: user.into() }))
}
Err(_) => return ready(Err(ActixError::from(ServiceError {
Ok(user) => ready(Ok(JwtAuth {
token: access_token_uuid,
user: user.into(),
})),
Err(_) => {
return ready(Err(ActixError::from(ServiceError {
status: 401,
message: format!("User was not found")
message: format!("User was not found"),
})))
}
}
}
}
pub fn verify_role(auth: &JwtAuth, role: &str) -> Result<(), ServiceError> {
@@ -211,7 +226,7 @@ pub fn verify_role(auth: &JwtAuth, role: &str) -> Result<(), ServiceError> {
} else {
Err(ServiceError {
status: 403,
message: "Forbidden".to_string()
message: "Forbidden".to_string(),
})
}
}

198
service/src/auth/routes.rs
View File

@@ -1,24 +1,32 @@
use std::env;
use actix_web::{get, post, web, HttpResponse, ResponseError, cookie::{Cookie, time::Duration}, HttpRequest};
use actix_web::{
get, post, web, HttpResponse, ResponseError,
cookie::{Cookie, time::Duration},
HttpRequest,
};
use log::error;
use redis::AsyncCommands;
use serde::{Serialize, Deserialize};
use crate::{error_handler::ServiceError, db::Response};
use crate::{auth::{LoginRequest, RegisterUser, InsertUser, QueryUser, verify_password, JwtAuth, verify_token, generate_access_token, generate_refresh_token}, db};
use crate::{
auth::{
LoginRequest, RegisterUser, InsertUser, QueryUser, verify_password, JwtAuth, verify_token,
generate_access_token, generate_refresh_token,
},
db,
};
#[post("/register")]
async fn register(user: web::Json<RegisterUser>) -> HttpResponse {
let register_user = user.0;
let insert_user: InsertUser = match register_user.convert_to_insert() {
Ok(user) => user,
Err(err) => return ResponseError::error_response(&err)
Err(err) => return ResponseError::error_response(&err),
};
match InsertUser::insert(insert_user) {
Ok(_) => {
HttpResponse::Created().finish()
},
Ok(_) => HttpResponse::Created().finish(),
Err(err) => {
// Obfuscate the service error message to prevent leaking database details
if err.status == 409 {
@@ -36,7 +44,7 @@ async fn login(request: web::Json<LoginRequest>) -> HttpResponse {
let query_user = match QueryUser::get_by_email(&email) {
Ok(query_user) => query_user,
Err(err) => return ResponseError::error_response(&err)
Err(err) => return ResponseError::error_response(&err),
};
let hash = &query_user.hash;
let password = request.password.as_bytes();
@@ -46,7 +54,7 @@ async fn login(request: web::Json<LoginRequest>) -> HttpResponse {
Ok(token_details) => token_details,
Err(err) => {
error!("Failed to generate access token: {}", err);
return ResponseError::error_response(&err)
return ResponseError::error_response(&err);
}
};
@@ -54,7 +62,7 @@ async fn login(request: web::Json<LoginRequest>) -> HttpResponse {
Ok(token_details) => token_details,
Err(err) => {
error!("Failed to generate refresh token: {}", err);
return ResponseError::error_response(&err)
return ResponseError::error_response(&err);
}
};
@@ -62,7 +70,7 @@ async fn login(request: web::Json<LoginRequest>) -> HttpResponse {
Ok(conn) => conn,
Err(err) => {
error!("Failed to get redis connection: {}", err);
return ResponseError::error_response(&err)
return ResponseError::error_response(&err);
}
};
@@ -76,31 +84,47 @@ async fn login(request: web::Json<LoginRequest>) -> HttpResponse {
.parse::<i64>()
.expect("REFRESH_TOKEN_MAXAGE must be an integer");
let access_result: redis::RedisResult<()> = conn.set_ex(access_token_details.token_uuid.to_string(), &email, (access_token_max_age * 60) as usize).await;
let access_result: redis::RedisResult<()> = conn
.set_ex(
access_token_details.token_uuid.to_string(),
&email,
(access_token_max_age * 60) as u64,
)
.await;
if let Err(err) = access_result {
error!("Failed to set access token in redis: {}", err);
return ResponseError::error_response(&ServiceError {
status: 500,
message: format!("Failed to set access token in redis: {}", err)
})
message: format!("Failed to set access token in redis: {}", err),
});
};
let refresh_result: redis::RedisResult<()> = conn.set_ex(refresh_token_details.token_uuid.to_string(), &email, (refresh_token_max_age * 60) as usize).await;
let refresh_result: redis::RedisResult<()> = conn
.set_ex(
refresh_token_details.token_uuid.to_string(),
&email,
(refresh_token_max_age * 60) as u64,
)
.await;
if let Err(err) = refresh_result {
error!("Failed to set refresh token in redis: {}", err);
return ResponseError::error_response(&ServiceError {
status: 500,
message: format!("Failed to set refresh token in redis: {}", err)
})
message: format!("Failed to set refresh token in redis: {}", err),
});
};
let access_cookie = Cookie::build("access_token", access_token_details.token.clone().unwrap())
let access_cookie =
Cookie::build("access_token", access_token_details.token.clone().unwrap())
.path("/")
.max_age(Duration::new(access_token_max_age * 60, 0))
.http_only(true)
.secure(true)
.finish();
let refresh_cookie = Cookie::build("refresh_token", refresh_token_details.token.clone().unwrap())
let refresh_cookie = Cookie::build(
"refresh_token",
refresh_token_details.token.clone().unwrap(),
)
.path("/")
.max_age(Duration::new(refresh_token_max_age * 60, 0))
.http_only(true)
@@ -112,18 +136,22 @@ async fn login(request: web::Json<LoginRequest>) -> HttpResponse {
.http_only(false)
.finish();
let access_token_uuid = uuid::Uuid::parse_str(&access_token_details.token_uuid.to_string()).unwrap();
let access_token_uuid =
uuid::Uuid::parse_str(&access_token_details.token_uuid.to_string()).unwrap();
HttpResponse::Ok()
.cookie(access_cookie)
.cookie(refresh_cookie)
.cookie(logged_in_cookie)
.json(JwtAuth { token: access_token_uuid, user: query_user.into() })
},
.json(JwtAuth {
token: access_token_uuid,
user: query_user.into(),
})
}
Err(err) => ResponseError::error_response(&ServiceError {
status: 401,
message: err.to_string()
})
message: err.to_string(),
}),
}
}
@@ -138,10 +166,10 @@ async fn session(req: HttpRequest) -> HttpResponse {
.expect("Unable to read refresh public key");
match verify_token(&access_token, &public_key) {
Ok(_) => true,
Err(_) => false
Err(_) => false,
}
},
None => false
}
None => false,
};
if !has_session {
// If there is a refresh_token cookie, check if it is valid
@@ -152,37 +180,41 @@ async fn session(req: HttpRequest) -> HttpResponse {
.expect("Unable to read refresh public key");
match verify_token(&refresh_token, &public_key) {
Ok(_) => return HttpResponse::Ok().json(true),
Err(_) => return HttpResponse::Ok().json(false)
Err(_) => return HttpResponse::Ok().json(false),
};
},
None => return HttpResponse::Ok().json(false)
}
None => return HttpResponse::Ok().json(false),
};
} else {
return HttpResponse::Ok().json(true)
return HttpResponse::Ok().json(true);
}
}
#[derive(Serialize, Deserialize)]
struct RefreshParams {
refresh_token_rotation: Option<bool>
refresh_token_rotation: Option<bool>,
}
#[get("/refresh")]
async fn refresh(req: HttpRequest) -> HttpResponse {
let params = match web::Query::<RefreshParams>::from_query(req.query_string()) {
Ok(params) => params,
Err(err) => return ResponseError::error_response(&ServiceError {
Err(err) => {
return ResponseError::error_response(&ServiceError {
status: 422,
message: err.to_string()
message: err.to_string(),
})
}
};
let refresh_token = match req.cookie("refresh_token") {
Some(cookie) => cookie.value().to_string(),
None => return ResponseError::error_response(&ServiceError {
None => {
return ResponseError::error_response(&ServiceError {
status: 401,
message: "Refresh token not found".to_string()
message: "Refresh token not found".to_string(),
})
}
};
let keys_dir = env::var("KEYS_DIR_PATH").expect("KEYS_DIR_PATH must be set");
@@ -190,7 +222,7 @@ async fn refresh(req: HttpRequest) -> HttpResponse {
.expect("Unable to read refresh public key");
let refresh_token_details = match verify_token(&refresh_token, &public_key) {
Ok(token_details) => token_details,
Err(err) => return ResponseError::error_response(&err)
Err(err) => return ResponseError::error_response(&err),
};
let email = refresh_token_details.email.clone();
@@ -201,7 +233,7 @@ async fn refresh(req: HttpRequest) -> HttpResponse {
Ok(token_details) => token_details,
Err(err) => {
error!("Failed to generate access token: {}", err);
return ResponseError::error_response(&err)
return ResponseError::error_response(&err);
}
};
@@ -209,7 +241,7 @@ async fn refresh(req: HttpRequest) -> HttpResponse {
Ok(conn) => conn,
Err(err) => {
error!("Failed to get redis connection: {}", err);
return ResponseError::error_response(&err)
return ResponseError::error_response(&err);
}
};
@@ -223,11 +255,10 @@ async fn refresh(req: HttpRequest) -> HttpResponse {
match verify_token(&access_token, &public_key) {
Ok(token_details) => {
let _: redis::RedisResult<()> = conn.del(token_details.token_uuid.to_string()).await;
},
}
Err(_) => {}
};
},
}
None => {}
};
@@ -236,16 +267,23 @@ async fn refresh(req: HttpRequest) -> HttpResponse {
.parse::<i64>()
.expect("ACCESS_TOKEN_MAXAGE must be an integer");
let access_result: redis::RedisResult<()> = conn.set_ex(access_token_details.token_uuid.to_string(), &email, (access_token_max_age * 60) as usize).await;
let access_result: redis::RedisResult<()> = conn
.set_ex(
access_token_details.token_uuid.to_string(),
&email,
(access_token_max_age * 60) as u64,
)
.await;
if let Err(err) = access_result {
error!("Failed to set access token in redis: {}", err);
return ResponseError::error_response(&ServiceError {
status: 500,
message: format!("Failed to set access token in redis: {}", err)
})
message: format!("Failed to set access token in redis: {}", err),
});
};
let access_cookie = Cookie::build("access_token", access_token_details.token.clone().unwrap())
let access_cookie =
Cookie::build("access_token", access_token_details.token.clone().unwrap())
.path("/")
.max_age(Duration::new(access_token_max_age * 60, 0))
.http_only(true)
@@ -257,22 +295,24 @@ async fn refresh(req: HttpRequest) -> HttpResponse {
.http_only(false)
.finish();
let access_token_uuid = uuid::Uuid::parse_str(&access_token_details.token_uuid.to_string()).unwrap();
let access_token_uuid =
uuid::Uuid::parse_str(&access_token_details.token_uuid.to_string()).unwrap();
// Refresh the refresh token if requested
let refresh_token_rotation = match params.refresh_token_rotation {
Some(refresh_token_rotation) => refresh_token_rotation,
None => false
None => false,
};
if refresh_token_rotation {
// Delete the old refresh token
let _: redis::RedisResult<()> = conn.del(refresh_token_details.token_uuid.to_string()).await;
let _: redis::RedisResult<()> =
conn.del(refresh_token_details.token_uuid.to_string()).await;
let refresh_token_details = match generate_refresh_token(&refresh_token_details.email) {
Ok(token_details) => token_details,
Err(err) => {
error!("Failed to generate refresh token: {}", err);
return ResponseError::error_response(&err)
return ResponseError::error_response(&err);
}
};
@@ -281,16 +321,25 @@ async fn refresh(req: HttpRequest) -> HttpResponse {
.parse::<i64>()
.expect("REFRESH_TOKEN_MAXAGE must be an integer");
let refresh_result: redis::RedisResult<()> = conn.set_ex(refresh_token_details.token_uuid.to_string(), &refresh_token_details.email, (refresh_token_max_age * 60) as usize).await;
let refresh_result: redis::RedisResult<()> = conn
.set_ex(
refresh_token_details.token_uuid.to_string(),
&refresh_token_details.email,
(refresh_token_max_age * 60) as u64,
)
.await;
if let Err(err) = refresh_result {
error!("Failed to set refresh token in redis: {}", err);
return ResponseError::error_response(&ServiceError {
status: 500,
message: format!("Failed to set refresh token in redis: {}", err)
})
message: format!("Failed to set refresh token in redis: {}", err),
});
};
let refresh_cookie = Cookie::build("refresh_token", refresh_token_details.token.clone().unwrap())
let refresh_cookie = Cookie::build(
"refresh_token",
refresh_token_details.token.clone().unwrap(),
)
.path("/")
.max_age(Duration::new(refresh_token_max_age * 60, 0))
.http_only(true)
@@ -301,15 +350,21 @@ async fn refresh(req: HttpRequest) -> HttpResponse {
.cookie(refresh_cookie)
.cookie(access_cookie)
.cookie(logged_in_cookie)
.json(JwtAuth { token: access_token_uuid, user: query_user.into() })
.json(JwtAuth {
token: access_token_uuid,
user: query_user.into(),
})
} else {
HttpResponse::Ok()
.cookie(access_cookie)
.cookie(logged_in_cookie)
.json(JwtAuth { token: access_token_uuid, user: query_user.into() })
.json(JwtAuth {
token: access_token_uuid,
user: query_user.into(),
})
}
},
Err(err) => return ResponseError::error_response(&err)
}
Err(err) => return ResponseError::error_response(&err),
}
}
@@ -317,37 +372,41 @@ async fn refresh(req: HttpRequest) -> HttpResponse {
async fn logout(req: HttpRequest, auth: JwtAuth) -> HttpResponse {
let refresh_token = match req.cookie("refresh_token") {
Some(cookie) => cookie.value().to_string(),
None => return ResponseError::error_response(&ServiceError {
None => {
return ResponseError::error_response(&ServiceError {
status: 401,
message: "Refresh token not found".to_string()
message: "Refresh token not found".to_string(),
})
}
};
let keys_dir = env::var("KEYS_DIR_PATH").expect("KEYS_DIR_PATH must be set");
let public_key = std::fs::read_to_string(format!("{}/refresh_public_key.pem", keys_dir))
.expect("Unable to read refresh public key");
let refresh_token_details = match verify_token(&refresh_token, &public_key) {
Ok(token_details) => token_details,
Err(err) => return ResponseError::error_response(&err)
Err(err) => return ResponseError::error_response(&err),
};
let mut conn = match db::redis_async_connection().await {
Ok(conn) => conn,
Err(err) => {
error!("Failed to get redis connection: {}", err);
return ResponseError::error_response(&err)
return ResponseError::error_response(&err);
}
};
let access_result: redis::RedisResult<()> = conn.del(&[
let access_result: redis::RedisResult<()> = conn
.del(&[
refresh_token_details.token_uuid.to_string(),
auth.token.to_string()
]).await;
auth.token.to_string(),
])
.await;
if let Err(err) = access_result {
error!("Failed to set access token in redis: {}", err);
return ResponseError::error_response(&ServiceError {
status: 500,
message: format!("Failed to set access token in redis: {}", err)
})
message: format!("Failed to set access token in redis: {}", err),
});
};
let access_cookie = Cookie::build("access_token", "")
@@ -382,7 +441,7 @@ async fn me(auth: JwtAuth) -> HttpResponse {
async fn roles() -> HttpResponse {
HttpResponse::Ok().json(Response {
data: vec!["admin", "user"],
meta: None
meta: None,
})
}
@@ -397,12 +456,13 @@ pub fn init_routes(config: &mut web::ServiceConfig) {
u.role = "admin".to_string();
u.verified = true;
let _ = InsertUser::insert(u);
config.service(web::scope("auth")
config.service(
web::scope("auth")
.service(register)
.service(login)
.service(refresh)
.service(logout)
.service(me)
.service(roles)
.service(roles),
);
}

52
service/src/db/mod.rs
View File

@@ -1,7 +1,10 @@
use crate::error_handler::ServiceError;
use diesel::{r2d2::ConnectionManager, PgConnection};
use redis::{Client as RedisClient, aio::Connection as RedisConnection};
use s3::{Bucket, Region, creds::Credentials, BucketConfiguration, request::ResponseData, bucket_ops::CreateBucketResponse};
use redis::{Client as RedisClient, aio::MultiplexedConnection as RedisConnection};
use s3::{
Bucket, Region, creds::Credentials, BucketConfiguration, request::ResponseData,
bucket_ops::CreateBucketResponse,
};
use serde::{Deserialize, Serialize};
use crate::diesel_migrations::MigrationHarness;
use lazy_static::lazy_static;
@@ -23,9 +26,15 @@ lazy_static! {
let host = env::var("DATABASE_HOST").unwrap_or("localhost".to_string());
let name = env::var("DATABASE_NAME").expect("Database name is not set");
let port = env::var("DATABASE_PORT").unwrap_or("5432".to_string());
let url = format!("postgres://{}:{}@{}:{}/{}", username, password, host, port, name);
let url = format!(
"postgres://{}:{}@{}:{}/{}",
username, password, host, port, name
);
let manager = ConnectionManager::<PgConnection>::new(url);
Pool::builder().test_on_check_out(true).build(manager).expect("Failed to create db pool")
Pool::builder()
.test_on_check_out(true)
.build(manager)
.expect("Failed to create db pool")
};
static ref REDIS: RedisClient = {
let host = env::var("REDIS_HOST").unwrap_or("localhost".to_string());
@@ -50,10 +59,12 @@ lazy_static! {
secret_key: Some(password),
security_token: None,
session_token: None,
expiration: None
expiration: None,
};
Bucket::new("aviation", region.clone(), credentials.clone()).expect("Failed to create S3 Bucket").with_path_style()
Bucket::new("aviation", region.clone(), credentials.clone())
.expect("Failed to create S3 Bucket")
.with_path_style()
};
}
@@ -63,22 +74,21 @@ pub async fn init() {
lazy_static::initialize(&BUCKET);
match create_bucket().await {
Ok(_) => info!("Bucket initialized"),
Err(err) => {
match err.status {
Err(err) => match err.status {
409 => warn!("Bucket already exists"),
_ => error!("Failed to initialize bucket; {}", err.message)
}
}
_ => error!("Failed to initialize bucket; {}", err.message),
},
};
let mut pool: DbConnection = connection().expect("Failed to get db connection");
match pool.run_pending_migrations(MIGRATIONS) {
Ok(_) => info!("Database initialized"),
Err(err) => error!("Failed to initialize database; {}", err)
Err(err) => error!("Failed to initialize database; {}", err),
};
}
pub fn connection() -> Result<DbConnection, ServiceError> {
POOL.get()
POOL
.get()
.map_err(|e| ServiceError::new(500, format!("Failed getting db connection: {}", e)))
}
@@ -88,7 +98,7 @@ pub fn redis_connection() -> Result<redis::Connection, ServiceError> {
}
pub async fn redis_async_connection() -> Result<RedisConnection, ServiceError> {
let conn = REDIS.get_async_connection().await?;
let conn = REDIS.get_multiplexed_async_connection().await?;
Ok(conn)
}
@@ -109,10 +119,16 @@ async fn create_bucket() -> Result<CreateBucketResponse, ServiceError> {
secret_key: Some(password),
security_token: None,
session_token: None,
expiration: None
expiration: None,
};
let bucket_name = "aviation";
let response = Bucket::create_with_path_style(bucket_name, region, credentials, BucketConfiguration::default()).await?;
let response = Bucket::create_with_path_style(
bucket_name,
region,
credentials,
BucketConfiguration::default(),
)
.await?;
Ok(response)
}
@@ -135,7 +151,7 @@ pub async fn delete_file(path: &str) -> Result<ResponseData, ServiceError> {
#[derive(Serialize, Deserialize)]
pub struct Response<T> {
pub data: T,
pub meta: Option<Metadata>
pub meta: Option<Metadata>,
}
#[derive(Serialize, Deserialize)]
@@ -149,5 +165,5 @@ pub struct Metadata {
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub struct Coordinate {
pub lon: f64,
pub lat: f64
pub lat: f64,
}

49
service/src/error_handler.rs
View File

@@ -14,10 +14,7 @@ pub struct ServiceError {
impl ServiceError {
pub fn new(status: u16, message: String) -> ServiceError {
ServiceError {
status,
message,
}
ServiceError { status, message }
}
pub fn to_http_response(&self) -> HttpResponse {
@@ -46,27 +43,24 @@ impl From<std::io::Error> for ServiceError {
impl From<std::env::VarError> for ServiceError {
fn from(error: std::env::VarError) -> ServiceError {
ServiceError::new(500, format!("Unknown environment variable error: {}", error))
ServiceError::new(
500,
format!("Unknown environment variable error: {}", error),
)
}
}
impl From<DieselError> for ServiceError {
fn from(error: DieselError) -> ServiceError {
match error {
DieselError::DatabaseError(kind, err) => {
match kind {
DieselError::DatabaseError(kind, err) => match kind {
diesel::result::DatabaseErrorKind::UniqueViolation => {
ServiceError::new(409, err.message().to_string())
},
_ => ServiceError::new(500, err.message().to_string())
}
_ => ServiceError::new(500, err.message().to_string()),
},
DieselError::NotFound => {
ServiceError::new(404, "The record was not found".to_string())
},
DieselError::SerializationError(err) => {
ServiceError::new(422, err.to_string())
},
DieselError::NotFound => ServiceError::new(404, "The record was not found".to_string()),
DieselError::SerializationError(err) => ServiceError::new(422, err.to_string()),
err => ServiceError::new(500, format!("Unknown Diesel error: {}", err)),
}
}
@@ -105,13 +99,24 @@ impl From<redis::RedisError> for ServiceError {
impl From<s3::error::S3Error> for ServiceError {
fn from(error: s3::error::S3Error) -> ServiceError {
match error {
s3::error::S3Error::Credentials(err) => ServiceError::new(500, format!("Unknown s3 credentials error: {}", err)),
s3::error::S3Error::FromUtf8(err) => ServiceError::new(500, format!("Unknown s3 from utf8 error: {}", err)),
s3::error::S3Error::FmtError(err) => ServiceError::new(500, format!("Unknown s3 fmt error: {}", err)),
s3::error::S3Error::HeaderToStr(err) => ServiceError::new(500, format!("Unknown s3 header to str error: {}", err)),
s3::error::S3Error::HmacInvalidLength(err) => ServiceError::new(500, format!("Unknown s3 hmac invalid length error: {}", err)),
s3::error::S3Error::Http(status, msg) => ServiceError::new(status, msg),
_ => ServiceError::new(500, format!("Unknown s3 error: {}", error))
s3::error::S3Error::Credentials(err) => {
ServiceError::new(500, format!("Unknown s3 credentials error: {}", err))
}
s3::error::S3Error::FromUtf8(err) => {
ServiceError::new(500, format!("Unknown s3 from utf8 error: {}", err))
}
s3::error::S3Error::FmtError(err) => {
ServiceError::new(500, format!("Unknown s3 fmt error: {}", err))
}
s3::error::S3Error::HeaderToStr(err) => {
ServiceError::new(500, format!("Unknown s3 header to str error: {}", err))
}
s3::error::S3Error::HmacInvalidLength(err) => ServiceError::new(
500,
format!("Unknown s3 hmac invalid length error: {}", err),
),
s3::error::S3Error::Http(error) => ServiceError::new(error.status_code().as_u16(), error.to_string()),
_ => ServiceError::new(500, format!("Unknown s3 error: {}", error)),
}
}
}

9
service/src/main.rs
View File

@@ -14,15 +14,15 @@ mod auth;
mod db;
mod error_handler;
mod metars;
mod users;
mod scheduler;
mod users;
#[actix_web::main]
async fn main() -> std::io::Result<()> {
dotenv().ok();
env_logger::init_from_env(env_logger::Env::default().filter_or("RUST_LOG", "warn,service=info"));
db::init().await;
// scheduler::update_airports();
scheduler::update_airports();
let host = env::var("SERVICE_HOST").unwrap_or("localhost".to_string());
let port = env::var("SERVICE_PORT").unwrap_or("5000".to_string());
@@ -42,11 +42,12 @@ async fn main() -> std::io::Result<()> {
.configure(auth::init_routes)
.configure(users::init_routes)
})
.bind(format!("{}:{}", host, port)) {
.bind(format!("{}:{}", host, port))
{
Ok(b) => {
info!("Binding server to {}:{}", host, port);
b
},
}
Err(err) => {
error!("Could not bind server: {}", err);
return Err(err);

266
service/src/metars/model.rs
View File

@@ -45,7 +45,7 @@ pub struct SkyCondition {
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_base_ft_agl: Option<i32>,
#[serde(skip_serializing_if = "Option::is_none")]
pub significant_convective_clouds: Option<String>
pub significant_convective_clouds: Option<String>,
}
impl Default for SkyCondition {
@@ -66,7 +66,7 @@ pub struct RunwayVisualRange {
#[serde(skip_serializing_if = "Option::is_none")]
pub variable_visibility_high_ft: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub variable_visibility_low_ft: Option<String>
pub variable_visibility_low_ft: Option<String>,
}
impl Default for RunwayVisualRange {
@@ -75,7 +75,7 @@ impl Default for RunwayVisualRange {
runway: "".to_string(),
visibility_ft: None,
variable_visibility_high_ft: None,
variable_visibility_low_ft: None
variable_visibility_low_ft: None,
}
}
}
@@ -86,7 +86,7 @@ pub enum FlightCategory {
MVFR,
LIFR,
IFR,
UNKN
UNKN,
}
#[derive(Serialize, Deserialize, Debug)]
@@ -132,7 +132,11 @@ impl Default for Metar {
Metar {
raw_text: "".to_string(),
station_id: "".to_string(),
observation_time: chrono::NaiveDateTime::parse_from_str("1970-01-01T00:00:00", "%Y-%m-%dT%H:%M:%S").unwrap(),
observation_time: chrono::NaiveDateTime::parse_from_str(
"1970-01-01T00:00:00",
"%Y-%m-%dT%H:%M:%S",
)
.unwrap(),
temp_c: None,
dewpoint_c: None,
wind_dir_degrees: None,
@@ -164,7 +168,10 @@ impl Metar {
metar.raw_text = metar_string.to_owned();
let mut metar_parts: Vec<&str> = metar_string.split_whitespace().collect();
if metar_parts.len() < 4 {
warn!("Unable to parse METAR data in an unexpected format: {}", metar_string);
warn!(
"Unable to parse METAR data in an unexpected format: {}",
metar_string
);
continue;
}
@@ -176,7 +183,10 @@ impl Metar {
let observation_time = metar_parts[0];
metar_parts.remove(0);
if observation_time.len() != 7 {
warn!("Unable to parse observation time in {}: {}", observation_time, metar_string);
warn!(
"Unable to parse observation time in {}: {}",
observation_time, metar_string
);
continue;
}
let observation_time_day = &observation_time[0..2];
@@ -184,7 +194,8 @@ impl Metar {
let observation_time_minute = &observation_time[4..6];
let current_time = chrono::Utc::now().naive_utc();
// Check if the observation time is from the previous month
let observation_time_month = if current_time.day() > observation_time_day.parse::<u32>().unwrap() {
let observation_time_month =
if current_time.day() > observation_time_day.parse::<u32>().unwrap() {
current_time.month() - 1
} else {
current_time.month()
@@ -196,13 +207,22 @@ impl Metar {
current_time.year()
};
// Handle Daylight Savings Time
let observation_time_hour = if observation_time_month == 3 && observation_time_day.parse::<u32>().unwrap() < 14 {
let observation_time_hour =
if observation_time_month == 3 && observation_time_day.parse::<u32>().unwrap() < 14 {
observation_time_hour.parse::<u32>().unwrap() - 1
} else {
observation_time_hour.parse::<u32>().unwrap()
};
let observation_time = format!("{}-{}-{}T{}:{}:00Z", observation_time_year, observation_time_month, observation_time_day, observation_time_hour, observation_time_minute);
metar.observation_time = chrono::NaiveDateTime::parse_from_str(&observation_time, "%Y-%m-%dT%H:%M:%SZ").unwrap();
let observation_time = format!(
"{}-{}-{}T{}:{}:00Z",
observation_time_year,
observation_time_month,
observation_time_day,
observation_time_hour,
observation_time_minute
);
metar.observation_time =
chrono::NaiveDateTime::parse_from_str(&observation_time, "%Y-%m-%dT%H:%M:%SZ").unwrap();
loop {
if metar_parts.is_empty() {
@@ -224,14 +244,22 @@ impl Metar {
// Wind Direction and Speed
let wind_re = regex::Regex::new(r"^(?:[0-9]{3}|VRB)[0-9]{2}(?:KT|MPS)$").unwrap();
let wind_gust_re = regex::Regex::new(r"^(?:[0-9]{3}|VRB)[0-9]{2}G[0-9]{2}(?:KT|MPS)$").unwrap();
let wind_gust_re =
regex::Regex::new(r"^(?:[0-9]{3}|VRB)[0-9]{2}G[0-9]{2}(?:KT|MPS)$").unwrap();
// Handle input error where there is a space between the numbers and units
let mut value: Option<String> = None;
if metar_parts.len() >= 2 && metar_parts[0].len() == 5 && (metar_parts[1] == "KT" || metar_parts[1] == "MPS") {
if metar_parts.len() >= 2
&& metar_parts[0].len() == 5
&& (metar_parts[1] == "KT" || metar_parts[1] == "MPS")
{
value = Some(format!("{}{}", metar_parts[0], metar_parts[1]));
metar_parts.remove(0);
metar_parts.remove(0);
} else if metar_parts.len() >= 2 && metar_parts[0].len() == 7 && metar_parts[0].contains("G") && (metar_parts[1] == "KT" || metar_parts[1] == "MPS") {
} else if metar_parts.len() >= 2
&& metar_parts[0].len() == 7
&& metar_parts[0].contains("G")
&& (metar_parts[1] == "KT" || metar_parts[1] == "MPS")
{
value = Some(format!("{}{}", metar_parts[0], metar_parts[1]));
metar_parts.remove(0);
metar_parts.remove(0);
@@ -267,7 +295,7 @@ impl Metar {
metar.wind_speed_kt = Some(wind_speed_kt.parse::<f64>().unwrap());
metar.wind_gust_kt = Some(wind_gust_kt.parse::<f64>().unwrap());
}
},
}
None => {}
}
@@ -289,29 +317,67 @@ impl Metar {
let visibility_left = visibility_parts[0];
let visibility_right = visibility_parts[1].parse::<f64>().unwrap();
if visibility_left.starts_with("M") {
format!("M{}", visibility_left[1..visibility_left.len()].parse::<f64>().unwrap() / visibility_right)
format!(
"M{}",
visibility_left[1..visibility_left.len()]
.parse::<f64>()
.unwrap()
/ visibility_right
)
} else if visibility_left.starts_with("P") {
format!("P{}", visibility_left[1..visibility_left.len()].parse::<f64>().unwrap() / visibility_right)
format!(
"P{}",
visibility_left[1..visibility_left.len()]
.parse::<f64>()
.unwrap()
/ visibility_right
)
} else {
format!("{}", visibility_left.parse::<f64>().unwrap() / visibility_right)
format!(
"{}",
visibility_left.parse::<f64>().unwrap() / visibility_right
)
}
} else {
visibility_str.to_string()
};
metar.visibility_statute_mi = Some(visibility);
} else if !metar_parts.is_empty() && metar_parts[0].parse::<f64>().is_ok() && metar_parts.len() > 1 && visibility_re.is_match(metar_parts[1]) {
} else if !metar_parts.is_empty()
&& metar_parts[0].parse::<f64>().is_ok()
&& metar_parts.len() > 1
&& visibility_re.is_match(metar_parts[1])
{
let visibility_whole = metar_parts[0].parse::<f64>().unwrap();
metar_parts.remove(0);
let visibility_parts: Vec<&str> = metar_parts[0].split("/").collect();
metar_parts.remove(0);
let visibility_left = visibility_parts[0];
let visibility_right = visibility_parts[1][0..visibility_parts[1].len() - 2].parse::<f64>().unwrap();
let visibility_right = visibility_parts[1][0..visibility_parts[1].len() - 2]
.parse::<f64>()
.unwrap();
let visibility = if visibility_left.starts_with("M") {
format!("M{}", visibility_whole + (visibility_left[1..visibility_left.len()].parse::<f64>().unwrap() / visibility_right))
format!(
"M{}",
visibility_whole
+ (visibility_left[1..visibility_left.len()]
.parse::<f64>()
.unwrap()
/ visibility_right)
)
} else if visibility_left.starts_with("P") {
format!("P{}", visibility_whole + (visibility_left[1..visibility_left.len()].parse::<f64>().unwrap() / visibility_right))
format!(
"P{}",
visibility_whole
+ (visibility_left[1..visibility_left.len()]
.parse::<f64>()
.unwrap()
/ visibility_right)
)
} else {
format!("{}", visibility_whole + (visibility_left.parse::<f64>().unwrap() / visibility_right))
format!(
"{}",
visibility_whole + (visibility_left.parse::<f64>().unwrap() / visibility_right)
)
};
metar.visibility_statute_mi = Some(visibility);
} else if !metar_parts.is_empty() && visibility_re_m.is_match(metar_parts[0]) {
@@ -328,8 +394,11 @@ impl Metar {
// Runway Visual Range
let rvr_re = regex::Regex::new(r"^R[0-9]{1,3}(?:L|R|C)?/[PM]?[0-9]{4}FT$").unwrap();
let variable_rvr_re = regex::Regex::new(r"^R[0-9]{1,3}(?:L|R|C)?/[PM]?[0-9]{4}V[PM]?[0-9]{4}FT$").unwrap();
while !metar_parts.is_empty() && (rvr_re.is_match(metar_parts[0]) || variable_rvr_re.is_match(metar_parts[0])) {
let variable_rvr_re =
regex::Regex::new(r"^R[0-9]{1,3}(?:L|R|C)?/[PM]?[0-9]{4}V[PM]?[0-9]{4}FT$").unwrap();
while !metar_parts.is_empty()
&& (rvr_re.is_match(metar_parts[0]) || variable_rvr_re.is_match(metar_parts[0]))
{
let rvr_string = metar_parts[0];
metar_parts.remove(0);
let mut rvr = RunwayVisualRange::default();
@@ -340,7 +409,10 @@ impl Metar {
} else {
let rvr_variable_parts: Vec<&str> = rvr_parts[1].split("V").collect();
if rvr_variable_parts.len() != 2 {
warn!("Unable to parse runway visual range in {}: {}", rvr_string, metar_string);
warn!(
"Unable to parse runway visual range in {}: {}",
rvr_string, metar_string
);
} else {
rvr.variable_visibility_low_ft = Some(rvr_variable_parts[0].to_string());
rvr.variable_visibility_high_ft = Some(rvr_variable_parts[1].to_string());
@@ -351,8 +423,13 @@ impl Metar {
// Weather Phenomena
let wx_intensity = "(?:[+-]|VC)?";
let wx_descriptor = "(?:MI|PR|BC|DR|BL|SH|TS|FZ)?";
let wx_precipitation = "(?:DZ|RA|SN|SG|IC|PL|GR|GS|UP|BR|FG|FU|VA|DU|SA|HZ|PY|PO|SQ|FC|SS|DS)?";
let wx_re = regex::Regex::new(&format!(r"^{}{}{}$", wx_intensity, wx_descriptor, wx_precipitation)).unwrap();
let wx_precipitation =
"(?:DZ|RA|SN|SG|IC|PL|GR|GS|UP|BR|FG|FU|VA|DU|SA|HZ|PY|PO|SQ|FC|SS|DS)?";
let wx_re = regex::Regex::new(&format!(
r"^{}{}{}$",
wx_intensity, wx_descriptor, wx_precipitation
))
.unwrap();
while !metar_parts.is_empty() && wx_re.is_match(metar_parts[0]) {
metar.weather_phenomena.push(metar_parts[0].to_string());
metar_parts.remove(0);
@@ -363,11 +440,13 @@ impl Metar {
metar.sky_condition.push(SkyCondition {
sky_cover: "CLR".to_string(),
cloud_base_ft_agl: None,
significant_convective_clouds: None
significant_convective_clouds: None,
});
metar_parts.remove(0);
}
let sky_condition_re = regex::Regex::new(r"^(?:CLR|SKC|NSC|NCD|(?:FEW|SCT|BKN|OVC|VV)([0-9/]{3})?(?:CB|TCU)?)$").unwrap();
let sky_condition_re =
regex::Regex::new(r"^(?:CLR|SKC|NSC|NCD|(?:FEW|SCT|BKN|OVC|VV)([0-9/]{3})?(?:CB|TCU)?)$")
.unwrap();
while !metar_parts.is_empty() && sky_condition_re.is_match(metar_parts[0]) {
let sky_condition_string = metar_parts[0];
metar_parts.remove(0);
@@ -388,7 +467,10 @@ impl Metar {
sky_condition.cloud_base_ft_agl = match cloud_base_ft_agl.parse::<i32>() {
Ok(c) => Some(c * 100),
Err(err) => {
warn!("Unable to parse cloud base in {}: {}", sky_condition_string, err);
warn!(
"Unable to parse cloud base in {}: {}",
sky_condition_string, err
);
None
}
};
@@ -478,7 +560,9 @@ impl Metar {
let remark = metar_parts[0];
metar_parts.remove(0);
if remark == "AO1" {
metar.quality_control_flags.auto_station_without_precipication = Some(true);
metar
.quality_control_flags
.auto_station_without_precipication = Some(true);
} else if remark == "AO2" {
metar.quality_control_flags.auto_station_with_precipication = Some(true);
} else if remark == "$" {
@@ -516,7 +600,10 @@ impl Metar {
// Skip unexpected fields
if !metar_parts.is_empty() {
warn!("Skipping unexpected field: '{}' ({})", metar_parts[0], metar_string);
warn!(
"Skipping unexpected field: '{}' ({})",
metar_parts[0], metar_string
);
metar_parts.remove(0);
}
}
@@ -533,7 +620,7 @@ impl Metar {
v.parse::<f64>().unwrap()
}
}
None => 5.0 // Assume VFR if no visibility is present
None => 5.0, // Assume VFR if no visibility is present
};
// Ceiling is the lowest cloud base that is BKN or OVC
let ceiling = match metar.sky_condition.first() {
@@ -543,13 +630,13 @@ impl Metar {
} else if s.sky_cover == "BKN" || s.sky_cover == "OVC" {
match s.cloud_base_ft_agl {
Some(c) => c as f64,
None => 0.0
None => 0.0,
}
} else {
3000.0 // Assume VFR if no BKN or OVC sky condition is present
}
},
None => 3000.0 // Assume VFR if no sky condition is present
}
None => 3000.0, // Assume VFR if no sky condition is present
};
if visibility >= 5.0 && ceiling >= 3000.0 {
metar.flight_category = FlightCategory::VFR;
@@ -564,19 +651,22 @@ impl Metar {
metars.push(metar);
}
return Ok(metars)
return Ok(metars);
}
fn get_missing_metar_icaos(db_metars: &Vec<Self>, station_icaos: &Vec<&str>) -> Vec<String> {
let mut missing_metar_icaos: Vec<String> = vec![];
let current_time = chrono::Local::now().naive_local().timestamp();
let db_metars_set: HashSet<&str> = db_metars.iter().map(|icao| icao.station_id.as_str()).collect();
let current_time = chrono::Local::now().naive_local().and_utc().timestamp();
let db_metars_set: HashSet<&str> = db_metars
.iter()
.map(|icao| icao.station_id.as_str())
.collect();
let station_icaos_set: HashSet<&str> = station_icaos.to_owned().into_iter().collect();
for difference in db_metars_set.symmetric_difference(&station_icaos_set) {
missing_metar_icaos.push(difference.to_string());
}
for metar in db_metars {
if current_time > (metar.observation_time.timestamp() + 3600) {
if current_time > (metar.observation_time.and_utc().timestamp() + 3600) {
trace!("{} METAR data is outdated", metar.station_id);
missing_metar_icaos.push(metar.station_id.to_string());
}
@@ -587,7 +677,10 @@ impl Metar {
async fn get_remote_metars(icaos: Vec<String>) -> Result<Vec<Metar>, ServiceError> {
let gov_api_url = std::env::var("GOV_API_URL").expect("GOV_API_URL must be set");
// Query the remote API for the missing METAR data 10 at a time
let icao_chunks = icaos.chunks(10).map(|chunk| chunk.join(",")).collect::<Vec<String>>();
let icao_chunks = icaos
.chunks(10)
.map(|chunk| chunk.join(","))
.collect::<Vec<String>>();
let mut metars: Vec<Metar> = vec![];
for icao_chunk in icao_chunks {
let url = format!("{}/metar.php?ids={}", gov_api_url, icao_chunk);
@@ -595,20 +688,37 @@ impl Metar {
Ok(r) => {
// Check if the status code is 200
if r.status() != 200 {
return Err(ServiceError::new(500, format!("Unable to get METAR request: {}", r.status())));
return Err(ServiceError::new(
500,
format!("Unable to get METAR request: {}", r.status()),
));
}
match r.text().await {
Ok(r) => {
let metar_chunk = r.trim().split("\n").filter(|m| !m.trim().is_empty()).collect();
let metar_chunk = r
.trim()
.split("\n")
.filter(|m| !m.trim().is_empty())
.collect();
match Metar::parse(metar_chunk) {
Ok(m) => m,
Err(err) => return Err(err)
Err(err) => return Err(err),
}
},
Err(err) => return Err(ServiceError::new(500, format!("Unable to parse METAR request: {}", err)))
}
},
Err(err) => return Err(ServiceError::new(500, format!("Unable to get METAR request: {}", err)))
Err(err) => {
return Err(ServiceError::new(
500,
format!("Unable to parse METAR request: {}", err),
))
}
}
}
Err(err) => {
return Err(ServiceError::new(
500,
format!("Unable to get METAR request: {}", err),
))
}
};
metars.append(&mut m);
}
@@ -633,7 +743,7 @@ impl Metar {
icao: metar.station_id.to_string(),
observation_time: metar.observation_time,
raw_text: metar.raw_text.to_string(),
data: serde_json::to_value(metar).unwrap()
data: serde_json::to_value(metar).unwrap(),
});
}
return insert_metars;
@@ -648,7 +758,7 @@ impl Metar {
let mut db_metars = match QueryMetar::get_all(&icaos) {
Ok(m) => Self::from_query(m),
Err(err) => return Err(err)
Err(err) => return Err(err),
};
let missing_icaos = Self::get_missing_metar_icaos(&db_metars, &icaos);
@@ -656,13 +766,17 @@ impl Metar {
return Ok(db_metars);
}
trace!("Retrieving missing METAR data for {:?}", missing_icaos);
let missing_icaos_string: Vec<String> = missing_icaos.iter().map(|icao| format!("{}", icao.to_string())).collect();
let missing_icaos_string: Vec<String> = missing_icaos
.iter()
.map(|icao| format!("{}", icao.to_string()))
.collect();
let mut airports: Vec<QueryAirport> = vec![];
missing_icaos_string.clone().iter().for_each(|icao| {
match QueryAirport::get(icao) {
missing_icaos_string
.clone()
.iter()
.for_each(|icao| match QueryAirport::get(icao) {
Ok(a) => airports.push(a),
Err(_) => {}
}
});
let missing_result = Self::get_remote_metars(missing_icaos_string).await;
let mut missing_metars = match missing_result {
@@ -676,11 +790,14 @@ impl Metar {
let insert_metars = Self::to_insert(&missing_metars);
match InsertMetar::insert(&insert_metars) {
Ok(rows) => trace!("Inserted {} metar rows", rows),
Err(err) => warn!("Unable to insert metar data; {}", err)
Err(err) => warn!("Unable to insert metar data; {}", err),
};
// Update airports with the appropriate has_metar flag
airports.iter().for_each(|airport| {
if missing_metars.iter().any(|metar| metar.station_id == airport.icao) {
if missing_metars
.iter()
.any(|metar| metar.station_id == airport.icao)
{
let updated = QueryAirport {
icao: airport.icao.to_string(),
category: airport.category.to_string(),
@@ -691,11 +808,11 @@ impl Metar {
municipality: airport.municipality.to_string(),
has_metar: true,
point: airport.point,
data: airport.data.to_owned()
data: airport.data.to_owned(),
};
match QueryAirport::update(updated) {
Ok(_) => {},
Err(err) => warn!("Unable to update airport with has_metar flag; {}", err)
Ok(_) => {}
Err(err) => warn!("Unable to update airport with has_metar flag; {}", err),
}
}
});
@@ -713,15 +830,21 @@ struct InsertMetar {
icao: String,
observation_time: chrono::NaiveDateTime,
raw_text: String,
data: serde_json::Value
data: serde_json::Value,
}
impl InsertMetar {
fn insert(metars: &Vec<Self>) -> Result<usize, ServiceError> {
let mut conn = db::connection()?;
match diesel::insert_into(metars::table).values(metars).execute(&mut conn) {
match diesel::insert_into(metars::table)
.values(metars)
.execute(&mut conn)
{
Ok(rows) => Ok(rows),
Err(err) => Err(ServiceError { status: 500, message: format!("{}", err) })
Err(err) => Err(ServiceError {
status: 500,
message: format!("{}", err),
}),
}
}
}
@@ -733,14 +856,25 @@ struct QueryMetar {
icao: String,
observation_time: chrono::NaiveDateTime,
raw_text: String,
data: serde_json::Value
data: serde_json::Value,
}
impl QueryMetar {
fn get_all(icaos: &Vec<&str>) -> Result<Vec<QueryMetar>, ServiceError> {
// Sanitize search to only allow [a-zA-Z0-9]
let icaos = icaos.iter().map(|icao| icao.chars().filter(|c| c.is_alphanumeric()).collect::<String>()).collect::<Vec<String>>();
let station_query: Vec<String> = icaos.iter().map(|icao| format!("'{}'", icao.to_string())).collect();
let icaos = icaos
.iter()
.map(|icao| {
icao
.chars()
.filter(|c| c.is_alphanumeric())
.collect::<String>()
})
.collect::<Vec<String>>();
let station_query: Vec<String> = icaos
.iter()
.map(|icao| format!("'{}'", icao.to_string()))
.collect();
let mut conn = db::connection()?;
let db_metars: Vec<Self> = match sql_query(
format!("SELECT DISTINCT ON (icao) * FROM metars WHERE icao IN ({}) ORDER BY icao, observation_time DESC", station_query.join(","))

19
service/src/metars/routes.rs
View File

@@ -7,12 +7,12 @@ use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize)]
pub struct MetarsResponse {
pub data: Vec<Metar>,
pub meta: Metadata
pub meta: Metadata,
}
#[derive(Debug, Serialize, Deserialize)]
struct GetAllParameters {
icaos: Option<String>
icaos: Option<String>,
}
#[get("metars")]
@@ -21,14 +21,16 @@ async fn get_all(req: HttpRequest) -> HttpResponse {
let icao_option = params.icaos.clone();
let icao_string = match icao_option {
Some(i) => i,
None => return HttpResponse::UnprocessableEntity().body("Missing icaos parameter")
None => return HttpResponse::UnprocessableEntity().body("Missing icaos parameter"),
};
let airports = match web::block(|| Ok::<_, ServiceError>(async {Metar::get_all(icao_string).await}))
let airports =
match web::block(|| Ok::<_, ServiceError>(async { Metar::get_all(icao_string).await }))
.await
.unwrap()
.unwrap()
.await {
.await
{
Ok(a) => a,
Err(err) => {
error!("{}", err);
@@ -37,7 +39,12 @@ async fn get_all(req: HttpRequest) -> HttpResponse {
};
HttpResponse::Ok().json(MetarsResponse {
data: airports,
meta: Metadata { page: 0, limit: 0, pages: 0, total: 0 }
meta: Metadata {
page: 0,
limit: 0,
pages: 0,
total: 0,
},
})
}

37
service/src/scheduler.rs
View File

@@ -1,5 +1,4 @@
use tokio::time::{sleep, Duration};
use log::{warn, debug, trace};
use crate::airports::{QueryAirport, QueryFilters};
use crate::metars::Metar;
@@ -9,38 +8,36 @@ pub fn update_airports() {
let mut airports: Vec<QueryAirport> = vec![];
let limit = 100;
loop {
debug!("METAR update start");
log::debug!("METAR update start");
let total = match QueryAirport::get_count(&QueryFilters::default()) {
Ok(t) => t,
Err(err) => {
warn!("{}", err);
break
log::warn!("{}", err);
break;
}
};
if total != airports.len() as i64 {
debug!("{} cached airports, expected {}", airports.len(), total);
log::debug!("{} cached airports, expected {}", airports.len(), total);
airports = vec![];
let pages = ((total as f32) / (if limit <= 0 { 1 } else { limit} as f32)).ceil() as i32;
let pages = ((total as f32) / (if limit <= 0 { 1 } else { limit } as f32)).ceil() as i32;
for page in 1..(pages + 1) {
match QueryAirport::get_all(&QueryFilters::default(), limit, page) {
Ok(mut a) => {
airports.append(&mut a)
},
Ok(mut a) => airports.append(&mut a),
Err(err) => {
warn!("{}", err);
break
log::warn!("{}", err);
break;
}
}
}
}
debug!("Updating {} airport METARS", airports.len());
log::debug!("Updating {} airport METARS", airports.len());
let airport_icaos: Vec<String> = airports.iter().map(|a| a.icao.to_string()).collect();
let mut peekable = airport_icaos.into_iter().peekable();
let mut observation_time = chrono::Utc::now().timestamp();
if peekable.peek().is_none() {
debug!("No airports to update, sleeping for 1 hour");
log::debug!("No airports to update, sleeping for 1 hour");
sleep(Duration::from_secs(3600)).await;
continue;
}
@@ -48,29 +45,29 @@ pub fn update_airports() {
while peekable.peek().is_some() {
let chunk: Vec<String> = peekable.by_ref().take(limit as usize).collect();
let icao_string = chunk.join(",");
trace!("Updating METARS for: {}", icao_string);
log::trace!("Updating METARS for: {}", icao_string);
match Metar::get_all(icao_string).await {
Ok(metars) => {
// Find the oldest observation time
for metar in metars {
if metar.observation_time.timestamp() < observation_time {
observation_time = metar.observation_time.timestamp();
if metar.observation_time.and_utc().timestamp() < observation_time {
observation_time = metar.observation_time.and_utc().timestamp();
}
}
}
},
Err(err) => {
warn!("{}", err);
log::warn!("{}", err);
}
}
// Sleep for 100ms between chunks to avoid rate limiting
sleep(Duration::from_millis(100)).await;
}
debug!("METAR update complete");
log::debug!("METAR update complete");
// Sleep until the earliest observation time is 1 hour old
// Bounded by 1 and 3600 seconds
let now = chrono::Utc::now().timestamp();
let sleep_time = std::cmp::min(std::cmp::max(1, now - (observation_time + 3600)), 3600);
debug!("Next update in {} seconds", sleep_time);
log::debug!("Next update in {} seconds", sleep_time);
sleep(Duration::from_secs(sleep_time as u64)).await;
}
});

89
service/src/users/routes.rs
View File

@@ -2,15 +2,17 @@ use actix_multipart::Multipart;
use actix_web::{get, post, delete, web, HttpResponse, ResponseError};
use futures_util::StreamExt;
use crate::{auth::{JwtAuth, QueryUser, InsertUser}, error_handler::ServiceError, db::{upload_file, get_file, delete_file}};
use crate::{
auth::{JwtAuth, QueryUser, InsertUser},
error_handler::ServiceError,
db::{upload_file, get_file, delete_file},
};
#[get("/favorites")]
async fn get_favorites(auth: JwtAuth) -> HttpResponse {
match QueryUser::get_by_email(&auth.user.email) {
Ok(user) => {
return HttpResponse::Ok().json(user.favorites)
},
Err(err) => return ResponseError::error_response(&err)
Ok(user) => return HttpResponse::Ok().json(user.favorites),
Err(err) => return ResponseError::error_response(&err),
}
}
@@ -20,18 +22,18 @@ async fn add_favorite(icao: web::Path<String>, auth: JwtAuth) -> HttpResponse {
Ok(user) => {
if user.favorites.contains(&icao) {
// Check if the airport ICAO is already in the user's favorites
return HttpResponse::Conflict().finish()
return HttpResponse::Conflict().finish();
} else {
// Add the airport ICAO to the user's favorites
let mut favorites = user.favorites;
favorites.push(icao.into_inner());
match InsertUser::update_favorites(&user.email, favorites) {
Ok(_) => return HttpResponse::Ok().finish(),
Err(err) => return ResponseError::error_response(&err)
Err(err) => return ResponseError::error_response(&err),
}
}
},
Err(err) => return ResponseError::error_response(&err)
}
Err(err) => return ResponseError::error_response(&err),
}
}
@@ -46,14 +48,14 @@ async fn delete_favorite(icao: web::Path<String>, auth: JwtAuth) -> HttpResponse
favorites.retain(|x| x != &icao);
match InsertUser::update_favorites(&user.email, favorites) {
Ok(_) => return HttpResponse::Ok().finish(),
Err(err) => return ResponseError::error_response(&err)
Err(err) => return ResponseError::error_response(&err),
}
} else {
// Remove the airport ICAO from the user's favorites
return HttpResponse::Conflict().finish()
return HttpResponse::Conflict().finish();
}
},
Err(err) => return ResponseError::error_response(&err)
}
Err(err) => return ResponseError::error_response(&err),
}
}
@@ -63,40 +65,52 @@ async fn set_picture(mut payload: Multipart, auth: JwtAuth) -> HttpResponse {
let mut bytes = web::BytesMut::new();
let mut field = match item {
Ok(field) => field,
Err(err) => return ResponseError::error_response(&err)
Err(err) => return ResponseError::error_response(&err),
};
let content_type = field.content_disposition();
let filename = match content_type.get_filename() {
Some(name) => {
match name.split(".").last() {
Some(ext) => {
match ext {
"apng" | "avif" | "gif" | "jpg" | "jpeg" | "jfif" | "pjpeg" | "pjp" | "png" | "svg" | "webp" => name,
_ => return ResponseError::error_response(&ServiceError::new(400, "File extension is not supported".to_string()))
let filename = match content_type.unwrap().get_filename() {
Some(name) => match name.split(".").last() {
Some(ext) => match ext {
"apng" | "avif" | "gif" | "jpg" | "jpeg" | "jfif" | "pjpeg" | "pjp" | "png" | "svg"
| "webp" => name,
_ => {
return ResponseError::error_response(&ServiceError::new(
400,
"File extension is not supported".to_string(),
))
}
},
None => return ResponseError::error_response(&ServiceError::new(400, "Unknown file extension".to_string()))
None => {
return ResponseError::error_response(&ServiceError::new(
400,
"Unknown file extension".to_string(),
))
}
},
None => return ResponseError::error_response(&ServiceError::new(400, "File name is not provided".to_string()))
None => {
return ResponseError::error_response(&ServiceError::new(
400,
"File name is not provided".to_string(),
))
}
};
let path = format!("users/{}/{}", auth.user.email, filename);
while let Some(chunk) = field.next().await {
let data = match chunk {
Ok(data) => data,
Err(err) => return ResponseError::error_response(&err)
Err(err) => return ResponseError::error_response(&err),
};
bytes.extend_from_slice(&data);
}
match upload_file(&path, &bytes).await {
Ok(_) => {
match InsertUser::update_profile_picture(&auth.user.email, Some(&path)) {
Ok(_) => {},
Err(err) => return ResponseError::error_response(&err)
Ok(_) => {}
Err(err) => return ResponseError::error_response(&err),
};
},
Err(err) => return ResponseError::error_response(&err)
}
Err(err) => return ResponseError::error_response(&err),
};
}
HttpResponse::Ok().finish()
@@ -106,12 +120,12 @@ async fn set_picture(mut payload: Multipart, auth: JwtAuth) -> HttpResponse {
async fn get_picture(auth: JwtAuth) -> HttpResponse {
let user = match QueryUser::get_by_email(&auth.user.email) {
Ok(user) => user,
Err(err) => return ResponseError::error_response(&err)
Err(err) => return ResponseError::error_response(&err),
};
if let Some(path) = user.profile_picture {
match get_file(&path).await {
Ok(bytes) => HttpResponse::Ok().body(bytes),
Err(err) => ResponseError::error_response(&err)
Err(err) => ResponseError::error_response(&err),
}
} else {
HttpResponse::NotFound().finish()
@@ -122,17 +136,15 @@ async fn get_picture(auth: JwtAuth) -> HttpResponse {
async fn delete_picture(auth: JwtAuth) -> HttpResponse {
let user = match QueryUser::get_by_email(&auth.user.email) {
Ok(user) => user,
Err(err) => return ResponseError::error_response(&err)
Err(err) => return ResponseError::error_response(&err),
};
if let Some(path) = user.profile_picture {
match delete_file(&path).await {
Ok(_) => {
match InsertUser::update_profile_picture(&auth.user.email, None) {
Ok(_) => match InsertUser::update_profile_picture(&auth.user.email, None) {
Ok(_) => HttpResponse::Ok().finish(),
Err(err) => ResponseError::error_response(&err)
}
Err(err) => ResponseError::error_response(&err),
},
Err(err) => ResponseError::error_response(&err)
Err(err) => ResponseError::error_response(&err),
}
} else {
HttpResponse::NotFound().finish()
@@ -140,12 +152,13 @@ async fn delete_picture(auth: JwtAuth) -> HttpResponse {
}
pub fn init_routes(config: &mut web::ServiceConfig) {
config.service(web::scope("users")
config.service(
web::scope("users")
.service(get_favorites)
.service(add_favorite)
.service(delete_favorite)
.service(set_picture)
.service(get_picture)
.service(delete_picture)
.service(delete_picture),
);
}

0
ui/.env.TEMPLATE → ui/.env
View File

2
ui/Makefile
View File

@@ -4,6 +4,8 @@ SHELL := /bin/bash
GIT_HASH ?= $(shell git log --format="%h" -n 1)
include .env
-include .env.local
export
.PHONY: help build start stop lint

3
ui/src/api/airport.ts
View File

@@ -17,6 +17,7 @@ interface GetAirportsProps {
name?: string;
order_field?: AirportOrderField;
order_by?: 'asc' | 'desc';
has_metar?: boolean;
page?: number;
limit?: number;
}
@@ -28,6 +29,7 @@ export async function getAirports({
name,
order_field,
order_by,
has_metar,
limit = 10,
page = 1
}: GetAirportsProps): Promise<GetAirportsResponse> {
@@ -40,6 +42,7 @@ export async function getAirports({
name: name ?? undefined,
order_field: order_field ?? undefined,
order_by: order_by ?? undefined,
has_metar: has_metar ?? undefined,
limit,
page
});

114
ui/src/components/Header/UserMenu.tsx Normal file
View File

@@ -0,0 +1,114 @@
import { User } from "@/api/auth.types";
import { setPicture } from "@/api/users";
import {
Menu,
UnstyledButton,
Group,
Avatar,
Card,
FileButton,
Grid,
Button,
Text
} from "@mantine/core";
import Link from "next/link";
import { SetterOrUpdater } from "recoil";
import './styles.css';
interface UserMenuProps {
user: User;
profilePicture: File | undefined;
setProfilePicture: SetterOrUpdater<File | undefined>;
toggle: (type: string) => void;
logout: () => Promise<void>;
}
export default function UserMenu({ user, profilePicture, setProfilePicture, logout, toggle }: UserMenuProps) {
return (
<Menu shadow='md' width={200} openDelay={100} closeDelay={400}>
<Menu.Target>
<UnstyledButton>
<Group>
<Avatar src={profilePicture ? URL.createObjectURL(profilePicture) : undefined} />
<div style={{ flex: 1 }}>
<Text size='sm' fw={500}>
{user.first_name} {user.last_name}
</Text>
<Text c='dimmed' size='xs' style={{ textTransform: 'uppercase' }}>
{user.role}
</Text>
</div>
</Group>
</UnstyledButton>
</Menu.Target>
<Menu.Dropdown p={0}>
<Card>
<Card.Section h={140} style={{ backgroundColor: '#4481e3' }} />
<FileButton
onChange={(payload) => {
if (payload) {
setPicture(payload).then((response) => {
if (response) {
setProfilePicture(payload);
}
});
}
}}
accept='image/png,image/jpeg,image/svg+xml,image/webp,image/gif,image/apng,image/avif'
multiple={false}
>
{(props) => (
<Avatar
{...props}
component='button'
size={80}
radius={80}
mx={'auto'}
mt={-30}
style={{ cursor: 'pointer' }}
bg={profilePicture ? 'transparent' : 'white'}
src={profilePicture ? URL.createObjectURL(profilePicture) : undefined}
/>
)}
</FileButton>
<Text ta='center' fz='lg' fw={500} mt='sm'>
{user.first_name} {user.last_name}
</Text>
<Text ta='center' fz='sm' c='dimmed' style={{ textTransform: 'uppercase' }}>
{user.role}
</Text>
<Grid mt='xl'>
<Grid.Col span={6}>
<Link href='/profile'>
<Button fullWidth radius='md' size='xs' variant='default'>
Profile
</Button>
</Link>
</Grid.Col>
<Grid.Col span={6}>
<Button
fullWidth
radius='md'
size='xs'
variant='default'
onClick={logout}
>
Logout
</Button>
</Grid.Col>
{user.role == 'admin' && (
<Grid.Col span={12}>
<Link href='/admin'>
<Button fullWidth radius='md' size='xs' variant='default'>
Administration
</Button>
</Link>
</Grid.Col>
)}
</Grid>
</Card>
</Menu.Dropdown>
</Menu>
)
}

138
ui/src/components/Header/index.tsx
View File

@@ -3,10 +3,8 @@
import Link from 'next/link';
import { useState } from 'react';
import { getAirport, getAirports } from '@/api/airport';
import { Autocomplete, Avatar, Button, Card, FileButton, Grid, Group, Menu, Text, UnstyledButton } from '@mantine/core';
import './header.css';
import { Autocomplete, Button, Group, UnstyledButton } from '@mantine/core';
import { SetterOrUpdater, useRecoilState } from 'recoil';
import { setPicture } from '@/api/users';
import { useToggle } from '@mantine/hooks';
import { HeaderModal } from './HeaderModal';
import { coordinatesState } from '@/state/map';
@@ -14,6 +12,8 @@ import { User } from '@/api/auth.types';
import { usePathname, useRouter } from 'next/navigation';
import { FaMoon } from "react-icons/fa6";
import { FaSun } from "react-icons/fa6";
import UserMenu from './UserMenu';
import './styles.css';
interface HeaderProps {
user: User | undefined;
@@ -77,13 +77,28 @@ export default function Header({ user, profilePicture, setProfilePicture, login,
/>
</div>
</div>
<UserSection
<div className='right'>
<UnstyledButton style={{ paddingRight: '1em', margin: 'auto' }}>
<FaMoon />
{/* <FaSun /> */}
</UnstyledButton>
{user ? (
<UserMenu
user={user}
profilePicture={profilePicture}
setProfilePicture={setProfilePicture}
toggle={toggle}
logout={logout}
/>
) : (
<Group className='user'>
<Button onClick={() => toggle('login')}>Login</Button>
<Button variant='outline' onClick={() => toggle('register')}>
Sign up
</Button>
</Group>
)}
</div>
</nav>
<HeaderModal
type={modalType}
@@ -94,118 +109,3 @@ export default function Header({ user, profilePicture, setProfilePicture, login,
</>
);
}
interface UserSectionProps {
user: User | undefined;
profilePicture: File | undefined;
setProfilePicture: SetterOrUpdater<File | undefined>;
toggle: (type: string) => void;
logout: () => Promise<void>;
}
function UserSection({ user, profilePicture, setProfilePicture, logout, toggle }: UserSectionProps) {
return (
<div className='user-section'>
<>
{/* <UnstyledButton> */}
{/* <FaMoon /> */}
{/* <FaSun /> */}
{/* </UnstyledButton> */}
{user ? (
<Menu shadow='md' width={200} openDelay={100} closeDelay={400}>
<Menu.Target>
<UnstyledButton className='user user-button'>
<Group>
<Avatar src={profilePicture ? URL.createObjectURL(profilePicture) : undefined} />
<div style={{ flex: 1 }}>
<Text size='sm' fw={500}>
{user.first_name} {user.last_name}
</Text>
<Text c='dimmed' size='xs' style={{ textTransform: 'uppercase' }}>
{user.role}
</Text>
</div>
</Group>
</UnstyledButton>
</Menu.Target>
<Menu.Dropdown p={0}>
<Card>
<Card.Section h={140} style={{ backgroundColor: '#4481e3' }} />
<FileButton
onChange={(payload) => {
if (payload) {
setPicture(payload).then((response) => {
if (response) {
setProfilePicture(payload);
}
});
}
}}
accept='image/png,image/jpeg,image/svg+xml,image/webp,image/gif,image/apng,image/avif'
multiple={false}
>
{(props) => (
<Avatar
{...props}
component='button'
size={80}
radius={80}
mx={'auto'}
mt={-30}
style={{ cursor: 'pointer' }}
bg={profilePicture ? 'transparent' : 'white'}
src={profilePicture ? URL.createObjectURL(profilePicture) : undefined}
/>
)}
</FileButton>
<Text ta='center' fz='lg' fw={500} mt='sm'>
{user.first_name} {user.last_name}
</Text>
<Text ta='center' fz='sm' c='dimmed' style={{ textTransform: 'uppercase' }}>
{user.role}
</Text>
<Grid mt='xl'>
<Grid.Col span={6}>
<Link href='/profile'>
<Button fullWidth radius='md' size='xs' variant='default'>
Profile
</Button>
</Link>
</Grid.Col>
<Grid.Col span={6}>
<Button
fullWidth
radius='md'
size='xs'
variant='default'
onClick={logout}
>
Logout
</Button>
</Grid.Col>
{user.role == 'admin' && (
<Grid.Col span={12}>
<Link href='/admin'>
<Button fullWidth radius='md' size='xs' variant='default'>
Administration
</Button>
</Link>
</Grid.Col>
)}
</Grid>
</Card>
</Menu.Dropdown>
</Menu>
) : (
<Group className='user'>
<Button onClick={() => toggle('login')}>Login</Button>
<Button variant='outline' onClick={() => toggle('register')}>
Sign up
</Button>
</Group>
)}
</>
</div>
)
}

14
ui/src/components/Header/header.css → ui/src/components/Header/styles.css
View File

@@ -6,27 +6,21 @@
color: white;
}
.navbar .left {
.left {
display: flex;
}
.navbar .title {
.title {
padding-left: 2em;
padding-right: 2em;
margin: auto;
}
.navbar .left .search {
.search {
margin: auto;
}
.navbar .avatar {
padding-right: 2em;
margin-top: auto;
margin-bottom: auto;
}
.navbar .user-section {
.right {
display: flex;
align-items: center;
padding-right: 2em;

9
ui/src/components/Metars/MapTiles.tsx
View File

@@ -3,7 +3,7 @@
import { getAirports, updateAirport } from '@/api/airport';
import { Airport, AirportOrderField } from '@/api/airport.types';
import { getMetars } from '@/api/metar';
import { LatLngBounds, icon } from 'leaflet';
import { LatLngBounds, PointTuple, icon } from 'leaflet';
import { useEffect, useState } from 'react';
import { Marker, TileLayer, Tooltip, useMap, useMapEvents } from 'react-leaflet';
import MetarModal from './MetarModal';
@@ -70,8 +70,10 @@ export default function MapTiles() {
function metarIcon(airport: Airport) {
let iconUrl = '/icons/unkn.svg';
let iconSize: PointTuple = [20, 20];
if (!airport.has_metar && airport.latest_metar == undefined) {
iconUrl = '/icons/nometar.svg';
iconSize = [10, 10];
} else if (airport.latest_metar?.flight_category == 'VFR') {
iconUrl = '/icons/vfr.svg';
} else if (airport.latest_metar?.flight_category == 'MVFR') {
@@ -81,10 +83,7 @@ export default function MapTiles() {
} else if (airport.latest_metar?.flight_category == 'LIFR') {
iconUrl = '/icons/lifr.svg';
}
return icon({
iconUrl: iconUrl,
iconSize: [20, 20]
})
return icon({ iconUrl, iconSize })
}
useEffect(() => {