added method for oracle,price,order_history

Author: nagarajm22

lib/ain-ocean/src/data_acces/oracle_price_aggregated.rs

@@ -1,9 +1,12 @@
+use crate::database::db_manger::ColumnFamilyOperations;
 use crate::database::db_manger::RocksDB;
 use crate::model::oracle_price_aggregated::OraclePriceAggregated;
 use anyhow::{anyhow, Result};
 use serde::{Deserialize, Serialize};
 
-pub struct OraclePriceAggrigatedDb {}
+pub struct OraclePriceAggrigatedDb {
+    pub db: RocksDB,
+}
 
 impl OraclePriceAggrigatedDb {
     pub async fn query(
@@ -15,12 +18,26 @@ impl OraclePriceAggrigatedDb {
         todo!()
     }
     pub async fn put(&self, oracle: OraclePriceAggregated) -> Result<()> {
-        todo!()
+        match serde_json::to_string(&oracle) {
+            Ok(value) => {
+                let key = oracle.id.clone();
+                self.db
+                    .put("oracle_price_aggregated", key.as_bytes(), value.as_bytes())?;
+                Ok(())
+            }
+            Err(e) => Err(anyhow!(e)),
+        }
     }
-    pub async fn get(&self, id: String) -> Result<OraclePriceAggregated> {
-        todo!()
+    pub async fn get(&self, id: String) -> Option<OraclePriceAggregated> {
+        match self.db.get("oracle_price_aggregated", id.as_bytes()) {
+            Ok(Some(value)) => serde_json::from_slice(&value).ok(),
+            _ => None,
+        }
     }
     pub async fn delete(&self, id: String) -> Result<()> {
-        todo!()
+        match self.db.delete("oracle_price_aggregated", id.as_bytes()) {
+            Ok(_) => Ok(()),
+            Err(e) => Err(anyhow!(e)),
+        }
     }
 }

lib/ain-ocean/src/data_acces/oracle_price_aggregated_interval.rs

@@ -1,9 +1,12 @@
+use crate::database::db_manger::ColumnFamilyOperations;
 use crate::database::db_manger::RocksDB;
 use crate::model::oracle_price_aggregated_interval::OraclePriceAggregatedInterval;
 use anyhow::{anyhow, Result};
 use serde::{Deserialize, Serialize};
 
-pub struct OraclePriceAggregatedIntervalDb {}
+pub struct OraclePriceAggregatedIntervalDb {
+    pub db: RocksDB,
+}
 
 impl OraclePriceAggregatedIntervalDb {
     pub async fn query(
@@ -15,9 +18,26 @@ impl OraclePriceAggregatedIntervalDb {
         todo!()
     }
     pub async fn put(&self, oracle: OraclePriceAggregatedInterval) -> Result<()> {
-        todo!()
+        match serde_json::to_string(&oracle) {
+            Ok(value) => {
+                let key = oracle.id.clone();
+                self.db.put(
+                    "oracle_price_aggregated_interval",
+                    key.as_bytes(),
+                    value.as_bytes(),
+                )?;
+                Ok(())
+            }
+            Err(e) => Err(anyhow!(e)),
+        }
     }
     pub async fn delete(&self, id: String) -> Result<()> {
-        todo!()
+        match self
+            .db
+            .delete("oracle_price_aggregated_interval", id.as_bytes())
+        {
+            Ok(_) => Ok(()),
+            Err(e) => Err(anyhow!(e)),
+        }
     }
 }

lib/ain-ocean/src/data_acces/oracle_token_currency.rs

@@ -1,18 +1,32 @@
+use crate::database::db_manger::ColumnFamilyOperations;
 use crate::database::db_manger::RocksDB;
 use crate::model::oracle_token_currency::OracleTokenCurrency;
 use anyhow::{anyhow, Result};
 use serde::{Deserialize, Serialize};
 
-pub struct OracleTokenCurrencyDb {}
+pub struct OracleTokenCurrencyDb {
+    pub db: RocksDB,
+}
 
 impl OracleTokenCurrencyDb {
     pub async fn query(&self, limit: i32, lt: String) -> Result<Vec<OracleTokenCurrency>> {
         todo!()
     }
     pub async fn put(&self, oracle_token: OracleTokenCurrency) -> Result<()> {
-        todo!()
+        match serde_json::to_string(&oracle_token) {
+            Ok(value) => {
+                let key = oracle_token.id.clone();
+                self.db
+                    .put("oracle_token_currency", key.as_bytes(), value.as_bytes())?;
+                Ok(())
+            }
+            Err(e) => Err(anyhow!(e)),
+        }
     }
     pub async fn delete(&self, id: String) -> Result<()> {
-        todo!()
+        match self.db.delete("oracle_token_currency", id.as_bytes()) {
+            Ok(_) => Ok(()),
+            Err(e) => Err(anyhow!(e)),
+        }
     }
 }

lib/ain-ocean/src/data_acces/order_history.rs

@@ -1,18 +1,34 @@
+use crate::database::db_manger::ColumnFamilyOperations;
 use crate::database::db_manger::RocksDB;
 use crate::model::oracle_history::OracleHistory;
 use anyhow::{anyhow, Result};
 use serde::{Deserialize, Serialize};
 
-pub struct OracleHistoryDB {}
+
+pub struct OracleHistoryDB {
+    pub db: RocksDB,
+}
 
 impl OracleHistoryDB {
     pub async fn query(&self, oracleId: String, limit: i32, lt: String) -> Result<OracleHistory> {
         todo!()
     }
-    pub async fn put(&self, oracleHistory: OracleHistory) -> Result<()> {
-        todo!()
+
+    pub async fn store(&self, oracle_history: OracleHistory) -> Result<()> {
+        match serde_json::to_string(&oracle_history) {
+            Ok(value) => {
+                let key = oracle_history.id.clone();
+                self.db
+                    .put("oracle_history", key.as_bytes(), value.as_bytes())?;
+                Ok(())
+            }
+            Err(e) => Err(anyhow!(e)),
+        }
     }
     pub async fn delete(&self, id: String) -> Result<()> {
-        todo!()
+        match self.db.delete("oracle_history", id.as_bytes()) {
+            Ok(_) => Ok(()),
+            Err(e) => Err(anyhow!(e)),
+        }
     }
 }

lib/ain-ocean/src/data_acces/pool_swap.rs

@@ -1,18 +1,31 @@
+use crate::database::db_manger::ColumnFamilyOperations;
 use crate::database::db_manger::RocksDB;
 use crate::model::poolswap::PoolSwap;
 use anyhow::{anyhow, Result};
 use serde::{Deserialize, Serialize};
 
-pub struct PoolSwapDb {}
+pub struct PoolSwapDb {
+    pub db: RocksDB,
+}
 
 impl PoolSwapDb {
     pub async fn query(&self, key: String, limit: i32, lt: String) -> Result<Vec<PoolSwap>> {
         todo!()
     }
-    pub async fn put(&self, feed: PoolSwap) -> Result<()> {
-        todo!()
+    pub async fn put(&self, swap: PoolSwap) -> Result<()> {
+        match serde_json::to_string(&swap) {
+            Ok(value) => {
+                let key = swap.id.clone();
+                self.db.put("pool_swap", key.as_bytes(), value.as_bytes())?;
+                Ok(())
+            }
+            Err(e) => Err(anyhow!(e)),
+        }
     }
     pub async fn delete(&self, id: String) -> Result<()> {
-        todo!()
+        match self.db.delete("pool_swap", id.as_bytes()) {
+            Ok(_) => Ok(()),
+            Err(e) => Err(anyhow!(e)),
+        }
     }
 }

lib/ain-ocean/src/data_acces/pool_swap_aggregated.rs

@@ -1,9 +1,12 @@
+use crate::database::db_manger::ColumnFamilyOperations;
 use crate::database::db_manger::RocksDB;
 use crate::model::poolswap_aggregated::PoolSwapAggregated;
 use anyhow::{anyhow, Result};
 use serde::{Deserialize, Serialize};
 
-pub struct PoolSwapAggregatedDb {}
+pub struct PoolSwapAggregatedDb {
+    pub db: RocksDB,
+}
 
 impl PoolSwapAggregatedDb {
     pub async fn query(
@@ -15,12 +18,31 @@ impl PoolSwapAggregatedDb {
         todo!()
     }
     pub async fn put(&self, aggregated: PoolSwapAggregated) -> Result<()> {
-        todo!()
+        match serde_json::to_string(&aggregated) {
+            Ok(value) => {
+                let key = aggregated.id.clone();
+                self.db
+                    .put("pool_swap_aggregated", key.as_bytes(), value.as_bytes())?;
+                Ok(())
+            }
+            Err(e) => Err(anyhow!(e)),
+        }
     }
     pub async fn get(&self, id: String) -> Result<PoolSwapAggregated> {
-        todo!()
+        match self.db.get("pool_swap_aggregated", id.as_bytes()) {
+            Ok(Some(value)) => {
+                let pool_swap: PoolSwapAggregated =
+                    serde_json::from_slice(&value).map_err(|e| anyhow!(e))?;
+                Ok(pool_swap)
+            }
+            Ok(None) => Err(anyhow!("No data found for the given ID")),
+            Err(e) => Err(anyhow!(e)),
+        }
     }
     pub async fn delete(&self, id: String) -> Result<()> {
-        todo!()
+        match self.db.delete("pool_swap_aggregated", id.as_bytes()) {
+            Ok(_) => Ok(()),
+            Err(e) => Err(anyhow!(e)),
+        }
     }
 }

lib/ain-ocean/src/data_acces/price_ticker.rs

@@ -1,21 +1,43 @@
+use crate::database::db_manger::ColumnFamilyOperations;
 use crate::database::db_manger::RocksDB;
 use crate::model::price_ticker::PriceTicker;
 use anyhow::{anyhow, Result};
 use serde::{Deserialize, Serialize};
 
-pub struct OraclePriceAggregatedIntervalDb {}
+pub struct price_ticker {
+    pub db: RocksDB,
+}
 
-impl OraclePriceAggregatedIntervalDb {
+impl price_ticker {
     pub async fn query(&self, limit: i32, lt: String) -> Result<Vec<PriceTicker>> {
         todo!()
     }
     pub async fn get(&self, id: String) -> Result<PriceTicker> {
-        todo!()
+        match self.db.get("price_ticker", id.as_bytes()) {
+            Ok(Some(value)) => {
+                let pool_swap: PriceTicker =
+                    serde_json::from_slice(&value).map_err(|e| anyhow!(e))?;
+                Ok(pool_swap)
+            }
+            Ok(None) => Err(anyhow!("No data found for the given ID")),
+            Err(e) => Err(anyhow!(e)),
+        }
     }
     pub async fn put(&self, price: PriceTicker) -> Result<()> {
-        todo!()
+        match serde_json::to_string(&price) {
+            Ok(value) => {
+                let key = price.id.clone();
+                self.db
+                    .put("price_ticker", key.as_bytes(), value.as_bytes())?;
+                Ok(())
+            }
+            Err(e) => Err(anyhow!(e)),
+        }
     }
     pub async fn delete(&self, id: String) -> Result<()> {
-        todo!()
+        match self.db.delete("price_ticker", id.as_bytes()) {
+            Ok(_) => Ok(()),
+            Err(e) => Err(anyhow!(e)),
+        }
     }
 }

lib/ain-ocean/src/database/db_manger.rs

@@ -5,10 +5,11 @@ use bitcoin::blockdata::block::Header;
 use bitcoin::consensus::encode::serialize;
 use rocksdb::Options;
 use rocksdb::{ColumnFamilyDescriptor, IteratorMode, DB};
+use serde::Deserialize;
 use std::collections::HashSet;
 use std::sync::Arc;
 
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct RocksDB {
     db: Arc<DB>,
     cfs: HashSet<String>,