channels modules have newly updated list endpoints

/channels/create requires a rework however

server-api/db/src/channels.rs

@@ -8,7 +8,10 @@ use crate::{VarChar, UBigInt, Integer};
 use crate::common::FromDB;
 use crate::{sql_err, no_conn, Response};
 
+use serde::Serialize;
+
 #[allow(dead_code)]
+#[derive(Serialize)]
 pub struct Channel {
     pub id: UBigInt,
     pub name: VarChar,
@@ -16,8 +19,11 @@ pub struct Channel {
     pub kind: Integer
 }
 
+pub const VOICE_CHANNEL: Integer = 1;
+pub const TEXT_CHANNEL: Integer = 2;
+
 #[async_trait]
-impl FromDB<Channel> for Channel {
+impl FromDB<Channel, Integer> for Channel {
     // id name desc kind
     type Row = Option<(UBigInt, VarChar, Option<VarChar>, Integer)>;
 
@@ -91,4 +97,62 @@ impl FromDB<Channel> for Channel {
         }
         return Response::Other(no_conn!("Member::FromDB::delete"))
     }
+
+    async fn filter(p: &Pool, kind: Integer) -> Response<Channel> {
+        //! @returns -> on success   : Response::Set(Vec<Channel>)
+        //! @returns -> on empty set : Response::Set(EmptyVector)
+        //! @params  -> on fail      : Response::Other
+
+        // NOTE: used for mapping datasets to vectors
+        let map_rows = |row| {
+            let (id, name, desc, k): (UBigInt, VarChar, Option<VarChar>, Integer) =
+                mysql_async::from_row(row);
+            Channel {
+                id: id,
+                name: name,
+                description: desc,
+                kind: k
+            }
+        };
+        return match (p.get_conn().await, kind) {
+            // Filter for text/voice channels specifically
+            (Ok(conn), VOICE_CHANNEL..=TEXT_CHANNEL) =>  { // @NOTE: voice channel and text_channel are literally 1 & 2 respectively
+                let q = "SELECT id, name, description, kind FROM channels WHERE kind = :kind";
+                let q_result = conn.prep_exec(q, params!{"kind" => kind}).await;
+                if let Ok(res) = q_result {
+                    let mapping_result = res.map_and_drop(map_rows).await;
+                    return match mapping_result {
+                        Ok((_, channels)) => Response::Set(channels),
+                        Err(_) => Response::Other(sql_err!("db::Channels::filter @with params"))
+                    };
+                }
+                else {
+                    Response::Other(sql_err!(""))
+                }
+            },
+            /*
+             * Here we are attempting to get all the channels with no filters applied
+             * This should fetch everything basically in our channels registry
+            */
+            (Ok(conn), _) => {
+                let q = "SELECT id, name, description, kind FROM channels";
+                if let Ok(query) = conn.prep_exec(q, ()).await {
+                    let mapping_r = query.map_and_drop(map_rows).await;
+
+                    return match mapping_r {
+                        Ok((_, channels)) => Response::Set(channels),
+                        Err(_) => Response::Other(sql_err!("db::Channels::filter @no params"))
+                    };
+                }
+                else {
+                    Response::Other(sql_err!("db::Channels::filter @no params @no initial query"))
+                }
+            },
+            (Err(_), _) =>  {Response::Other(no_conn!("Channel::FromDB::filter"))}
+        }
+    }
+}
+
+impl Channel {
+    pub async fn add() {}
 }