fire

.gitignore

@@ -1,2 +1,6 @@
 /target
 .env
+backend/target/sqlx/backend
+Cargo.lock
+frontend/dist/db-frontend-a8d46cf89f6300e8.js
+frontend/dist

README.md

@@ -4,18 +4,12 @@ The project structure is divided into 3 thingies
 ## Frontend
 - Utilises YEW
 - Builds component with HTML macro
-- Fetches values from API via requests see [https://yew.rs/docs/0.18.0/concepts/services/fetch#dispatching-requests](Yew requests) 
 - Don't need anythign fancy yet
+- Will hopefully add more here
+- [ ] Make user input without dying
 
 ## Backend 
-Ohoihohohoho t he fun begins here 
+Realised that diesel is abysmal and should not be used holy fuck
-- Covering get requests for now to fetch data
+- sqlx my beloved
-- the path is read from the macro atop the functions
+- we write the SQL code and it gets checked at compile time very cool
-- the function takes variables that are in {} in the path
+- [ ] Define structs for certain types for simplicity sake
-- must pass the vars into their smaller first not directly web::Path<Type> or whatever
-- Template function for ticket extraction exists
-- [ ] Make retrieval functions for all data types (Refer to models.rs for those and their parameters)
-
-### Models.rs
-the good file where the structs that interact with the database occurred
-

backend/Cargo.toml

@@ -6,10 +6,14 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-diesel = { version = "2.0.0",features = ["postgres","r2d2","chrono"] }
 dotenv = "0.15"
-chrono = "0.2.25"
 common = { path = "../common"}
-actix-web = "4.0.0-rc.1"
-tokio = { version = "1.17.0", features = ["full"] }
 yew = { version = "0.20.0", features = ["csr"] }
+anyhow = "1.0"
+futures = "0.3"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+sqlx = {version = "0.6", features = ["postgres", "json", "runtime-actix-rustls", "chrono", "decimal", "uuid", "offline"] }
+async-trait =  "0.1.60"
+actix-web = "4"
+chrono = {version = "0.4.23", features = ["serde"]}

backend/migrations/00000000000000_diesel_initial_setup/down.sql

@@ -1,6 +0,0 @@
--- This file was automatically created by Diesel to setup helper functions
--- and other internal bookkeeping. This file is safe to edit, any future
--- changes will be added to existing projects as new migrations.
-
-DROP FUNCTION IF EXISTS diesel_manage_updated_at(_tbl regclass);
-DROP FUNCTION IF EXISTS diesel_set_updated_at();

backend/migrations/00000000000000_diesel_initial_setup/up.sql

@@ -1,36 +0,0 @@
--- This file was automatically created by Diesel to setup helper functions
--- and other internal bookkeeping. This file is safe to edit, any future
--- changes will be added to existing projects as new migrations.
-
-
-
-
--- Sets up a trigger for the given table to automatically set a column called
--- `updated_at` whenever the row is modified (unless `updated_at` was included
--- in the modified columns)
---
--- # Example
---
--- ```sql
--- CREATE TABLE users (id SERIAL PRIMARY KEY, updated_at TIMESTAMP NOT NULL DEFAULT NOW());
---
--- SELECT diesel_manage_updated_at('users');
--- ```
-CREATE OR REPLACE FUNCTION diesel_manage_updated_at(_tbl regclass) RETURNS VOID AS $$
-BEGIN
-    EXECUTE format('CREATE TRIGGER set_updated_at BEFORE UPDATE ON %s
-                    FOR EACH ROW EXECUTE PROCEDURE diesel_set_updated_at()', _tbl);
-END;
-$$ LANGUAGE plpgsql;
-
-CREATE OR REPLACE FUNCTION diesel_set_updated_at() RETURNS trigger AS $$
-BEGIN
-    IF (
-        NEW IS DISTINCT FROM OLD AND
-        NEW.updated_at IS NOT DISTINCT FROM OLD.updated_at
-    ) THEN
-        NEW.updated_at := current_timestamp;
-    END IF;
-    RETURN NEW;
-END;
-$$ LANGUAGE plpgsql;

backend/sqlx-data.json

@@ -0,0 +1,69 @@
+{
+  "db": "PostgreSQL",
+  "eab68949a5cbad11b0ca3bc62e4e5c3611df0d3af69633dba08e3ad3941d76d1": {
+    "describe": {
+      "columns": [
+        {
+          "name": "id",
+          "ordinal": 0,
+          "type_info": "Int4"
+        }
+      ],
+      "nullable": [
+        false
+      ],
+      "parameters": {
+        "Left": [
+          "Int4",
+          "Text",
+          "Text",
+          "Date",
+          "Date"
+        ]
+      }
+    },
+    "query": "\n            INSERT INTO drivers ( id, name, address, reg_date, birthdate )\n            VALUES ( $1, $2, $3, $4, $5 ) \n            RETURNING id\n            "
+  },
+  "edfc7e63f5381c6f71191820f798a0f66ebaee1ceb9f3a5466d9f73ffe8271d0": {
+    "describe": {
+      "columns": [
+        {
+          "name": "id",
+          "ordinal": 0,
+          "type_info": "Int4"
+        },
+        {
+          "name": "name",
+          "ordinal": 1,
+          "type_info": "Text"
+        },
+        {
+          "name": "address",
+          "ordinal": 2,
+          "type_info": "Text"
+        },
+        {
+          "name": "reg_date",
+          "ordinal": 3,
+          "type_info": "Date"
+        },
+        {
+          "name": "birthdate",
+          "ordinal": 4,
+          "type_info": "Date"
+        }
+      ],
+      "nullable": [
+        false,
+        false,
+        false,
+        false,
+        false
+      ],
+      "parameters": {
+        "Left": []
+      }
+    },
+    "query": "SELECT * FROM drivers"
+  }
+}

backend/src/admin_data.rs

@@ -1,55 +1,2 @@
-use crate::models::{Admin, AdminEmail, NewAdmin, NewAdminEmail};
-use common::CommonAdmin;
-use diesel::prelude::*;
 
-pub fn listadmins(connection: &mut PgConnection) -> String {
-    use crate::schema::admins::dsl::*;
-    let query = admins.load::<Admin>(connection).expect("KANKER");
-    let admin_list = query
-        .iter()
-        .map(|admin| format!("{} {}\n", admin.name, admin.address))
-        .collect();
-    return admin_list;
-}
-pub fn addmin(connection: &mut PgConnection, new_admin: NewAdmin) {
-    use crate::schema::admins::dsl::*;
-    diesel::insert_into(admins)
-        .values(&new_admin)
-        .execute(connection)
-        .expect("LOL DEAD NOT WORKING INSERTION");
-}
-pub fn addmail(connection: &mut PgConnection, admin_email: String, inserted_id: i32) {
-    use crate::schema::admin_emails::dsl::*;
-    let inserted_email = NewAdminEmail {
-        admin_id: &inserted_id,
-        email: &admin_email,
-    };
-    diesel::insert_into(admin_emails)
-        .values(inserted_email)
-        .execute(connection)
-        .expect("You FOOL! You didn't put an email in there");
-}
 
-pub fn listadminmails(connection: &mut PgConnection) {
-    use crate::schema::admin_emails::dsl::*;
-    let results = admin_emails
-        .load::<AdminEmail>(connection)
-        .expect("hecc D:");
-    for addmail in results {
-        println!("{} {}", addmail.email, addmail.admin_id);
-    }
-}
-
-pub fn get_admin(connection: &mut PgConnection, admin_id: i32) -> CommonAdmin {
-    use crate::schema::admins::dsl::*;
-    let admin = &mut admins
-        .filter(id.eq(admin_id))
-        .limit(1)
-        .load::<Admin>(connection)
-        .expect("no admins  :(")[0];
-    return CommonAdmin {
-        id: admin.id,
-        name: String::from(&admin.name),
-        address: String::from(&admin.address),
-    };
-}

backend/src/driver_data.rs

@@ -1,34 +1,46 @@
-use crate::models::{Driver, NewDriver};
+use crate::pog::SqlStruct;
-use common::CommonDriver;
+use actix_web::{get, web, HttpResponse, Responder};
-use diesel::prelude::*;
+use async_trait::async_trait;
+use chrono::NaiveDate;
+use serde::{Deserialize, Serialize};
+use sqlx::PgPool;
 
-pub fn listdrivers(connection: &mut PgConnection) {
+#[derive(Serialize, Deserialize, Debug, Clone, sqlx::FromRow)]
-    use crate::schema::drivers::dsl::*;
+pub struct Driver {
-    let queury = drivers.load::<Driver>(connection).expect("KANKER");
+    pub id: i32,
-    for driver in queury {
+    pub name: String,
-        println!("{} {}", driver.name, driver.address);
+    pub address: String,
-    }
+    pub reg_date: NaiveDate,
+    pub birthdate: NaiveDate,
 }
 
-pub fn addriver(connection: &mut PgConnection, new_driver: NewDriver) {
+#[async_trait]
-    use crate::schema::drivers::dsl::*;
+impl SqlStruct<i32> for Driver {
-    diesel::insert_into(drivers)
+    async fn add(&self, pool: &PgPool) -> anyhow::Result<i32> {
-        .values(&new_driver)
+        let rec = sqlx::query!(
-        .execute(connection)
+            r#"
-        .expect("Couldn't insert new driver :)");
+            INSERT INTO drivers ( id, name, address, reg_date, birthdate )
+            VALUES ( $1, $2, $3, $4, $5 ) 
+            RETURNING id
+            "#,
+            self.id as i32,
+            self.name,
+            self.address,
+            self.reg_date,
+            self.birthdate,
+        )
+        .fetch_one(pool)
+        .await?;
+        Ok(rec.id)
     }
-
-pub fn get_driver(connection: &mut PgConnection, driver_id: i32) -> CommonDriver {
-    use crate::schema::drivers::dsl::*;
-    let driver = &mut drivers
-        .filter(id.eq(driver_id))
-        .limit(1)
-        .load::<Driver>(connection)
-        .expect("no drivers  :(")[0];
-    return CommonDriver {
-        id: driver.id,
-        name: String::from(&driver.name),
-        address: String::from(&driver.address),
-    };
 }
-
+#[get("/api/json/drivers")]
+pub async fn list_all(db_pool: web::Data<PgPool>) -> impl Responder {
+    let drivers = sqlx::query_as!(Driver, "SELECT * FROM drivers")
+        .fetch_all(db_pool.get_ref())
+        .await
+        .expect("Could not fetch anything from the DB D:");
+    HttpResponse::Ok()
+        .content_type("application/json")
+        .json(drivers)
+}

backend/src/lib.rs

@@ -1,34 +0,0 @@
-use std::env;
-pub mod admin_data;
-pub mod driver_data;
-pub mod models;
-pub mod radar_data;
-pub mod schema;
-pub mod ticket_data;
-pub mod vehicle_data;
-use diesel::{Connection, PgConnection};
-use dotenv::dotenv;
-
-//boiler plate :D
-pub fn establish_connection() -> PgConnection {
-    dotenv().ok();
-    let database_url = env::var("DATABASE_URL").expect("fix your .env idot");
-    PgConnection::establish(&database_url)
-        .unwrap_or_else(|_| panic!("Error connecting to {}", database_url))
-}
-//
-//Pool instead
-
-// pub type PgPool = r2d2::Pool<ConnectionManager<PgConnection>>;
-// pub type PgPooledConnection = PooledConnection<ConnectionManager<PgConnection>>;
-// fn init_pool(database_url: &str) -> Result<PgPool, PoolError> {
-//     let manager = ConnectionManager::<PgConnection>::new(database_url);
-//     Pool::builder().build(manager)
-// }
-//
-// pub fn establish_connection() -> PgPool {
-//     dotenv().ok();
-//
-//     let database_url = env::var("DATABASE_URL").expect("pls obama put the link this time");
-//     init_pool(&database_url).expect("Failed to create pool")
-// }

backend/src/main.rs

@@ -0,0 +1,38 @@
+use actix_web::{web, App, HttpServer};
+use dotenv::dotenv;
+use sqlx::postgres::PgPoolOptions;
+use std::env;
+
+#[cfg(test)]
+mod tests;
+
+pub mod admin_data;
+pub mod driver_data;
+pub mod pog;
+pub mod radar_data;
+pub mod ticket_data;
+pub mod vehicle_data;
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    dotenv().ok();
+    let port: u16 = env::var("ACTIX_PORT")
+        .expect("SET ACTIX_PORT PLOX")
+        .parse()
+        .expect("NOPE CANT PARSE THIS WHAT DID YOU PUT IN?!!!");
+    let address = env::var("ACTIX_IP").expect("SET ACTIX_IP PLOX");
+    let database_url = env::var("DATABASE_URL").expect("Put a DB url in the .env file dumbass");
+    let pool = PgPoolOptions::new()
+        .max_connections(10)
+        .connect(database_url.as_str())
+        .await
+        .expect("No pool connection man :(");
+    HttpServer::new(move || {
+        App::new()
+            .app_data(web::Data::new(pool.clone()))
+            .service(driver_data::list_all)
+    })
+    .bind((address.as_str(), port))?
+    .run()
+    .await
+}

backend/src/models.rs

@@ -1,99 +0,0 @@
-use crate::schema::*;
-use diesel::{data_types::PgDate, prelude::*};
-
-//Admins
-#[derive(Queryable, Debug, AsChangeset, Identifiable)]
-pub struct Admin {
-    pub id: i32,
-    pub name: String,
-    pub address: String,
-}
-
-#[derive(Insertable)]
-#[diesel(table_name = admins)]
-pub struct NewAdmin<'a> {
-    pub id: i32,
-    pub name: &'a str,
-    pub address: &'a str,
-}
-
-#[derive(Queryable, AsChangeset, Associations)]
-#[diesel(belongs_to(Admin))]
-pub struct AdminEmail {
-    pub admin_id: i32,
-    pub email: String,
-}
-
-#[derive(Insertable, Associations)]
-#[diesel(belongs_to(Admin))]
-#[diesel(table_name = admin_emails)]
-pub struct NewAdminEmail<'a> {
-    pub admin_id: &'a i32,
-    pub email: &'a str,
-}
-
-//Ticket things
-#[derive(Queryable)]
-pub struct Ticket {
-    pub id: i32,
-    pub category: String,
-    pub description: String,
-    pub issue_date: PgDate,
-}
-
-#[derive(Insertable)]
-#[diesel(table_name = tickets)]
-pub struct NewTicket<'a> {
-    pub category: &'a str,
-    pub description: &'a str,
-}
-
-#[derive(Insertable)]
-#[diesel(table_name = issued_tickets)]
-pub struct IssuedTicket {
-    ticket: i32,
-    vehicle: String,
-    driver: Option<i32>,
-    officer: i32,
-}
-
-#[derive(Insertable)]
-#[diesel(table_name = auto_issued_tickets)]
-pub struct AutoIssuedTicket<'a> {
-    ticket: &'a i32,
-    vehicle: &'a str,
-    driver: Option<i32>,
-    radar: &'a i32,
-}
-
-//Drivers
-#[derive(Queryable, AsChangeset, Identifiable)]
-pub struct Driver {
-    pub id: i32,
-    pub name: String,
-    pub address: String,
-    pub reg_date: PgDate,
-    pub birthdate: PgDate,
-}
-
-#[derive(Insertable)]
-#[diesel(table_name = drivers)]
-pub struct NewDriver<'a> {
-    pub id: i32,
-    pub name: &'a str,
-    pub address: &'a str,
-    reg_date: PgDate,
-    birthdate: PgDate,
-}
-
-//Vehicles
-#[derive(Queryable, AsChangeset)]
-#[diesel(belongs_to(Driver))]
-pub struct Vehicle {
-    pub model: Option<String>,
-    pub color: Option<String>,
-    pub chasse_num: i32,
-    pub plate_num: String,
-    pub vehicle_type: String,
-    pub owner: i32,
-}

backend/src/pog.rs

@@ -0,0 +1,9 @@
+use anyhow::Result;
+use async_trait::async_trait;
+use sqlx::PgPool;
+
+//Nuke happened here but we got POOLS :DDDDDD
+#[async_trait]
+pub trait SqlStruct<T> {
+    async fn add(&self, pool: &PgPool) -> Result<T>;
+}

backend/src/radar_data.rs

@@ -0,0 +1,2 @@
+
+

backend/src/schema.rs

@@ -1,132 +0,0 @@
-// @generated automatically by Diesel CLI.
-
-diesel::table! {
-    admin_emails (admin_id, email) {
-        admin_id -> Int4,
-        email -> Text,
-    }
-}
-
-diesel::table! {
-    admins (id) {
-        id -> Int4,
-        name -> Text,
-        address -> Text,
-    }
-}
-
-diesel::table! {
-    auto_issued_tickets (ticket) {
-        ticket -> Int4,
-        vehicle -> Text,
-        driver -> Nullable<Int4>,
-        radar -> Int4,
-    }
-}
-
-diesel::table! {
-    driver_phones (driver, number) {
-        driver -> Int4,
-        number -> Int4,
-    }
-}
-
-diesel::table! {
-    drivers (id) {
-        id -> Int4,
-        name -> Text,
-        address -> Text,
-        reg_date -> Date,
-        birthdate -> Date,
-    }
-}
-
-diesel::table! {
-    issued_tickets (ticket) {
-        ticket -> Int4,
-        vehicle -> Text,
-        driver -> Nullable<Int4>,
-        officer -> Int4,
-    }
-}
-
-diesel::table! {
-    officer_emails (officer, email) {
-        officer -> Int4,
-        email -> Text,
-    }
-}
-
-diesel::table! {
-    officer_phones (officer, number) {
-        officer -> Int4,
-        number -> Int4,
-    }
-}
-
-diesel::table! {
-    officers (badge_num) {
-        badge_num -> Int4,
-        id -> Text,
-        jurisdiction -> Nullable<Text>,
-    }
-}
-
-diesel::table! {
-    radars (serialnumber) {
-        serialnumber -> Int4,
-        #[sql_name = "type"]
-        type_ -> Nullable<Text>,
-        address -> Nullable<Text>,
-    }
-}
-
-diesel::table! {
-    tickets (id) {
-        id -> Int4,
-        category -> Text,
-        description -> Text,
-        issue_date -> Date,
-    }
-}
-
-diesel::table! {
-    vehicles (plate_num) {
-        model -> Nullable<Text>,
-        color -> Nullable<Text>,
-        chasse_num -> Nullable<Int4>,
-        plate_num -> Text,
-        vehicle_type -> Text,
-        category -> Text,
-        owner -> Nullable<Int4>,
-    }
-}
-
-diesel::joinable!(admin_emails -> admins (admin_id));
-diesel::joinable!(auto_issued_tickets -> drivers (driver));
-diesel::joinable!(auto_issued_tickets -> radars (radar));
-diesel::joinable!(auto_issued_tickets -> tickets (ticket));
-diesel::joinable!(auto_issued_tickets -> vehicles (vehicle));
-diesel::joinable!(driver_phones -> drivers (driver));
-diesel::joinable!(issued_tickets -> drivers (driver));
-diesel::joinable!(issued_tickets -> officers (officer));
-diesel::joinable!(issued_tickets -> tickets (ticket));
-diesel::joinable!(issued_tickets -> vehicles (vehicle));
-diesel::joinable!(officer_emails -> officers (officer));
-diesel::joinable!(officer_phones -> officers (officer));
-diesel::joinable!(vehicles -> drivers (owner));
-
-diesel::allow_tables_to_appear_in_same_query!(
-    admin_emails,
-    admins,
-    auto_issued_tickets,
-    driver_phones,
-    drivers,
-    issued_tickets,
-    officer_emails,
-    officer_phones,
-    officers,
-    radars,
-    tickets,
-    vehicles,
-);

backend/src/tests.rs

@@ -0,0 +1,30 @@
+use super::*;
+use actix_web::{
+    http::header::ContentType,
+    test::{self, init_service},
+};
+
+//TODO: sqlx offline mode for these tests
+#[actix_web::test]
+async fn test_list_drivers_ok() {
+    dotenv().ok();
+    let database_url = env::var("DATABASE_URL").expect("Put a DB url in the .env file dumbass");
+    let pool = PgPoolOptions::new()
+        .max_connections(10)
+        .connect(database_url.as_str())
+        .await
+        .expect("No pool connection man :(");
+    let app = tests::init_service(
+        App::new()
+            .app_data(web::Data::new(pool.clone()))
+            .service(driver_data::list_all),
+    )
+    .await;
+    let req = test::TestRequest::get()
+        .uri("/api/json/drivers")
+        .insert_header(ContentType::plaintext())
+        .to_request();
+    let resp = test::call_service(&app, req).await;
+    assert!(resp.status().is_success());
+}
+//TODO: sqlx tests

backend/src/ticket_data.rs

@@ -1,57 +1,2 @@
-use crate::models::{AutoIssuedTicket, IssuedTicket, NewTicket, Ticket};
-use common::CommonTicket;
-use diesel::prelude::*;
 
-pub fn create_ticket(connection: &mut PgConnection, ticket: NewTicket) {
-    use crate::schema::tickets::dsl::*;
-    diesel::insert_into(tickets)
-        .values(&ticket)
-        .execute(connection)
-        .expect("Didn't save ticket AAAAAA");
-}
 
-pub fn get_tickets(connection: &mut PgConnection, amount: i64) -> Vec<CommonTicket> {
-    use crate::schema::tickets::dsl::*;
-    let results = tickets
-        .limit(amount)
-        .load::<Ticket>(connection)
-        .expect("KANKER TIKET");
-    return results
-        .iter()
-        .map(|ticket| CommonTicket {
-            id: ticket.id,
-            category: String::from(&ticket.category),
-            description: String::from(&ticket.description),
-        })
-        .collect(); //Shoves everything to a vector
-}
-
-pub fn get_ticket(connection: &mut PgConnection, tickid: i32) -> CommonTicket {
-    use crate::schema::tickets::dsl::*;
-    let ticket = &mut tickets
-        .filter(id.eq(tickid))
-        .limit(1)
-        .load::<Ticket>(connection)
-        .expect("no tickets  :(")[0];
-    return CommonTicket {
-        id: ticket.id,
-        category: String::from(&ticket.category),
-        description: String::from(&ticket.description),
-    };
-}
-
-pub fn issue_ticket(connection: &mut PgConnection, issued_ticket: IssuedTicket) {
-    use crate::schema::issued_tickets::dsl::*;
-    diesel::insert_into(issued_tickets)
-        .values(issued_ticket)
-        .execute(connection)
-        .expect("PAINNNN IT NO WORKEY (issued tickets)");
-}
-
-pub fn auto_issue_ticket(connection: &mut PgConnection, issued_ticket: AutoIssuedTicket) {
-    use crate::schema::auto_issued_tickets::dsl::*;
-    diesel::insert_into(auto_issued_tickets)
-        .values(issued_ticket)
-        .execute(connection)
-        .expect("PAINNNN IT NO WORKEY (issued tickets)");
-}

backend/src/vehicle_data.rs

@@ -0,0 +1,2 @@
+
+

common/src/lib.rs

@@ -24,3 +24,23 @@ pub struct CommonDriver {
     pub address: String,
 }
 
+//generate common radar struct
+#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct CommonRadar {
+    pub id: i32,
+    pub category: Option<String>,
+    pub address: Option<String>,
+}
+
+#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct CommonVehicle {
+    pub model: Option<String>,
+    pub category: String,
+    pub color: Option<String>,
+    pub chasse_num: Option<i32>,
+    pub plate_num: String,
+    pub vehicle_type: String,
+    pub owner: Option<i32>,
+}

frontend/Cargo.toml

@@ -8,4 +8,20 @@ edition = "2021"
 [dependencies]
 yew = { version = "0.20.0", features = ["csr"] }
 common = { path = "../common"}
-diesel = { version = "2.0.0",features = ["postgres","r2d2"] }
+gloo-net = {version = "0.2"}
+gloo = "0.8"
+serde = { version = "1.0.126", features = ["derive"] }
+serde_json = "1.0.64"
+wasm-bindgen = "0.2"
+wasm-bindgen-futures = "0.4"
+
+[dependencies.web-sys]
+version = "0.3"
+features = [
+  "Headers",
+  "Request",
+  "RequestInit",
+  "RequestMode",
+  "Response",
+  "Window",
+]

frontend/dist/db-frontend-12bfbd74b2a545ed.js

@@ -0,0 +1,678 @@
+
+let wasm;
+
+const heap = new Array(32).fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+function getObject(idx) { return heap[idx]; }
+
+let WASM_VECTOR_LEN = 0;
+
+let cachedUint8Memory0 = new Uint8Array();
+
+function getUint8Memory0() {
+    if (cachedUint8Memory0.byteLength === 0) {
+        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8Memory0;
+}
+
+const cachedTextEncoder = new TextEncoder('utf-8');
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+}
+    : function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+        read: arg.length,
+        written: buf.length
+    };
+});
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length);
+        getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len);
+
+    const mem = getUint8Memory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3);
+        const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+
+        offset += ret.written;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+let cachedInt32Memory0 = new Int32Array();
+
+function getInt32Memory0() {
+    if (cachedInt32Memory0.byteLength === 0) {
+        cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
+    }
+    return cachedInt32Memory0;
+}
+
+const cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+function getStringFromWasm0(ptr, len) {
+    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+}
+
+let heap_next = heap.length;
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function dropObject(idx) {
+    if (idx < 36) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+function makeMutClosure(arg0, arg1, dtor, f) {
+    const state = { a: arg0, b: arg1, cnt: 1, dtor };
+    const real = (...args) => {
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            if (--state.cnt === 0) {
+                wasm.__wbindgen_export_2.get(state.dtor)(a, state.b);
+
+            } else {
+                state.a = a;
+            }
+        }
+    };
+    real.original = state;
+
+    return real;
+}
+
+let stack_pointer = 32;
+
+function addBorrowedObject(obj) {
+    if (stack_pointer == 1) throw new Error('out of js stack');
+    heap[--stack_pointer] = obj;
+    return stack_pointer;
+}
+function __wbg_adapter_18(arg0, arg1, arg2) {
+    try {
+        wasm._dyn_core__ops__function__FnMut___A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h9380123c3ed0eddb(arg0, arg1, addBorrowedObject(arg2));
+    } finally {
+        heap[stack_pointer++] = undefined;
+    }
+}
+
+function __wbg_adapter_21(arg0, arg1, arg2) {
+    wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h414630ac9216cad4(arg0, arg1, addHeapObject(arg2));
+}
+
+let cachedUint32Memory0 = new Uint32Array();
+
+function getUint32Memory0() {
+    if (cachedUint32Memory0.byteLength === 0) {
+        cachedUint32Memory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32Memory0;
+}
+
+function getArrayJsValueFromWasm0(ptr, len) {
+    const mem = getUint32Memory0();
+    const slice = mem.subarray(ptr / 4, ptr / 4 + len);
+    const result = [];
+    for (let i = 0; i < slice.length; i++) {
+        result.push(takeObject(slice[i]));
+    }
+    return result;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm.__wbindgen_exn_store(addHeapObject(e));
+    }
+}
+
+async function load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+
+            } catch (e) {
+                if (module.headers.get('Content-Type') != 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else {
+                    throw e;
+                }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+
+        } else {
+            return instance;
+        }
+    }
+}
+
+function getImports() {
+    const imports = {};
+    imports.wbg = {};
+    imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
+        const obj = getObject(arg1);
+        const ret = typeof(obj) === 'string' ? obj : undefined;
+        var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
+        const ret = getStringFromWasm0(arg0, arg1);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
+        const ret = getObject(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_listenerid_12315eee21527820 = function(arg0, arg1) {
+        const ret = getObject(arg1).__yew_listener_id;
+        getInt32Memory0()[arg0 / 4 + 1] = isLikeNone(ret) ? 0 : ret;
+        getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
+    };
+    imports.wbg.__wbg_setlistenerid_3183aae8fa5840fb = function(arg0, arg1) {
+        getObject(arg0).__yew_listener_id = arg1 >>> 0;
+    };
+    imports.wbg.__wbg_subtreeid_e348577f7ef777e3 = function(arg0, arg1) {
+        const ret = getObject(arg1).__yew_subtree_id;
+        getInt32Memory0()[arg0 / 4 + 1] = isLikeNone(ret) ? 0 : ret;
+        getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
+    };
+    imports.wbg.__wbg_setsubtreeid_d32e6327eef1f7fc = function(arg0, arg1) {
+        getObject(arg0).__yew_subtree_id = arg1 >>> 0;
+    };
+    imports.wbg.__wbg_cachekey_b61393159c57fd7b = function(arg0, arg1) {
+        const ret = getObject(arg1).__yew_subtree_cache_key;
+        getInt32Memory0()[arg0 / 4 + 1] = isLikeNone(ret) ? 0 : ret;
+        getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
+    };
+    imports.wbg.__wbg_setcachekey_80183b7cfc421143 = function(arg0, arg1) {
+        getObject(arg0).__yew_subtree_cache_key = arg1 >>> 0;
+    };
+    imports.wbg.__wbg_error_f851667af71bcfc6 = function(arg0, arg1) {
+        try {
+            console.error(getStringFromWasm0(arg0, arg1));
+        } finally {
+            wasm.__wbindgen_free(arg0, arg1);
+        }
+    };
+    imports.wbg.__wbg_new_abda76e883ba8a5f = function() {
+        const ret = new Error();
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_stack_658279fe44541cf6 = function(arg0, arg1) {
+        const ret = getObject(arg1).stack;
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
+        takeObject(arg0);
+    };
+    imports.wbg.__wbindgen_cb_drop = function(arg0) {
+        const obj = takeObject(arg0).original;
+        if (obj.cnt-- == 1) {
+            obj.a = 0;
+            return true;
+        }
+        const ret = false;
+        return ret;
+    };
+    imports.wbg.__wbindgen_is_undefined = function(arg0) {
+        const ret = getObject(arg0) === undefined;
+        return ret;
+    };
+    imports.wbg.__wbg_error_71d6845bf00a930f = function(arg0, arg1) {
+        var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+        wasm.__wbindgen_free(arg0, arg1 * 4);
+        console.error(...v0);
+    };
+    imports.wbg.__wbg_instanceof_Window_acc97ff9f5d2c7b4 = function(arg0) {
+        let result;
+        try {
+            result = getObject(arg0) instanceof Window;
+        } catch {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
+    imports.wbg.__wbg_document_3ead31dbcad65886 = function(arg0) {
+        const ret = getObject(arg0).document;
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_fetch_0fe04905cccfc2aa = function(arg0, arg1) {
+        const ret = getObject(arg0).fetch(getObject(arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_body_3cb4b4042b9a632b = function(arg0) {
+        const ret = getObject(arg0).body;
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_createElement_976dbb84fe1661b5 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).createElement(getStringFromWasm0(arg1, arg2));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_createElementNS_1561aca8ee3693c0 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+        const ret = getObject(arg0).createElementNS(arg1 === 0 ? undefined : getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_createTextNode_300f845fab76642f = function(arg0, arg1, arg2) {
+        const ret = getObject(arg0).createTextNode(getStringFromWasm0(arg1, arg2));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_instanceof_Response_eaa426220848a39e = function(arg0) {
+        let result;
+        try {
+            result = getObject(arg0) instanceof Response;
+        } catch {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
+    imports.wbg.__wbg_text_1169d752cc697903 = function() { return handleError(function (arg0) {
+        const ret = getObject(arg0).text();
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_newwithstrandinit_05d7180788420c40 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = new Request(getStringFromWasm0(arg0, arg1), getObject(arg2));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_instanceof_ShadowRoot_76b32ccdae10a710 = function(arg0) {
+        let result;
+        try {
+            result = getObject(arg0) instanceof ShadowRoot;
+        } catch {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
+    imports.wbg.__wbg_host_57eec05a2624bc1b = function(arg0) {
+        const ret = getObject(arg0).host;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_value_ccb32485ee1b3928 = function(arg0, arg1) {
+        const ret = getObject(arg1).value;
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbg_setvalue_df64bc6794c098f2 = function(arg0, arg1, arg2) {
+        getObject(arg0).value = getStringFromWasm0(arg1, arg2);
+    };
+    imports.wbg.__wbg_setchecked_f1e1f3e62cdca8e7 = function(arg0, arg1) {
+        getObject(arg0).checked = arg1 !== 0;
+    };
+    imports.wbg.__wbg_value_b2a620d34c663701 = function(arg0, arg1) {
+        const ret = getObject(arg1).value;
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbg_setvalue_e5b519cca37d82a7 = function(arg0, arg1, arg2) {
+        getObject(arg0).value = getStringFromWasm0(arg1, arg2);
+    };
+    imports.wbg.__wbg_instanceof_Element_33bd126d58f2021b = function(arg0) {
+        let result;
+        try {
+            result = getObject(arg0) instanceof Element;
+        } catch {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
+    imports.wbg.__wbg_namespaceURI_e19c7be2c60e5b5c = function(arg0, arg1) {
+        const ret = getObject(arg1).namespaceURI;
+        var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbg_setinnerHTML_32081d8a164e6dc4 = function(arg0, arg1, arg2) {
+        getObject(arg0).innerHTML = getStringFromWasm0(arg1, arg2);
+    };
+    imports.wbg.__wbg_outerHTML_bf662bdff92e5910 = function(arg0, arg1) {
+        const ret = getObject(arg1).outerHTML;
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbg_children_67776b4810f38b6a = function(arg0) {
+        const ret = getObject(arg0).children;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_removeAttribute_beaed7727852af78 = function() { return handleError(function (arg0, arg1, arg2) {
+        getObject(arg0).removeAttribute(getStringFromWasm0(arg1, arg2));
+    }, arguments) };
+    imports.wbg.__wbg_setAttribute_d8436c14a59ab1af = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+        getObject(arg0).setAttribute(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+    }, arguments) };
+    imports.wbg.__wbg_bubbles_03eed164b4feeaf1 = function(arg0) {
+        const ret = getObject(arg0).bubbles;
+        return ret;
+    };
+    imports.wbg.__wbg_cancelBubble_8c0bdf21c08f1717 = function(arg0) {
+        const ret = getObject(arg0).cancelBubble;
+        return ret;
+    };
+    imports.wbg.__wbg_composedPath_160ed014dc4d787f = function(arg0) {
+        const ret = getObject(arg0).composedPath();
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_addEventListener_1fc744729ac6dc27 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+        getObject(arg0).addEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3), getObject(arg4));
+    }, arguments) };
+    imports.wbg.__wbg_removeEventListener_b10f1a66647f3aa0 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+        getObject(arg0).removeEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3), arg4 !== 0);
+    }, arguments) };
+    imports.wbg.__wbg_parentNode_e397bbbe28be7b28 = function(arg0) {
+        const ret = getObject(arg0).parentNode;
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_parentElement_0cffb3ceb0f107bd = function(arg0) {
+        const ret = getObject(arg0).parentElement;
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_lastChild_a2f5ed739809bb31 = function(arg0) {
+        const ret = getObject(arg0).lastChild;
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_nextSibling_62338ec2a05607b4 = function(arg0) {
+        const ret = getObject(arg0).nextSibling;
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_setnodeValue_4077cafeefd0725e = function(arg0, arg1, arg2) {
+        getObject(arg0).nodeValue = arg1 === 0 ? undefined : getStringFromWasm0(arg1, arg2);
+    };
+    imports.wbg.__wbg_textContent_77bd294928962f93 = function(arg0, arg1) {
+        const ret = getObject(arg1).textContent;
+        var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbg_appendChild_e513ef0e5098dfdd = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).appendChild(getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_insertBefore_9f2d2defb9471006 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).insertBefore(getObject(arg1), getObject(arg2));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_removeChild_6751e9ca5d9aaf00 = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).removeChild(getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_get_57245cc7d7c7619d = function(arg0, arg1) {
+        const ret = getObject(arg0)[arg1 >>> 0];
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_from_7ce3cb27cb258569 = function(arg0) {
+        const ret = Array.from(getObject(arg0));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_length_6e3bbe7c8bd4dbd8 = function(arg0) {
+        const ret = getObject(arg0).length;
+        return ret;
+    };
+    imports.wbg.__wbg_newnoargs_b5b063fc6c2f0376 = function(arg0, arg1) {
+        const ret = new Function(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_call_97ae9d8645dc388b = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).call(getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_is_40a66842732708e7 = function(arg0, arg1) {
+        const ret = Object.is(getObject(arg0), getObject(arg1));
+        return ret;
+    };
+    imports.wbg.__wbg_new_0b9bfdd97583284e = function() {
+        const ret = new Object();
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_resolve_99fe17964f31ffc0 = function(arg0) {
+        const ret = Promise.resolve(getObject(arg0));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_then_11f7a54d67b4bfad = function(arg0, arg1) {
+        const ret = getObject(arg0).then(getObject(arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_then_cedad20fbbd9418a = function(arg0, arg1, arg2) {
+        const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_globalThis_7f206bda628d5286 = function() { return handleError(function () {
+        const ret = globalThis.globalThis;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_self_6d479506f72c6a71 = function() { return handleError(function () {
+        const ret = self.self;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_window_f2557cc78490aceb = function() { return handleError(function () {
+        const ret = window.window;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_global_ba75c50d1cf384f4 = function() { return handleError(function () {
+        const ret = global.global;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_set_bf3f89b92d5a34bf = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
+        const ret = debugString(getObject(arg1));
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbindgen_closure_wrapper3975 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 302, __wbg_adapter_18);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_closure_wrapper6639 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 329, __wbg_adapter_21);
+        return addHeapObject(ret);
+    };
+
+    return imports;
+}
+
+function initMemory(imports, maybe_memory) {
+
+}
+
+function finalizeInit(instance, module) {
+    wasm = instance.exports;
+    init.__wbindgen_wasm_module = module;
+    cachedInt32Memory0 = new Int32Array();
+    cachedUint32Memory0 = new Uint32Array();
+    cachedUint8Memory0 = new Uint8Array();
+
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+function initSync(module) {
+    const imports = getImports();
+
+    initMemory(imports);
+
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+
+    const instance = new WebAssembly.Instance(module, imports);
+
+    return finalizeInit(instance, module);
+}
+
+async function init(input) {
+    if (typeof input === 'undefined') {
+        input = new URL('db-frontend-12bfbd74b2a545ed_bg.wasm', import.meta.url);
+    }
+    const imports = getImports();
+
+    if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
+        input = fetch(input);
+    }
+
+    initMemory(imports);
+
+    const { instance, module } = await load(await input, imports);
+
+    return finalizeInit(instance, module);
+}
+
+export { initSync }
+export default init;

frontend/dist/index.html

@@ -0,0 +1,35 @@
+<!DOCTYPE html><html><head>
+        <meta charset="utf-8">
+        <title>Ze greatest</title>
+    
+<link rel="preload" href="/db-frontend-12bfbd74b2a545ed_bg.wasm" as="fetch" type="application/wasm" crossorigin="">
+<link rel="modulepreload" href="/db-frontend-12bfbd74b2a545ed.js"></head>
+<body>
+<script type="module">import init from '/db-frontend-12bfbd74b2a545ed.js';init('/db-frontend-12bfbd74b2a545ed_bg.wasm');</script><script>(function () {
+    var protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+    var url = protocol + '//' + window.location.host + '/_trunk/ws';
+    var poll_interval = 5000;
+    var reload_upon_connect = () => {
+        window.setTimeout(
+            () => {
+                // when we successfully reconnect, we'll force a
+                // reload (since we presumably lost connection to
+                // trunk due to it being killed, so it will have
+                // rebuilt on restart)
+                var ws = new WebSocket(url);
+                ws.onopen = () => window.location.reload();
+                ws.onclose = reload_upon_connect;
+            },
+            poll_interval);
+    };
+
+    var ws = new WebSocket(url);
+    ws.onmessage = (ev) => {
+        const msg = JSON.parse(ev.data);
+        if (msg.reload) {
+            window.location.reload();
+        }
+    };
+    ws.onclose = reload_upon_connect;
+})()
+</script></body></html>

frontend/src/fetching.rs

@@ -0,0 +1,245 @@
+use common::{CommonAdmin, CommonDriver};
+use std::{
+    error::Error,
+    fmt::{self, Debug, Display, Formatter},
+};
+use wasm_bindgen::{JsCast, JsValue};
+use wasm_bindgen_futures::JsFuture;
+use web_sys::{Request, RequestInit, RequestMode, Response};
+use yew::props;
+use yew::{html, Component, Context, Html, Properties};
+//Trait to handle Future yew HTMLS
+pub trait UseAble {
+    //Return  HTML if didn't fail return error if not
+    fn use_it(self) -> Result<Html, String>;
+}
+impl UseAble for CommonDriver {
+    fn use_it(self) -> Result<Html, String> {
+        let name = self.name;
+        let address = self.address;
+        let id = self.id;
+        let html = html! {
+            <div>
+                <h2> { "Driver:" } </h2>
+                <p> { format!("Name: {}", name) } </p>
+                <p> { format!("Address: {}", address) } </p>
+                <p> { format!("ID: {}", id) } </p>
+            </div>
+        };
+        Ok(html)
+    }
+}
+impl UseAble for CommonAdmin {
+    fn use_it(self) -> Result<Html, String> {
+        let name = self.name;
+        let address = self.address;
+        let id = self.id;
+        let html = html! {
+            <div>
+                <h2> { "Admin:" } </h2>
+                <p> { format!("Name: {}", name) } </p>
+                <p> { format!("Address: {}", address) } </p>
+                <p> { format!("ID: {}", id) } </p>
+            </div>
+        };
+        Ok(html)
+    }
+}
+
+//Wwasm bingdengen code
+const DRIVER_URL: &str = "http://db.sewelam.tech/api/driver/50";
+const ADMIN_URL: &str = "http://db.sewelam.tech/api/admin/";
+const TICKET_URL: &str = "http://db.sewelam.tech/api/ticket/";
+const FUNNY_TXT_URL: &str = "https://whatthecommit.com/index.txt";
+const INCORRECT_URL: &str = "http://libkyy.cf";
+//Generic Msg for our states
+pub enum Msg<T> {
+    SetDataFetchState(FetchState<T>),
+    GetData,
+    GetError,
+}
+pub struct RandomCommit {
+    commit: FetchState<String>,
+}
+//This trait is for all yew components
+impl Component for RandomCommit {
+    type Message = Msg<String>;
+    type Properties = ();
+    fn create(_ctx: &Context<Self>) -> Self {
+        Self {
+            commit: FetchState::NotFetching, //Default state is not fetching anything
+        }
+    }
+
+    fn update(&mut self, ctx: &Context<Self>, msg: Self::Message) -> bool {
+        match msg {
+            Msg::SetDataFetchState(fetch_state) => {
+                self.commit = fetch_state;
+                true
+            }
+            Msg::GetData => {
+                ctx.link().send_future(async {
+                    match fetch_url_text(FUNNY_TXT_URL).await {
+                        Ok(commit) => Msg::SetDataFetchState(FetchState::Success(commit)),
+                        Err(err) => Msg::SetDataFetchState(FetchState::Failed(err)),
+                    }
+                });
+                ctx.link()
+                    .send_message(Msg::SetDataFetchState(FetchState::Fetching));
+                false
+            }
+            Msg::GetError => {
+                ctx.link().send_future(async {
+                    match fetch_url_text(INCORRECT_URL).await {
+                        Ok(commit) => Msg::SetDataFetchState(FetchState::Success(commit)),
+                        Err(err) => Msg::SetDataFetchState(FetchState::Failed(err)),
+                    }
+                });
+                ctx.link()
+                    .send_message(Msg::SetDataFetchState(FetchState::Fetching));
+                false
+            }
+        }
+    }
+
+    fn view(&self, ctx: &Context<Self>) -> Html {
+        match &self.commit {
+            FetchState::NotFetching => html! {
+                <>
+                    <button onclick={ctx.link().callback(|_| Msg::GetData)}>
+                        { "Get commit msg" }
+                    </button>
+                </>
+            },
+            FetchState::Fetching => html! { "Fetching" },
+            FetchState::Success(data) => {
+                html! { <> {data}</> }
+            }
+            FetchState::Failed(err) => html! { err },
+        }
+    }
+}
+//Generate Struct and implement component for driver using CommonDriver
+pub struct DriverComponent {
+    driver: FetchState<String>,
+}
+
+#[derive(Default, Properties, PartialEq)]
+pub struct ApiParams {
+    pub entered_id: i32,
+}
+impl ApiParams {
+    pub fn new_api_thingy_with_id(id: i32) -> Self {
+        props! { ApiParams {
+            entered_id: id
+        }}
+    }
+}
+//implement the component for Driver using a string
+impl Component for DriverComponent {
+    type Message = Msg<String>;
+    type Properties = ApiParams;
+    fn create(_ctx: &Context<Self>) -> Self {
+        Self {
+            driver: FetchState::NotFetching,
+        }
+    }
+
+    fn update(&mut self, ctx: &Context<Self>, msg: Self::Message) -> bool {
+        match msg {
+            Msg::SetDataFetchState(fetch_state) => {
+                self.driver = fetch_state;
+                true
+            }
+            Msg::GetData => {
+                ctx.link().send_future(async {
+                    match fetch_url_text(DRIVER_URL).await {
+                        Ok(driver) => Msg::SetDataFetchState(FetchState::Success(driver)),
+                        Err(err) => Msg::SetDataFetchState(FetchState::Failed(err)),
+                    }
+                });
+                ctx.link()
+                    .send_message(Msg::SetDataFetchState(FetchState::Fetching));
+                false
+            }
+            Msg::GetError => {
+                ctx.link().send_future(async {
+                    match fetch_url_text(INCORRECT_URL).await {
+                        Ok(driver) => Msg::SetDataFetchState(FetchState::Success(driver)),
+                        Err(err) => Msg::SetDataFetchState(FetchState::Failed(err)),
+                    }
+                });
+                ctx.link()
+                    .send_message(Msg::SetDataFetchState(FetchState::Fetching));
+                false
+            }
+        }
+    }
+
+    fn view(&self, ctx: &Context<Self>) -> Html {
+        match &self.driver {
+            FetchState::NotFetching => html! {
+                <>
+
+                    <label for="id"> {"ID:"} </label>
+                    <input type="text" id="name" name="name"/>
+
+                    <br/>
+                    <button onclick={ctx.link().callback(|_| Msg::GetData)}>
+                        { "Get driver" }
+                    </button>
+                </>
+            },
+            FetchState::Fetching => html! { "Fetching" },
+            FetchState::Success(data) => html! { <> {data} <br/>
+                <button onclick={ctx.link().callback(|_| Msg::GetData)}>
+                    { "Get new driver (assuming input works :D)" }
+                </button>
+            </> },
+            FetchState::Failed(err) => html! { err },
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct FetchError {
+    err: JsValue,
+}
+
+impl Display for FetchError {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        Debug::fmt(&self.err, f)
+    }
+}
+
+impl Error for FetchError {}
+
+impl From<JsValue> for FetchError {
+    fn from(value: JsValue) -> Self {
+        Self { err: value }
+    }
+}
+//Enum for Fetchstates that takes a generic type --> String/Driver etc.
+pub enum FetchState<T> {
+    NotFetching,
+    Fetching,
+    Success(T),
+    Failed(FetchError),
+}
+
+async fn fetch_url_text(url: &'static str) -> Result<String, FetchError> {
+    let mut opts = RequestInit::new();
+    opts.method("GET");
+    opts.mode(RequestMode::Cors); //Cors is required for fetch to work
+
+    //initialise request
+    let request = Request::new_with_str_and_init(url, &opts)?;
+    let window = gloo::utils::window();
+    let resp_value = JsFuture::from(window.fetch_with_request(&request)).await?;
+    let resp: Response = resp_value.dyn_into().unwrap();
+    let text = JsFuture::from(resp.text()?).await?;
+    Ok(text.as_string().unwrap())
+}
+
+//Admin component 
+

frontend/src/main.rs

@@ -1,60 +1,20 @@
+mod fetching;
 use yew::prelude::*;
-use common::CommonTicket;
+
+use crate::fetching::DriverComponent;
+
 #[function_component]
 fn App() -> Html {
-    let counter = use_state(|| 0);
+    let entered_id = 50;
-    let onclick = {
-        let counter = counter.clone();
-        move |_| {
-            let value = *counter + 1;
-            counter.set(value);
-        }
-    };
-
-let stdnts = vec! [
-    Stdnt {
-        id: 1,
-        name: "Hamada".to_string(),
-        email: "Hamada@Gmail.com".to_string(),
-        gpa: 3.4
-    },
-    Stdnt {
-        id: 2,
-        name: "Gamal".to_string(),
-        email: "Gamal@Gmail.com".to_string(),
-        gpa: 4.0
-    },
-    Stdnt {
-        id: 3,
-        name: "Joe".to_string(),
-        email: "joe@proton.mail".to_string(),
-        gpa: 3.8
-    }
-];
-let stdnts_comp = stdnts.iter().map(|stdnt| html! {
-    <>
-    <p key={stdnt.id}>{format!("Name: {}", stdnt.name)} </p>
-    <p key={stdnt.id}>{format!("Email: {}", stdnt.email)} </p>
-    <p key={stdnt.id}>{format!("GPA: {}",stdnt.gpa)} </p>
-    <br/>
-    </>
-}).collect::<Html>();
-
     html! {
         <div>
-            <button {onclick}>{ "+1" }</button>
+            <h1> {"API response examples"} </h1>
-            <p>{ *counter }</p>
+            <h2> {"Drivers"} </h2>
-            <h2> { "Students:" } </h2>
+            <DriverComponent {entered_id}/>
-            <p> { stdnts_comp } </p>
+            <h2> {"Admins and Tickets" } </h2>
         </div>
     }
 }
-struct Stdnt {
-    id: usize,
-    name: String,
-    gpa: f32,
-    email: String,
-}
 
 fn main() {
     yew::Renderer::<App>::new().render();

frontend/src/shadowrealm.rs

@@ -0,0 +1,85 @@
+// impl Component for Driver {
+//     type Message = Msg<CommonDriver>;
+//     type Properties = ();
+//     fn create(_ctx: &Context<Self>) -> Self {
+//         Self {
+//             driver: FetchState::NotFetching, //Default state is not fetching anything
+//         }
+//     }
+//
+//     fn update(&mut self, ctx: &Context<Self>, msg: Self::Message) -> bool {
+//         match msg {
+//             Msg::SetDataFetchState(fetch_state) => {
+//                 self.driver = fetch_state;
+//                 true
+//             }
+//             Msg::GetData => {
+//                 ctx.link().send_future(async {
+//                     match fetch_driver(DRIVER_URL).await {
+//                         Ok(driver) => Msg::SetDataFetchState(FetchState::Success(driver)),
+//                         Err(err) => Msg::SetDataFetchState(FetchState::Failed(err)),
+//                     }
+//                 });
+//                 ctx.link()
+//                     .send_message(Msg::SetDataFetchState(FetchState::Fetching));
+//                 false
+//             }
+//             Msg::GetError => {
+//                 ctx.link().send_future(async {
+//                     match fetch_driver(INCORRECT_URL).await {
+//                         Ok(driver) => Msg::SetDataFetchState(FetchState::Success(driver)),
+//                         Err(err) => Msg::SetDataFetchState(FetchState::Failed(err)),
+//                     }
+//                 });
+//                 ctx.link()
+//                     .send_message(Msg::SetDataFetchState(FetchState::Fetching));
+//                 false
+//             }
+//         }
+//     }
+//
+//     fn view(&self, ctx: &Context<Self>) -> Html {
+//         //render the component into HTML
+//         match &self.driver {
+//             FetchState::NotFetching => html! {
+//                 <>
+//                     <button onclick={ctx.link().callback(|_| Msg::GetData)}>
+//                         { "Get driver info" }
+//                     </button>
+//                     <button onclick={ctx.link().callback(|_| Msg::GetError)}>
+//                         { "Get using incorrect URL" }
+//                     </button>
+//                 </>
+//             },
+//             FetchState::Fetching => html! { "Fetching" },
+//             FetchState::Success(data) => match data.clone().use_it() {
+//                 Ok(html) => html,
+//                 Err(err) => html! { err },
+//             },
+//             FetchState::Failed(err) => html! { err },
+//         }
+//     }
+// }
+// async fn fetch_driver(url: &'static str) -> Result<CommonDriver, FetchError> {
+//     let mut opts = RequestInit::new();
+//     opts.method("GET");
+//     //Available request modes: Cors, NoCors, SameOrigin
+//     opts.mode(RequestMode::NoCors); //NoCors because cors simply doesn't work here
+//
+//     let request = Request::new_with_str_and_init(url, &opts)?;
+//     //api header for json
+//     request.headers().set("Accept", "application/json")?;
+//
+//     let window = web_sys::window().unwrap();
+//     let resp_value = JsFuture::from(window.fetch_with_request(&request)).await?;
+//     assert!(resp_value.is_instance_of::<Response>());
+//     let resp: Response = resp_value.dyn_into().unwrap();
+//
+//     //parsing Json response
+//     let fetched_json = JsFuture::from(resp.json()?).await?;
+//     log!(fetched_json.clone());
+//     let fetched_json: JsValue = fetched_json.into();
+//     //parsing into CommonDriver struct
+//     let fetched_json: CommonDriver = fetched_json.into_serde().unwrap();
+//     Ok(fetched_json)
+// }

src/api.rs

@@ -0,0 +1,98 @@
+use actix_web::{get, http::header::ContentType, web, HttpResponse, Responder};
+use backend::{
+    admin_data::get_admin, driver_data::get_driver, establish_connection, ticket_data::get_ticket,
+    vehicle_data::get_vehicle,
+};
+// use common::{CommonAdmin, CommonDriver, CommonTicket};
+
+#[get("api/ticket/{id}")]
+async fn api_ticket(id: web::Path<i32>) -> impl Responder {
+    let fetched_ticket_data = get_ticket(&mut establish_connection(), *id);
+    //return struct values as string
+    HttpResponse::Ok()
+        .content_type(ContentType::plaintext())
+        .insert_header(("Access-Control-Allow-Origin", "*"))
+        .insert_header(("content-type", "text/plain"))
+        .insert_header(("content-encoded", "gzip"))
+        .insert_header((
+            "Access-Control-Allow-Headers",
+            "Content-Type, Content-Length, User-Agent, X-Requested-With, Range, DNT ",
+        ))
+        .body(format!(
+            "Ticket ID: {}, Ticket Price: {}, Ticket Status: {}",
+            fetched_ticket_data.id, fetched_ticket_data.category, fetched_ticket_data.description
+        ))
+}
+
+// Getting admin data or smth idk
+#[get("api/admin/{id}")]
+async fn api_admin(id: web::Path<i32>) -> impl Responder {
+    let fetched_admin_data = get_admin(&mut establish_connection(), *id);
+    //return struct values as string
+    HttpResponse::Ok()
+        .content_type(ContentType::plaintext())
+        .insert_header(("Access-Control-Allow-Origin", "*"))
+        .insert_header(("content-type", "text/plain"))
+        .insert_header(("content-encoded", "gzip"))
+        .insert_header((
+            "Access-Control-Allow-Headers",
+            "Content-Type, Content-Length, User-Agent, X-Requested-With, Range, DNT ",
+        ))
+        .body(format!(
+            "Admin ID: {}, Admin Name: {}, Admin Address: {}",
+            fetched_admin_data.id, fetched_admin_data.name, fetched_admin_data.address
+        ))
+}
+
+#[get("api/driver/{id}")]
+async fn api_driver(id: web::Path<i32>) -> impl Responder {
+    let fetched_driver_data = get_driver(&mut establish_connection(), *id);
+    HttpResponse::Ok()
+        .content_type(ContentType::plaintext())
+        //headers for plain text
+        .insert_header(("Access-Control-Allow-Origin", "*"))
+        .insert_header(("content-type", "text/plain"))
+        .insert_header(("content-encoded", "gzip"))
+        .insert_header((
+            "Access-Control-Allow-Headers",
+            "Content-Type, Content-Length, User-Agent, X-Requested-With, Range, DNT ",
+        ))
+        .body(format!(
+            "Driver ID: {}, Driver Name: {}, Driver Address: {}",
+            fetched_driver_data.id, fetched_driver_data.name, fetched_driver_data.address
+        ))
+}
+
+#[get("api/test")]
+async fn api_test() -> impl Responder {
+    HttpResponse::Ok()
+        .content_type(ContentType::plaintext())
+        .insert_header(("Access-Control-Allow-Origin", "*"))
+        .insert_header(("Access-Control-Allow-Methods", "GET"))
+        .insert_header((
+            "Access-Control-Allow-Headers",
+            "Content-Type, Content-Length, User-Agent, X-Requested-With, Range, DNT ",
+        ))
+        .insert_header(("content-type", "text/plain"))
+        .insert_header(("content-encoded", "gzip"))
+        .body("Alles gut")
+}
+
+#[get("api/vehicle/{id}")]
+async fn api_vehicle(id: web::Path<String>) -> impl Responder {
+    let id = id.into_inner();
+    let fetched_vehicle_data = get_vehicle(&mut establish_connection(), id);
+    HttpResponse::Ok()
+        .content_type(ContentType::plaintext())
+        .insert_header(("Access-Control-Allow-Origin", "*"))
+        .insert_header(("content-type", "text/plain"))
+        .insert_header(("content-encoded", "gzip"))
+        .insert_header((
+            "Access-Control-Allow-Headers",
+            "Content-Type, Content-Length, User-Agent, X-Requested-With, Range, DNT ",
+        ))
+        .body(format!(
+            "Vehicle ID: {}, Vehicle Category: {}",
+            fetched_vehicle_data.plate_num, fetched_vehicle_data.category
+        ))
+}

src/main.rs

@@ -1,46 +1,25 @@
-use actix_web::{
+pub mod api;
-    get,
+pub mod shadowrealmapi;
-    web::{self, Json},
+use crate::api::*;
-    App, HttpServer,
+use crate::shadowrealmapi::*;
-};
+pub(crate) use actix_web::{App, HttpServer};
-use backend::{establish_connection, admin_data::get_admin, ticket_data::get_ticket, driver_data::get_driver};
-use common::CommonAdmin;
-use common::CommonTicket;
-use common::CommonDriver;
-
-// //Admin Services
-// #[get("/api/admin/{id}")]
-// async fn admin(id: web::Path<i32>) -> Json<CommonAdmin> {
-//     Json(get_admin(&mut establish_connection(), *id))
-// }
-// #[get("/api/admins{amount}")]
-// async fn admins(amount: web::Path<i64>) -> Json<Vec<CommonAdmin>> {
-//     Json(get_admins(&mut establish_connection(), *amount))
-// }
-
-//Ticket Table Services
-#[get("api/ticket/{id}")]
-async fn api_ticket(id: web::Path<i32>) -> Json<CommonTicket> {
-    let fetched_ticket_data = get_ticket(&mut establish_connection(), *id);
-    Json(fetched_ticket_data)
-}
-
-// Getting admin data or smth idk
-#[get("api/admin/{id}")]
-async fn api_admin(id: web::Path<i32>) -> Json<CommonAdmin> {
-    let fetched_admin_data = get_admin(&mut establish_connection(), *id);
-    Json(fetched_admin_data)
-}
-
-#[get("api/driver/{id}")]
-async fn api_driver(id: web::Path<i32>) -> Json<CommonDriver> {
-    let fetched_driver_data = get_driver(&mut establish_connection(), *id);
-    Json(fetched_driver_data)
-}
 
+//Main function where all the api calls are
+//attached as services to backend
 #[actix_web::main]
 async fn main() -> std::io::Result<()> {
-    HttpServer::new(|| App::new().service(api_ticket).service(api_admin).service(api_driver))
+    HttpServer::new(|| {
+        App::new()
+            .service(api_ticket)
+            .service(api_admin)
+            .service(api_driver)
+            .service(api_json_ticket)
+            .service(api_json_admin)
+            .service(api_json_driver)
+            .service(api_test)
+            .service(api_json_driver_tickets)
+            .service(api_json_ticket_new)
+    })
     .bind(("0.0.0.0", 48590))?
     .run()
     .await

src/shadowrealmapi.rs

@@ -0,0 +1,79 @@
+use actix_web::{
+    get,
+    http::header::ContentType,
+    post,
+    web::{self, Json},
+    HttpResponse, Responder,
+};
+use backend::{
+    admin_data::get_admin,
+    driver_data::get_driver,
+    establish_connection,
+    models::NewTicket,
+    ticket_data::{create_ticket, get_ticket, get_tickets},
+};
+use common::{CommonAdmin, CommonDriver, CommonTicket};
+
+// Json goodies? NAHH
+// Ticket Table Services
+#[get("api/json/ticket/{id}")]
+async fn api_json_ticket(id: web::Path<i32>) -> impl Responder {
+    let fetched_ticket_data = get_ticket(&mut establish_connection(), *id);
+    HttpResponse::Ok()
+        .content_type(ContentType::json())
+        .insert_header(("Access-Control-Allow-Origin", "*"))
+        .insert_header(("content-encoded", "gzip"))
+        .insert_header((
+            "Access-Control-Allow-Headers",
+            "Content-Type, Content-Length, User-Agent, X-Requested-With, Range, DNT ",
+        ))
+        .json(fetched_ticket_data)
+}
+#[post("api/json/ticket/new")]
+async fn api_json_ticket_new(ticket: web::Json<CommonTicket>) -> impl Responder {
+    let input = ticket.into_inner();
+    let input_result = NewTicket {
+        id: input.id,
+        description: &input.description,
+        category: &input.category,
+    };
+    create_ticket(&mut establish_connection(), input_result);
+    HttpResponse::Ok()
+        .content_type(ContentType::plaintext())
+        .insert_header(("Access-Control-Allow-Origin", "*"))
+        .insert_header(("Access-Control-Allow-Methods", "GET"))
+        .insert_header((
+            "Access-Control-Allow-Headers",
+            "Content-Type, Content-Length, User-Agent, X-Requested-With, Range, DNT ",
+        ))
+        .insert_header(("content-type", "text/plain"))
+        .insert_header(("content-encoded", "gzip"))
+        .body("Alles gut")
+}
+
+// Getting admin data or smth idk
+#[get("api/json/admin/{id}")]
+async fn api_json_admin(id: web::Path<i32>) -> Json<CommonAdmin> {
+    let fetched_admin_data = get_admin(&mut establish_connection(), *id);
+    Json(fetched_admin_data)
+}
+
+#[get("api/json/driver/{id}")]
+async fn api_json_driver(id: web::Path<i32>) -> Json<CommonDriver> {
+    let fetched_driver_data = get_driver(&mut establish_connection(), *id);
+    Json(fetched_driver_data)
+}
+
+#[get("api/json/tickets/{driver}")]
+async fn api_json_driver_tickets(id: web::Path<i32>) -> impl Responder {
+    let fetched_tickets = get_tickets(&mut establish_connection(), *id);
+    HttpResponse::Ok()
+        .content_type(ContentType::json())
+        .insert_header(("Access-Control-Allow-Origin", "*"))
+        .insert_header(("content-encoded", "gzip"))
+        .insert_header((
+            "Access-Control-Allow-Headers",
+            "Content-Type, Content-Length, User-Agent, X-Requested-With, Range, DNT ",
+        ))
+        .json(fetched_tickets)
+}