Refactor models names

This commit is contained in:
Tobias Reisinger 2023-11-27 12:49:40 +01:00
parent 76b14ce75b
commit be7f31906c
Signed by: serguzim
GPG key ID: 13AD60C237A28DFE
24 changed files with 461 additions and 340 deletions

View file

@ -2,17 +2,19 @@ use serde::{Deserialize, Deserializer};
#[derive(Debug, Clone, Copy)]
pub enum Driver {
Gpio,
Piface,
Gpio,
Piface,
}
impl<'de> Deserialize<'de> for Driver {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
match String::deserialize(deserializer)?.as_str() {
"gpio" => Ok(Driver::Gpio),
"piface" => Ok(Driver::Piface),
_ => Err(serde::de::Error::custom("invalid driver")),
}
}
}
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
match String::deserialize(deserializer)?.as_str() {
"gpio" => Ok(Driver::Gpio),
"piface" => Ok(Driver::Piface),
_ => Err(serde::de::Error::custom("invalid driver")),
}
}
}

View file

@ -1,32 +1,51 @@
use std::str;
use futures::{future, pin_mut, SinkExt, StreamExt};
use crate::relay_loop::run_relay_loop;
use crate::settings::Settings;
use emgauwa_lib::db::errors::DatabaseError;
use emgauwa_lib::db::{DbController, DbRelay};
use emgauwa_lib::types::ControllerUid;
use emgauwa_lib::{db, models};
use futures::channel::mpsc;
use futures::{future, pin_mut, SinkExt, StreamExt};
use sqlx::pool::PoolConnection;
use sqlx::Sqlite;
use tokio::io::AsyncReadExt;
use tokio_tungstenite::{connect_async, tungstenite::protocol::Message};
use tokio_tungstenite::tungstenite::Error;
use emgauwa_lib::db;
use emgauwa_lib::db::Controller;
use emgauwa_lib::db::types::ControllerUid;
use crate::relay_loop::run_relay_loop;
use crate::settings::Settings;
use tokio_tungstenite::{connect_async, tungstenite::protocol::Message};
mod settings;
mod driver;
mod relay_loop;
mod settings;
fn create_this_controller(conn: &mut PoolConnection<Sqlite>, settings: &Settings) -> Controller {
futures::executor::block_on(async {
Controller::create(
conn,
&ControllerUid::new(),
&settings.name,
i64::try_from(settings.relays.len()).expect("Too many relays"),
true
).await.expect("Failed to create controller")
})
async fn create_this_controller(
conn: &mut PoolConnection<Sqlite>,
settings: &Settings,
) -> DbController {
DbController::create(
conn,
&ControllerUid::default(),
&settings.name,
i64::try_from(settings.relays.len()).expect("Too many relays"),
true,
)
.await
.expect("Failed to create controller")
}
async fn create_this_relay(
conn: &mut PoolConnection<Sqlite>,
this_controller: &DbController,
settings_relay: &settings::Relay,
) -> DbRelay {
DbRelay::create(
conn,
&settings_relay.name,
settings_relay.number.unwrap(),
this_controller,
)
.await
.expect("Failed to create relay")
}
#[tokio::main]
@ -37,22 +56,60 @@ async fn main() {
let mut conn = pool.acquire().await.unwrap();
let this = Controller::get_all(&mut conn)
let db_controller = DbController::get_all(&mut conn)
.await
.expect("Failed to get controller from database")
.pop()
.unwrap_or_else(|| create_this_controller(&mut conn, &settings));
.unwrap_or_else(|| {
futures::executor::block_on(create_this_controller(&mut conn, &settings))
});
let db_relays: Vec<DbRelay> = settings
.relays
.iter()
.map(|relay| {
futures::executor::block_on(async {
match DbRelay::get_by_controller_and_num(
&mut conn,
&db_controller,
relay.number.unwrap(),
)
.await
{
Ok(relay) => relay,
Err(err) => match err {
DatabaseError::NotFound => {
create_this_relay(&mut conn, &db_controller, relay).await
}
_ => panic!("Failed to get relay from database"),
},
}
})
})
.collect();
let db_controller = db_controller
.update(&mut conn, &db_controller.name, db_relays.len() as i64, true)
.await
.unwrap();
let relays = db_relays
.into_iter()
.map(|relay| models::Relay::from_db_relay(relay, &mut conn))
.collect();
let this = models::Controller {
controller: db_controller,
relays,
};
let this_json = serde_json::to_string(&this).unwrap();
println!("{:?}", settings.relays);
println!("{:?}", this);
println!("{}", this_json);
let url = format!(
"ws://{}:{}/api/v1/ws/controllers",
settings.core.host,
settings.core.port
settings.core.host, settings.core.port
);
let (stdin_tx, stdin_rx) = mpsc::unbounded();
@ -83,13 +140,14 @@ async fn read_stdin(tx: mpsc::UnboundedSender<Message>) {
Ok(n) => n,
};
buf.truncate(n);
tx.unbounded_send(Message::text(str::from_utf8(&buf).unwrap())).unwrap();
tx.unbounded_send(Message::text(str::from_utf8(&buf).unwrap()))
.unwrap();
}
}
pub async fn handle_message(message_result: Result<Message, Error>) {
match message_result {
Ok(message) => println!("{}", message.into_text().unwrap()),
Err(err) => println!("Error: {}", err)
Err(err) => println!("Error: {}", err),
}
}
}

View file

@ -1,9 +1,8 @@
use chrono::Local;
use crate::settings::Settings;
use chrono::Local;
#[allow(unused_variables)]
pub async fn run_relay_loop(settings: Settings) {
let next_timestamp = Local::now().naive_local();
loop {
}
}
let next_timestamp = Local::now().naive_local();
loop {}
}

View file

@ -1,5 +1,6 @@
use emgauwa_lib::{constants, utils};
use serde_derive::Deserialize;
use crate::driver::Driver;
#[derive(Clone, Debug, Deserialize)]
@ -23,6 +24,8 @@ pub struct Logging {
#[allow(unused)]
pub struct Relay {
pub driver: Driver,
pub name: String,
pub number: Option<i64>,
pub pin: u8,
pub inverted: bool,
}
@ -54,6 +57,8 @@ impl Default for Relay {
fn default() -> Self {
Relay {
driver: Driver::Gpio,
number: None,
name: String::from("Relay"),
pin: 0,
inverted: false,
}
@ -79,5 +84,13 @@ impl Default for Logging {
}
pub fn init() -> Settings {
utils::load_settings("controller", "CONTROLLER")
let mut settings: Settings = utils::load_settings("controller", "CONTROLLER");
for (num, relay) in settings.relays.iter_mut().enumerate() {
if relay.number.is_none() {
relay.number = Some(num as i64);
}
}
settings
}