Add device service

api/src/device/client.rs

@@ -0,0 +1,53 @@
+extern crate rocket;
+use std::error::Error;
+
+use storage::database::DatabaseClient;
+
+pub struct DevicesClient {
+    database: DatabaseClient,
+}
+
+impl DevicesClient {
+    pub async fn new(
+        database_url: &str
+    ) -> Self {
+        let database = DatabaseClient::new(database_url);
+        Self {
+            database,
+        }
+    }
+
+    pub fn add_device(&mut self, device: primitives::device::Device) -> Result<primitives::device::Device, Box<dyn Error>> {
+        let device_id = device.id.clone();
+        let add_device = self.map_device(device);
+        let _ = self.database.add_device(add_device)?;
+        return self.get_device(device_id.as_str());
+    }
+
+    pub fn get_device(&mut self, device_id: &str) -> Result<primitives::device::Device, Box<dyn Error>> {
+        let device = self.database.get_device(device_id.to_string())?;
+        Ok(
+            primitives::device::Device { 
+                id: device.device_id, 
+                platform: device.platform,
+                token: device.token,
+                is_push_enabled: device.is_push_enabled,
+            }
+        )
+    }
+    pub fn update_device(&mut self, device: primitives::device::Device) -> Result<primitives::device::Device, Box<dyn Error>> {
+        let device_id = device.id.clone();
+        let update_device = self.map_device(device);
+        let _ = self.database.update_device(update_device)?;
+        return self.get_device(device_id.as_str());
+    }
+
+    pub fn map_device(&self, device: primitives::device::Device) -> storage::models::Device {
+        return storage::models::Device {
+            device_id: device.id,
+            platform: device.platform,
+            token: device.token,
+            is_push_enabled: device.is_push_enabled,
+        };
+    }
+}

api/src/device/mod.rs

@@ -0,0 +1,37 @@
+extern crate rocket;
+use primitives::device::Device;
+use rocket::serde::json::Json;
+use self::client::DevicesClient;
+use rocket::State;
+use rocket::tokio::sync::Mutex;
+
+pub mod client;
+
+#[post("/devices", format = "json", data = "<device>")]
+pub async fn add_device(
+    device: Json<Device>, 
+    client: &State<Mutex<DevicesClient>>,
+) -> Json<Device> {
+    let device = client.lock().await.add_device(device.0).unwrap();
+    Json(device)
+}
+
+#[get("/devices/<device_id>")]
+pub async fn get_device(
+    device_id: &str,
+    client: &State<Mutex<DevicesClient>>,
+) -> Json<Device> {
+    let device = client.lock().await.get_device(device_id).unwrap();
+    Json(device)
+}
+
+#[put("/devices/<device_id>", format = "json", data = "<device>")]
+pub async fn update_device(
+    device: Json<Device>, 
+    #[allow(unused)]
+    device_id: &str,
+    client: &State<Mutex<DevicesClient>>,
+) -> Json<Device> {
+    let device = client.lock().await.update_device(device.0).unwrap();
+    Json(device)
+}

api/src/main.rs

@@ -10,6 +10,7 @@ mod config_client;
 mod plausible_client;
 mod name;
 mod charts;
+mod device;
 
 use fiat::mercuryo::MercuryoClient;
 use fiat::moonpay::MoonPayClient;
@@ -25,6 +26,7 @@ use config_client::Client as ConfigClient;
 use plausible_client:: Client as PlausibleClient;
 use storage::database::DatabaseClient as DatabaseClient;
 use name_resolver::client::Client as NameClient;
+use device::client::DevicesClient;
 use rocket::tokio::sync::Mutex;
 use rocket_prometheus::PrometheusMetrics;
 
@@ -46,11 +48,12 @@ async fn rocket(settings: Settings) -> Rocket<Build> {
         settings.name.tree.url,
         settings.name.spaceid.url,
     );
+    let devices_client = DevicesClient::new(postgres_url).await;
     let plausible_client = PlausibleClient::new(&settings.plausible.url);
     let request_client = FiatClient::request_client(settings.fiat.timeout);
     let transak = TransakClient::new(request_client.clone(), settings.transak.key.public);
     let moonpay = MoonPayClient::new( request_client.clone(),  settings.moonpay.key.public,  settings.moonpay.key.secret);
-    let mercuryo = MercuryoClient::new(request_client.clone(), settings.mercuryo.key.public);
+    let mercuryo = MercuryoClient::new(request_client.clone(),  settings.mercuryo.key.public);
     let ramp = RampClient::new(request_client.clone(), settings.ramp.key.public);
     let fiat_client = FiatClient::new(
         postgres_url,
@@ -76,6 +79,7 @@ async fn rocket(settings: Settings) -> Rocket<Build> {
         .manage(Mutex::new(config_client))
         .manage(Mutex::new(plausible_client))
         .manage(Mutex::new(name_client))
+        .manage(Mutex::new(devices_client))        
         .mount("/", routes![
             status::get_status,
         ])
@@ -89,6 +93,9 @@ async fn rocket(settings: Settings) -> Rocket<Build> {
             nodes::get_nodes,
             config::get_config,
             name::get_name_resolve,
+            device::add_device,
+            device::get_device,
+            device::update_device,
         ])
         .mount(settings.metrics.path, prometheus)
 }

primitives/src/device.rs

@@ -0,0 +1,12 @@
+use typeshare::typeshare;
+use serde::{Serialize, Deserialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[typeshare(swift="Codable")]
+#[serde(rename_all = "camelCase")]
+pub struct Device {
+    pub id: String,
+    pub platform: i32,
+    pub token: String,
+    pub is_push_enabled: bool,
+}

primitives/src/lib.rs

@@ -16,4 +16,5 @@ pub mod fiat_quote;
 pub mod fiat_assets;
 pub mod fiat_provider;
 pub mod fiat_quote_request;
-pub mod platform;
+pub mod platform;
+pub mod device;

storage/src/database.rs

@@ -6,6 +6,7 @@ use diesel::prelude::*;
 use diesel_migrations::{embed_migrations, EmbeddedMigrations, MigrationHarness};
 pub const MIGRATIONS: EmbeddedMigrations = embed_migrations!("../storage/src/migrations");
 use primitives::asset_price::ChartPeriod;
+
 pub struct DatabaseClient {
     connection: PgConnection,
 }
@@ -193,6 +194,34 @@ impl DatabaseClient {
             .execute(&mut self.connection)
     }
 
+    pub fn add_device(&mut self, device: Device) -> Result<usize, diesel::result::Error> {
+        use crate::schema::devices::dsl::*;
+            diesel::insert_into(devices)
+            .values(device)
+            .execute(&mut self.connection)
+    }
+
+    pub fn get_device(&mut self, _device_id: String) -> Result<Device, diesel::result::Error> {
+        use crate::schema::devices::dsl::*;
+        devices
+            .filter(device_id.eq(_device_id))
+            .select(Device::as_select())
+            .first(&mut self.connection)
+    }
+
+    pub fn update_device(&mut self, device: Device) -> Result<usize, diesel::result::Error> {
+        use crate::schema::devices::dsl::*;
+            diesel::insert_into(devices)
+            .values(device)
+            .on_conflict(device_id)
+            .do_update()
+            .set((
+                token.eq(excluded(token)),
+                is_push_enabled.eq(excluded(is_push_enabled)),
+            ))
+            .execute(&mut self.connection)
+    }
+
     pub fn migrations(&mut self) {
         self.connection.run_pending_migrations(MIGRATIONS).unwrap();
     }

storage/src/migrations/2023-09-03-192926_devices/down.sql

@@ -0,0 +1 @@
+drop table devices;

storage/src/migrations/2023-09-03-192926_devices/up.sql

@@ -0,0 +1,14 @@
+CREATE TABLE devices (
+    id SERIAL PRIMARY KEY,
+    device_id VARCHAR NOT NULL,
+    is_push_enabled boolean NOT NULL,
+    platform INTEGER NOT NULL,
+    token VARCHAR NOT NULL,
+    updated_at timestamp NOT NULL default current_timestamp,
+    created_at timestamp NOT NULL default current_timestamp,
+    UNIQUE(device_id)
+);
+
+CREATE INDEX devices_token_idx ON devices (token);
+
+SELECT diesel_manage_updated_at('devices');

storage/src/models.rs

@@ -145,4 +145,14 @@ impl Price {
             volume: self.total_volume,
         }
     }
+}
+
+#[derive(Debug, Queryable, Selectable, Serialize, Deserialize, Insertable, AsChangeset, Clone)]
+#[diesel(table_name = crate::schema::devices)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+pub struct Device {
+    pub device_id: String,
+    pub platform: i32,
+    pub token: String,  
+    pub is_push_enabled: bool,
 }

storage/src/schema.rs

@@ -11,6 +11,18 @@ diesel::table! {
     }
 }
 
+diesel::table! {
+    devices (id) {
+        id -> Int4,
+        device_id -> Varchar,
+        is_push_enabled -> Bool,
+        platform -> Int4,
+        token -> Varchar,
+        updated_at -> Timestamp,
+        created_at -> Timestamp,
+    }
+}
+
 diesel::table! {
     fiat_assets (id) {
         id -> Int4,
@@ -78,6 +90,7 @@ diesel::table! {
 
 diesel::allow_tables_to_appear_in_same_query!(
     charts,
+    devices,
     fiat_assets,
     fiat_rates,
     nodes,