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

Update frequencies to communications, fixed control icons

Browse Source
This commit is contained in:
Ben Sherriff
2025-05-14 08:28:43 -04:00
parent 019fb77373
commit 1e3c75624a
18 changed files with 20457 additions and 20413 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
api/migrations/20250513_initial.sql
View File

@@ -39,20 +39,19 @@ CREATE TABLE IF NOT EXISTS runways (
CREATE INDEX ON runways (icao);
CREATE INDEX ON runways (runway_id);
CREATE INDEX ON runways (surface);
CREATE TABLE IF NOT EXISTS frequencies (
CREATE TABLE IF NOT EXISTS communications (
id UUID PRIMARY KEY NOT NULL,
icao TEXT NOT NULL,
frequency_id TEXT NOT NULL,
frequency_name TEXT,
frequency_mhz REAL NOT NULL
name TEXT,
frequencies_mhz REAL[] NOT NULL,
phone TEXT
);
CREATE INDEX ON frequencies (icao);
CREATE INDEX ON frequencies (frequency_id);
CREATE INDEX ON frequencies (frequency_name);
CREATE INDEX ON frequencies (frequency_mhz);
CREATE INDEX ON communications (icao);
CREATE INDEX ON communications (frequency_id);
CREATE INDEX ON communications (name);
CREATE TABLE IF NOT EXISTS metars (
icao TEXT NOT NULL,

7
api/src/account/session.rs
View File

@@ -120,7 +120,7 @@ impl Session {
if let Ok(environment) = std::env::var("ENVIRONMENT") {
if environment == "development" || environment == "dev" {
log::trace!(
"Development cookie [ID: {}]: {}",
"Session cookie [ID: {}]: {}",
self.id,
self.session_id
);
@@ -147,6 +147,11 @@ impl Session {
if let Ok(environment) = std::env::var("ENVIRONMENT") {
if environment == "development" || environment == "dev" {
log::trace!(
"Session expiration cookie [ID: {}]: {}",
self.id,
self.session_id
);
cookie.set_secure(false);
}
}

40
api/src/airports/model/airport.rs
View File

@@ -6,7 +6,7 @@ use reqwest::Client;
use serde::{Deserialize, Serialize};
use sqlx::{Postgres, QueryBuilder};
use crate::airports::{
AirportCategory, Frequency, FrequencyRow, Runway, RunwayRow, UpdateFrequency, UpdateRunway,
AirportCategory, Communication, CommunicationRow, Runway, RunwayRow, UpdateCommunication, UpdateRunway,
};
use crate::db;
use crate::error::{ApiResult, Error};
@@ -34,7 +34,7 @@ pub struct Airport {
#[serde(skip_serializing_if = "Option::is_none")]
pub has_beacon: Option<bool>,
pub runways: Vec<Runway>,
pub frequencies: Vec<Frequency>,
pub communications: Vec<Communication>,
pub public: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_metar: Option<Metar>,
@@ -141,7 +141,7 @@ pub struct UpdateAirport {
pub has_tower: Option<bool>,
pub has_beacon: Option<bool>,
pub runways: Option<Vec<UpdateRunway>>,
pub frequencies: Option<Vec<UpdateFrequency>>,
pub communications: Option<Vec<UpdateCommunication>>,
pub public: Option<bool>,
pub latest_metar_observation: Option<DateTime<Utc>>,
}
@@ -194,7 +194,7 @@ impl From<AirportRow> for Airport {
has_tower: airport.has_tower,
has_beacon: airport.has_beacon,
runways: vec![],
frequencies: vec![],
communications: vec![],
public: airport.public,
latest_metar: None,
}
@@ -227,10 +227,10 @@ impl Airport {
};
let runways_fut = Runway::select_all(icao);
let frequencies_fut = Frequency::select_all(icao);
let communications_fut = Communication::select_all(icao);
let (airport_result, runways_result, frequencies_result, metar_result) =
tokio::join!(airport_fut, runways_fut, frequencies_fut, metar_fut);
let (airport_result, runways_result, communications_result, metar_result) =
tokio::join!(airport_fut, runways_fut, communications_fut, metar_fut);
let airport_row: Option<AirportRow> = match airport_result {
Ok(opt) => opt,
@@ -248,11 +248,11 @@ impl Airport {
}
};
let frequencies: Vec<Frequency> = match frequencies_result {
let communications: Vec<Communication> = match communications_result {
Ok(f) => f,
Err(err) => {
log::error!(
"Error retrieving frequencies for airport '{}': {}",
"Error retrieving communications for airport '{}': {}",
icao,
err
);
@@ -271,7 +271,7 @@ impl Airport {
airport_row.map(|row| {
let mut airport: Airport = row.into();
airport.runways = runways;
airport.frequencies = frequencies;
airport.communications = communications;
airport.latest_metar = metar;
airport
})
@@ -343,7 +343,7 @@ impl Airport {
let icaos: Vec<String> = airports.iter().map(|a| a.icao.clone()).collect();
let runway_future = Runway::select_all_map(icaos.clone());
let frequency_future = Frequency::select_all_map(icaos.clone());
let frequency_future = Communication::select_all_map(icaos.clone());
let metar_future = if query.metars.unwrap_or(false) {
Some(Metar::find_all_distinct(client, &icaos))
} else {
@@ -373,7 +373,7 @@ impl Airport {
for airport in airports.iter_mut() {
airport.runways = runway_map.get(&airport.icao).cloned().unwrap_or_default();
airport.frequencies = frequency_map
airport.communications = frequency_map
.get(&airport.icao)
.cloned()
.unwrap_or_default();
@@ -428,15 +428,15 @@ impl Airport {
let pool = db::pool();
let mut all_runway_rows: Vec<RunwayRow> = Vec::new();
let mut all_frequency_rows: Vec<FrequencyRow> = Vec::new();
let mut all_frequency_rows: Vec<CommunicationRow> = Vec::new();
for runway in &self.runways {
all_runway_rows.push(Runway::into(runway, &self.icao));
}
for frequency in &self.frequencies {
all_frequency_rows.push(Frequency::into(frequency, &self.icao));
for frequency in &self.communications {
all_frequency_rows.push(Communication::into(frequency, &self.icao));
}
Runway::insert_all(&all_runway_rows).await?;
Frequency::insert_all(&all_frequency_rows).await?;
Communication::insert_all(&all_frequency_rows).await?;
let airport: AirportRow = sqlx::query_as(&format!(
r#"
@@ -476,15 +476,15 @@ impl Airport {
let pool = db::pool();
let chunk_size = 1000;
let mut all_runway_rows: Vec<RunwayRow> = Vec::new();
let mut all_frequency_rows: Vec<FrequencyRow> = Vec::new();
let mut all_frequency_rows: Vec<CommunicationRow> = Vec::new();
let airport_rows: Vec<AirportRow> = airports
.into_iter()
.map(|airport| {
for runway in &airport.runways {
all_runway_rows.push(Runway::into(runway, &airport.icao));
}
for frequency in &airport.frequencies {
all_frequency_rows.push(Frequency::into(frequency, &airport.icao));
for frequency in &airport.communications {
all_frequency_rows.push(Communication::into(frequency, &airport.icao));
}
airport.into()
})
@@ -518,7 +518,7 @@ impl Airport {
}
Runway::insert_all(&all_runway_rows).await?;
Frequency::insert_all(&all_frequency_rows).await?;
Communication::insert_all(&all_frequency_rows).await?;
Ok(())
}

75
api/src/airports/model/frequency.rs → api/src/airports/model/communication.rs
View File

@@ -5,63 +5,69 @@ use uuid::Uuid;
use crate::db;
use crate::error::ApiResult;
const TABLE_NAME: &str = "frequencies";
const TABLE_NAME: &str = "communications";
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Frequency {
#[serde(rename = "id")]
pub frequency_id: String,
#[serde(rename = "name")]
pub frequency_name: Option<String>,
pub frequency_mhz: f32,
pub struct Communication {
pub id: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
pub frequencies_mhz: Vec<f32>,
#[serde(skip_serializing_if = "Option::is_none")]
pub phone: Option<String>,
}
#[derive(Debug, Deserialize, sqlx::FromRow)]
pub struct FrequencyRow {
pub struct CommunicationRow {
pub id: Uuid,
pub icao: String,
pub frequency_id: String,
pub frequency_name: Option<String>,
pub frequency_mhz: f32,
pub name: Option<String>,
pub frequencies_mhz: Vec<f32>,
pub phone: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct UpdateFrequency {
pub struct UpdateCommunication {
#[serde(skip_serializing_if = "Option::is_none")]
pub icao: Option<String>,
#[serde(rename = "id", skip_serializing_if = "Option::is_none")]
pub frequency_id: Option<String>,
#[serde(rename = "name", skip_serializing_if = "Option::is_none")]
pub frequency_name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub frequency_mhz: Option<f32>,
pub id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub frequencies_mhz: Option<Vec<f32>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub phone: Option<String>,
}
impl From<FrequencyRow> for Frequency {
fn from(frequency: FrequencyRow) -> Self {
impl From<CommunicationRow> for Communication {
fn from(frequency: CommunicationRow) -> Self {
Self {
frequency_id: frequency.frequency_id.clone(),
frequency_name: frequency.frequency_name.clone(),
frequency_mhz: frequency.frequency_mhz,
id: frequency.frequency_id.clone(),
name: frequency.name.clone(),
frequencies_mhz: frequency.frequencies_mhz,
phone: frequency.phone.clone(),
}
}
}
impl Frequency {
pub fn into(frequency: &Frequency, icao: &str) -> FrequencyRow {
FrequencyRow {
impl Communication {
pub fn into(frequency: &Communication, icao: &str) -> CommunicationRow {
CommunicationRow {
id: Uuid::new_v4(),
icao: icao.to_string(),
frequency_id: frequency.frequency_id.clone(),
frequency_name: frequency.frequency_name.clone(),
frequency_mhz: frequency.frequency_mhz.clone(),
frequency_id: frequency.id.clone(),
name: frequency.name.clone(),
frequencies_mhz: frequency.frequencies_mhz.clone(),
phone: frequency.phone.clone(),
}
}
pub async fn select_all_map(icaos: Vec<String>) -> ApiResult<HashMap<String, Vec<Self>>> {
let pool = db::pool();
let frequency_rows: Vec<FrequencyRow> = sqlx::query_as(&format!(
let frequency_rows: Vec<CommunicationRow> = sqlx::query_as(&format!(
r#"SELECT * FROM {} WHERE icao = ANY($1)"#,
TABLE_NAME
))
@@ -85,7 +91,7 @@ impl Frequency {
pub async fn select_all(icao: &str) -> ApiResult<Vec<Self>> {
let pool = db::pool();
let frequency_row: Vec<FrequencyRow> = sqlx::query_as(&format!(
let frequency_row: Vec<CommunicationRow> = sqlx::query_as(&format!(
r#"
SELECT * FROM {} WHERE icao = $1
"#,
@@ -97,21 +103,22 @@ impl Frequency {
Ok(frequency_row.into_iter().map(From::from).collect())
}
pub async fn insert_all(frequencies: &Vec<FrequencyRow>) -> ApiResult<()> {
pub async fn insert_all(communications: &Vec<CommunicationRow>) -> ApiResult<()> {
let pool = db::pool();
let chunk_size = 1000;
for chunk in frequencies.chunks(chunk_size) {
for chunk in communications.chunks(chunk_size) {
let mut query_builder: QueryBuilder<Postgres> = QueryBuilder::new(&format!(
"INSERT INTO {} (id, icao, frequency_id, frequency_name, frequency_mhz) ",
"INSERT INTO {} (id, icao, frequency_id, name, frequencies_mhz, phone) ",
TABLE_NAME
));
query_builder.push_values(chunk, |mut b, row| {
b.push_bind(&row.id)
.push_bind(&row.icao)
.push_bind(&row.frequency_id)
.push_bind(&row.frequency_name)
.push_bind(&row.frequency_mhz);
.push_bind(&row.name)
.push_bind(&row.frequencies_mhz)
.push_bind(&row.phone);
});
let query = query_builder.build();

4
api/src/airports/model/mod.rs
View File

@@ -1,9 +1,9 @@
mod airport;
mod airport_category;
mod frequency;
mod communication;
mod runway;
pub use airport::*;
pub use airport_category::*;
pub use frequency::*;
pub use communication::*;
pub use runway::*;

2
api/src/metars/model.rs
View File

@@ -855,7 +855,7 @@ impl Metar {
has_tower: None,
has_beacon: None,
runways: None,
frequencies: None,
communications: None,
public: None,
latest_metar_observation: Some(observation_time),
},