add error handling

src/cat-data-service/src/service/mod.rs

@@ -1,5 +1,5 @@
 use crate::state::State;
-use axum::Router;
+use axum::{http::StatusCode, Router};
 use event_db::queries::snapshot::SnapshotQueries;
 use std::{net::SocketAddr, sync::Arc};
 
@@ -9,6 +9,8 @@ mod v0;
 pub enum Error {
     #[error("Cannot run service, error: {0}")]
     CannotRunService(String),
+    #[error(transparent)]
+    EventDbError(#[from] event_db::Error),
 }
 
 // #[tracing::instrument]
@@ -29,3 +31,10 @@ pub async fn run_service<EventDB: SnapshotQueries>(
         .map_err(|e| Error::CannotRunService(e.to_string()))?;
     Ok(())
 }
+
+async fn handle_result(res: Result<String, Error>) -> (StatusCode, String) {
+    match res {
+        Ok(res) => (StatusCode::OK, res),
+        Err(err) => (StatusCode::INTERNAL_SERVER_ERROR, err.to_string()),
+    }
+}

src/cat-data-service/src/service/v0/snapshot.rs

@@ -1,4 +1,7 @@
-use crate::state::State;
+use crate::{
+    service::{handle_result, Error},
+    state::State,
+};
 use axum::{extract::Path, routing::get, Router};
 use event_db::queries::snapshot::SnapshotQueries;
 use std::sync::Arc;
@@ -9,43 +12,45 @@ pub fn snapshot<EventDB: SnapshotQueries>(state: Arc<State<EventDB>>) -> Router
             "/snapshot",
             get({
                 let state = state.clone();
-                move || versions_exec(state)
+                move || async { handle_result(versions_exec(state).await).await }
             }),
         )
         .route(
             "/snapshot/voter/:event/:voting_key",
             get({
                 let state = state.clone();
-                move |path| voter_exec(path, state)
+                move |path| async { handle_result(voter_exec(path, state).await).await }
             }),
         )
         .route(
             "/snapshot/delegator/:event/:stake_public_key",
-            get(move |path| delegator_exec(path, state)),
+            get(move |path| async { handle_result(delegator_exec(path, state).await).await }),
         )
 }
 
-async fn versions_exec<EventDB: SnapshotQueries>(state: Arc<State<EventDB>>) -> String {
+async fn versions_exec<EventDB: SnapshotQueries>(
+    state: Arc<State<EventDB>>,
+) -> Result<String, Error> {
     tracing::debug!("versions_exec");
 
-    let snapshot_versions = state.event_db.get_snapshot_versions().await.unwrap();
-    serde_json::to_string(&snapshot_versions).unwrap()
+    let snapshot_versions = state.event_db.get_snapshot_versions().await?;
+    Ok(serde_json::to_string(&snapshot_versions).unwrap())
 }
 
 async fn voter_exec<EventDB: SnapshotQueries>(
     Path((event, voting_key)): Path<(String, String)>,
     state: Arc<State<EventDB>>,
-) -> String {
+) -> Result<String, Error> {
     tracing::debug!("voter_exec, event: {0}, voting_key: {1}", event, voting_key);
 
-    let voter = state.event_db.get_voter(event, voting_key).await.unwrap();
-    serde_json::to_string(&voter).unwrap()
+    let voter = state.event_db.get_voter(event, voting_key).await?;
+    Ok(serde_json::to_string(&voter).unwrap())
 }
 
 async fn delegator_exec<EventDB: SnapshotQueries>(
     Path((event, stake_public_key)): Path<(String, String)>,
     state: Arc<State<EventDB>>,
-) -> String {
+) -> Result<String, Error> {
     tracing::debug!(
         "delegator_exec, event: {0}, stake_public_key: {1}",
         event,
@@ -55,7 +60,6 @@ async fn delegator_exec<EventDB: SnapshotQueries>(
     let delegator = state
         .event_db
         .get_delegator(event, stake_public_key)
-        .await
-        .unwrap();
-    serde_json::to_string(&delegator).unwrap()
+        .await?;
+    Ok(serde_json::to_string(&delegator).unwrap())
 }

src/event-db/src/queries/snapshot.rs

@@ -1,5 +1,5 @@
 use crate::{
-    types::snapshot::{Delegator, Voter},
+    types::snapshot::{Delegator, Voter, VoterInfo},
     Error, EventDB,
 };
 use async_trait::async_trait;
@@ -19,7 +19,14 @@ pub trait SnapshotQueries: Sync + Send + 'static {
 impl SnapshotQueries for EventDB {
     async fn get_snapshot_versions(&self) -> Result<Vec<i32>, Error> {
         let conn = self.pool.get().await?;
-        let rows = conn.query("SELECT event from snapshot;", &[]).await?;
+        let rows = conn
+            .query(
+                "
+        SELECT event 
+        FROM snapshot;",
+                &[],
+            )
+            .await?;
         let mut snapshot_versions = Vec::new();
         for row in rows {
             let version = row.try_get("event")?;
@@ -28,11 +35,25 @@ impl SnapshotQueries for EventDB {
         Ok(snapshot_versions)
     }
 
-    async fn get_voter(&self, _event: String, _voting_key: String) -> Result<Voter, Error> {
+    async fn get_voter(&self, _event: String, voting_key: String) -> Result<Voter, Error> {
         let conn = self.pool.get().await?;
-        let _row = conn.query_one("SELECT ", &[]).await?;
+        let row = conn.query_one("
+         SELECT voter.voting_key, voter.voting_group, voter.voting_power, snapshot.as_at, snapshot.last_updated, snapshot.final
+         FROM voter 
+         INNER JOIN snapshot ON voter.snapshot_id = snapshot.row_id 
+         WHERE voter.voting_key = $1;
+        ", &[&voting_key]).await?;
 
-        Ok(Default::default())
+        Ok(Voter {
+            voter_info: VoterInfo {
+                voting_power: row.try_get("voting_power")?,
+                voting_group: row.try_get("voting_group")?,
+                ..Default::default()
+            },
+            as_at: row.try_get("as_at")?,
+            last_updated: row.try_get("last_updated")?,
+            r#final: row.try_get("final")?,
+        })
     }
 
     async fn get_delegator(

src/event-db/src/types/snapshot.rs

@@ -1,38 +1,39 @@
 use serde::Serialize;
+use std::time::SystemTime;
 
 #[derive(Serialize, Clone, Default)]
 pub struct VoterInfo {
-    voting_power: u64,
-    voting_group: String,
-    delegations_power: u64,
-    delegations_count: u64,
-    voting_power_saturation: f64,
+    pub voting_power: i64,
+    pub voting_group: String,
+    pub delegations_power: u64,
+    pub delegations_count: u64,
+    pub voting_power_saturation: f64,
 }
 
-#[derive(Serialize, Clone, Default)]
+#[derive(Serialize, Clone)]
 pub struct Voter {
-    voter_info: VoterInfo,
-    as_at: String,
-    last_updated: String,
-    r#final: bool,
+    pub voter_info: VoterInfo,
+    pub as_at: SystemTime,
+    pub last_updated: SystemTime,
+    pub r#final: bool,
 }
 
 #[derive(Serialize, Clone, Default)]
 pub struct Delegation {
-    voting_key: String,
-    group: String,
-    weight: u64,
-    value: u64,
+    pub voting_key: String,
+    pub group: String,
+    pub weight: u64,
+    pub value: u64,
 }
 
 #[derive(Serialize, Clone, Default)]
 pub struct Delegator {
-    delegations: Vec<Delegation>,
-    raw_power: u64,
-    total_power: u64,
-    as_at: String,
-    last_updated: String,
-    r#final: bool,
+    pub delegations: Vec<Delegation>,
+    pub raw_power: u64,
+    pub total_power: u64,
+    pub as_at: String,
+    pub last_updated: String,
+    pub r#final: bool,
 }
 
 #[cfg(test)]
@@ -56,14 +57,14 @@ mod tests {
                 delegations_count: 1,
                 voting_power_saturation: 0.4,
             },
-            as_at: "today".to_string(),
-            last_updated: "today".to_string(),
+            as_at: SystemTime::UNIX_EPOCH,
+            last_updated: SystemTime::UNIX_EPOCH,
             r#final: true,
         };
         let json = serde_json::to_string(&voter).unwrap();
         assert_eq!(
             json,
-            r#"{"voter_info":{"voting_power":100,"voting_group":"rep","delegations_power":100,"delegations_count":1,"voting_power_saturation":0.4},"as_at":"today","last_updated":"today","final":true}"#
+            r#"{"voter_info":{"voting_power":100,"voting_group":"rep","delegations_power":100,"delegations_count":1,"voting_power_saturation":0.4},"as_at":{"secs_since_epoch":0,"nanos_since_epoch":0},"last_updated":{"secs_since_epoch":0,"nanos_since_epoch":0},"final":true}"#
         );
     }