sitekey list

src/api/v1/mcaptcha/levels.rs

@@ -17,6 +17,7 @@
 
 use actix_identity::Identity;
 use actix_web::{web, HttpResponse, Responder};
+use log::debug;
 use m_captcha::{defense::Level, DefenseBuilder};
 use serde::{Deserialize, Serialize};
 
@@ -54,6 +55,7 @@ pub mod routes {
 pub struct AddLevels {
     pub levels: Vec<Level>,
     pub duration: u32,
+    pub description: String,
 }
 
 pub fn services(cfg: &mut web::ServiceConfig) {
@@ -104,7 +106,11 @@ async fn add_levels(
 
     defense.build()?;
 
-    let mcaptcha_config = add_mcaptcha_util(payload.duration, &data, &id).await?;
+    debug!("creating config");
+    let mcaptcha_config =
+        add_mcaptcha_util(payload.duration, &payload.description, &data, &id).await?;
+
+    debug!("config created");
 
     for level in payload.levels.iter() {
         let difficulty_factor = level.difficulty_factor as i32;

src/api/v1/mcaptcha/mcaptcha.rs

@@ -83,13 +83,15 @@ pub struct MCaptchaID {
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct MCaptchaDetails {
-    pub name: Option<String>,
+    pub name: String,
     pub key: String,
 }
 
 // this should be called from within add levels
+#[inline]
 pub async fn add_mcaptcha_util(
     duration: u32,
+    description: &str,
     data: &Data,
     id: &Identity,
 ) -> ServiceResult<MCaptchaDetails> {
@@ -102,12 +104,13 @@ pub async fn add_mcaptcha_util(
         key = get_random(32);
 
         let res = sqlx::query!(
-            "INSERT INTO mcaptcha_config 
-        (key, user_id, duration)
-        VALUES ($1, (SELECT ID FROM mcaptcha_users WHERE name = $2), $3)",
+            "INSERT INTO mcaptcha_config
+        (key, user_id, duration, name)
+        VALUES ($1, (SELECT ID FROM mcaptcha_users WHERE name = $2), $3, $4)",
             &key,
             &username,
-            duration as i32
+            duration as i32,
+            description,
         )
         .execute(&data.db)
         .await;
@@ -125,7 +128,10 @@ pub async fn add_mcaptcha_util(
             Err(e) => Err(e)?,
 
             Ok(_) => {
-                resp = MCaptchaDetails { key, name: None };
+                resp = MCaptchaDetails {
+                    key,
+                    name: description.to_owned(),
+                };
                 break;
             }
         }
@@ -133,10 +139,12 @@ pub async fn add_mcaptcha_util(
     Ok(resp)
 }
 
-// this should be called from within add levels
+// TODO deprecate this
 async fn add_mcaptcha(data: web::Data<Data>, id: Identity) -> ServiceResult<impl Responder> {
     let duration = 30;
-    let resp = add_mcaptcha_util(duration, &data, &id).await?;
+    let description = "dummy";
+
+    let resp = add_mcaptcha_util(duration, description, &data, &id).await?;
     Ok(HttpResponse::Ok().json(resp))
 }
 

src/errors.rs

@@ -24,9 +24,7 @@ use actix_web::{
     HttpResponse,
 };
 use argon2_creds::errors::CredsError;
-//use awc::error::SendRequestError;
 use derive_more::{Display, Error};
-use lazy_static::lazy_static;
 use m_captcha::errors::CaptchaError;
 use serde::{Deserialize, Serialize};
 use url::ParseError;

src/pages/panel/sitekey/list.rs

@@ -19,25 +19,92 @@ use actix_identity::Identity;
 use actix_web::{web, HttpResponse, Responder};
 use sailfish::TemplateOnce;
 
-//use crate::api::v1::mcaptcha::mcaptcha::MCaptchaDetails;
+use crate::api::v1::mcaptcha::mcaptcha::MCaptchaDetails;
 use crate::errors::*;
 use crate::Data;
 
 #[derive(TemplateOnce, Clone)]
 #[template(path = "panel/site-keys/index.html")]
-pub struct IndexPage;
+pub struct IndexPage {
+    sitekeys: SiteKeys,
+}
 
 const PAGE: &str = "SiteKeys";
 
-impl Default for IndexPage {
-    fn default() -> Self {
-        IndexPage
+impl IndexPage {
+    fn new(sitekeys: SiteKeys) -> Self {
+        IndexPage { sitekeys }
     }
 }
 
 pub async fn list_sitekeys(data: web::Data<Data>, id: Identity) -> PageResult<impl Responder> {
-    let body = IndexPage::default().render_once().unwrap();
+    let username = id.identity().unwrap();
+    let res = sqlx::query_as!(
+        MCaptchaDetails,
+        "SELECT key, name from mcaptcha_config WHERE
+        user_id = (SELECT ID FROM mcaptcha_users WHERE name = $1) ",
+        &username,
+    )
+    .fetch_all(&data.db)
+    .await?;
+
+    let body = IndexPage::new(res).render_once().unwrap();
     Ok(HttpResponse::Ok()
         .content_type("text/html; charset=utf-8")
         .body(body))
 }
+
+type SiteKeys = Vec<MCaptchaDetails>;
+
+#[cfg(test)]
+mod test {
+    use actix_web::http::StatusCode;
+    use actix_web::test;
+    use actix_web::web::Bytes;
+
+    use crate::tests::*;
+    use crate::*;
+
+    #[actix_rt::test]
+    async fn list_sitekeys_work() {
+        const NAME: &str = "listsitekeyuser";
+        const PASSWORD: &str = "longpassworddomain";
+        const EMAIL: &str = "listsitekeyuser@a.com";
+
+        {
+            let data = Data::new().await;
+            delete_user(NAME, &data).await;
+        }
+
+        register_and_signin(NAME, EMAIL, PASSWORD).await;
+        let (data, _, signin_resp, key) = add_levels_util(NAME, PASSWORD).await;
+        let cookies = get_cookie!(signin_resp);
+
+        let mut app = get_app!(data).await;
+
+        let list_sitekey_resp = test::call_service(
+            &mut app,
+            test::TestRequest::get()
+                .uri(PAGES.panel.sitekey.list)
+                .cookie(cookies.clone())
+                .to_request(),
+        )
+        .await;
+
+        assert_eq!(list_sitekey_resp.status(), StatusCode::OK);
+
+        let body: Bytes = test::read_body(list_sitekey_resp).await;
+        let body = String::from_utf8(body.to_vec()).unwrap();
+
+        //        Bytes::from(key.key)
+        //            .iter()
+        //            .for_each(|e| assert!(body.contains(e)));
+        //
+        //        Bytes::from(key.name)
+        //            .iter()
+        //            .for_each(|e| assert!(body.contains(e)));
+
+        assert!(body.contains(&key.key));
+        assert!(body.contains(&key.name));
+    }
+}

src/pages/panel/sitekey/mod.rs

@@ -22,13 +22,15 @@ pub mod routes {
     pub struct Sitekey {
         pub list: &'static str,
         pub add: &'static str,
+        pub view: &'static str,
     }
 
     impl Sitekey {
         pub const fn new() -> Self {
             Sitekey {
-                list: "/sitekey",
+                list: "/sitekey/list",
                 add: "/sitekey/add",
+                view: "/sitekey/{key}/view",
             }
         }
     }

src/tests/mod.rs

@@ -57,6 +57,7 @@ macro_rules! get_app {
                 ))
                 .configure(crate::api::v1::pow::services)
                 .configure(crate::api::v1::services)
+                .configure(crate::pages::services)
                 .data($data.clone()),
         )
     };
@@ -189,6 +190,7 @@ pub async fn add_levels_util(
     let add_level = AddLevels {
         levels: levels.clone(),
         duration: 30,
+        description: "dummy".into(),
     };
 
     // 1. add level