parse question desc with deserialize_with feature

Author: clearloop

src/cache/mod.rs

@@ -50,7 +50,7 @@ impl Cache {
 
         for i in &self.0.conf.sys.categories.to_owned() {
             let json = self.0.clone().get_category_problems(&i)?.json()?;
-            parser::problem(&mut ps, json)?
+            parser::problem(&mut ps, json)?;
         }
 
         let count = self.get_problems()?.len();
@@ -67,16 +67,13 @@ impl Cache {
         let rslug: String = problems
             .select(slug)
             .filter(fid.eq(rfid))
-            .first(&self.conn())
-            .unwrap();
+            .first(&self.conn())?;
 
-        let mut res = self.0.clone().get_question_detail(&rslug)?;
-        let json: Value = res.json()?;
-        println!("{:?}", json);
-        // let problem = diesel::select(
-        //     problems.filter(fid.eq(fid))
-        // ).execute(&self.conn());
-        Ok(true)
+        let mut desc = Question::default();
+        let json: Value = self.0.clone().get_question_detail(&rslug)?.json()?;
+        parser::desc(&mut desc, json)?;
+
+        Ok(desc)
     }
 
     /// Get problems from cache

src/cache/models.rs

@@ -1,6 +1,7 @@
-//! Leetcode data models
+//! Leetcode data modelsA
 use colored::Colorize;
-use serde::Serialize;
+use serde::{Serialize, Deserialize};
+pub use self::question::*;
 use super::schemas::problems;
 
 /// Problem model
@@ -16,7 +17,7 @@ pub struct Problem {
     pub percent: f32,
     pub slug: String,
     pub starred: bool,
-    pub state: String,
+    pub status: String,
 }
 
 static DONE: &'static str = " ✔";
@@ -34,9 +35,9 @@ impl std::fmt::Display for Problem {
         let mut level = "".normal();
 
         if self.locked { lock = LOCK };
-        if self.state == "ac".to_string() {
+        if self.status == "ac".to_string() {
             done = DONE.green().bold();
-        } else if self.state == "notac" {
+        } else if self.status == "notac" {
             done = NDONE.green().bold();
         }
 
@@ -90,48 +91,144 @@ impl std::fmt::Display for Problem {
     }
 }
 
-
-/// Description Model
-pub struct DescData {
-    pub question: Question
-}
-
-/// desc.question
+/// desc model
+#[derive(Debug, Default, Serialize, Deserialize)]
 pub struct Question {
-    pub content: String,
-    pub stat: QuestionStat,
-    pub code_defintion: Vec<CodeDefintion>,
-    pub sample_text_case: String,
-    pub enable_run_code: bool,
-    pub meta_data: MetaData,
-    pub translated_cotent: String
+    pub content: Option<String>,
+    #[serde(deserialize_with = "string_struct")]
+    pub stats: Stats,
+    #[serde(alias = "codeDefinition", deserialize_with = "string_struct")]
+    pub defs: CodeDefintion,
+    #[serde(alias = "sampleTestCase")]
+    pub case: String,
+    #[serde(alias = "metaData", deserialize_with = "string_struct")]
+    pub metadata: MetaData,
+    #[serde(alias = "enableRunCode")]
+    pub test: bool,
+    #[serde(alias = "translatedContent")]
+    pub t_content: Option<String>,
 }
 
-pub struct QuestionStat {
-    pub total_accepted: String,
-    pub total_submission: String,
-    pub total_accepted_aw: i64,
-    pub total_submission_raw: i64,
-    pub ac_rate: String
-}
+/// deps of Question
+mod question {
+    use crate::err::Error;
+    use serde::{
+        Serialize,
+        Deserialize,
+        Deserializer,
+        de::{
+            self,
+            Visitor
+        }
+    };
+    use std::{
+        fmt,
+        str::FromStr,
+        marker::PhantomData,
+    };
 
-pub struct CodeDefintion {
-    pub value: String,
-    pub text: String,
-    pub default_code: String,
-}
+    /// Code samples
+    #[derive(Debug, Default, Serialize, Deserialize)]
+    pub struct CodeDefintion(pub Vec<CodeDefintionInner>);
 
-pub struct MetaData {
-    pub name: String,
-    pub params: Vec<Param>,
-    pub r#return: Return,
-}
+    /// CodeDefinition Inner struct
+    #[derive(Debug, Default, Serialize, Deserialize)]
+    pub struct CodeDefintionInner {
+        pub value: String,
+        pub text: String,
+        #[serde(alias = "defaultCode")]
+        pub code: String,
+    }
 
-pub struct Param {
-    pub name: String,
-    pub r#type: String
-}
+    /// Question status
+    #[derive(Debug, Default, Serialize, Deserialize)]
+    pub struct Stats {
+        #[serde(alias = "totalAccepted")]
+        tac: String,
+        #[serde(alias = "totalSubmission")]
+        tsm: String,
+        #[serde(alias = "totalAcceptedRaw")]
+        tacr: i32,
+        #[serde(alias = "totalSubmissionRaw")]
+        tsmr: i32,
+        #[serde(alias = "acRate")]
+        rate: String
+    }
+    
+    /// Algorithm metadata
+    #[derive(Debug, Default, Serialize, Deserialize)]
+    pub struct MetaData {
+        pub name: String,
+        pub params: Vec<Param>,
+        pub r#return: Return,
+    }
+
+    /// Deserialize CodedeFintion from str
+    impl std::str::FromStr for CodeDefintion {
+        type Err = Error;
+
+        fn from_str(s: &str) -> Result<Self, Self::Err> {
+            Ok(serde_json::from_str(s)?)
+        }
+    }
+
+    /// Deserialize Stats from str
+    impl std::str::FromStr for Stats {
+        type Err = crate::err::Error;
 
-pub struct Return {
-    pub r#type: String
+        fn from_str(s: &str) -> Result<Self, Self::Err> {
+            Ok(serde_json::from_str(s)?)
+        }
+    }
+
+    /// Deserialize MetaData from str
+    impl std::str::FromStr for MetaData {
+        type Err = Error;
+
+        fn from_str(s: &str) -> Result<Self, Self::Err> {
+            Ok(serde_json::from_str(s)?)
+        }
+    }
+
+    /// MetaData nested fields
+    #[derive(Debug, Default, Serialize, Deserialize)]
+    pub struct Param {
+        pub name: String,
+        pub r#type: String
+    }
+
+    /// MetaData nested fields
+    #[derive(Debug, Default, Serialize, Deserialize)]
+    pub struct Return {
+        pub r#type: String
+    }
+
+    /// Master serde_json
+    pub fn string_struct<'de, T, D>(deserializer: D) -> Result<T, D::Error>
+    where
+        T: Deserialize<'de> + FromStr<Err = Error>,
+        D: Deserializer<'de>,
+    {
+        struct StringStruct<T>(PhantomData<fn() -> T>);
+        impl<'de, T> Visitor<'de> for StringStruct<T>
+        where
+            T: Deserialize<'de> + FromStr<Err = Error>,
+        {
+            type Value = T;
+            
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("string")
+            }
+            
+            fn visit_str<E>(self, value: &str) -> Result<T, E>
+            where
+                E: de::Error,
+            {
+                Ok(FromStr::from_str(value).unwrap())
+            }
+        }
+
+        
+        deserializer.deserialize_str(StringStruct(PhantomData))
+    }
 }

src/cache/parser.rs

@@ -1,39 +1,38 @@
 //! mod for parse resp data
 use serde_json::Value;
 use crate::err::Error;
-use super::models::Problem;
+use super::models::*;
 
+/// problem parser
 pub fn problem(problems: &mut Vec<Problem>, v: Value) -> Result<(), Error> {
     let pairs = v.get("stat_status_pairs")?.as_array()?;
     for p in pairs {
-        let category = v.get("category_slug")?.as_str()?.to_string();
-        let level = p.get("difficulty")?.as_object()?.get("level")?.as_i64()? as i32;
-        let starred = p.get("is_favor")?.as_bool()?;
-        let locked = p.get("paid_only")?.as_bool()?;
-        let state = p.get("status")?.as_str()?.to_string();
         let stat = p.get("stat")?.as_object()?;
-        let id = stat.get("question_id")?.as_i64()? as i32;
-        let fid = stat.get("frontend_question_id")?.as_i64()? as i32;
-        let name = stat.get("question__title")?.as_str()?.to_string();
-        let slug = stat.get("question__title_slug")?.as_str()?.to_string();
         let total_acs = stat.get("total_acs")?.as_f64()? as f32;
         let total_submitted = stat.get("total_submitted")?.as_f64()? as f32;
-
+        
         problems.push(Problem{
-            category,
-            fid,
-            id,
-            level,
-            locked,
-            name,
+            category: v.get("category_slug")?.as_str()?.to_string(),
+            fid: stat.get("frontend_question_id")?.as_i64()? as i32,
+            id: stat.get("question_id")?.as_i64()? as i32,
+            level: p.get("difficulty")?.as_object()?.get("level")?.as_i64()? as i32,
+            locked: p.get("paid_only")?.as_bool()?,
+            name: stat.get("question__title")?.as_str()?.to_string(),
             percent: total_acs / total_submitted * 100.0,
-            slug,
-            starred,
-            state,
+            slug: stat.get("question__title_slug")?.as_str()?.to_string(),
+            starred: p.get("is_favor")?.as_bool()?,
+            status: p.get("status")?.as_str().unwrap_or("Null").to_string(),
         });
     }
 
     return Ok(());
 }
 
-// pub fn question()
+/// desc parser
+pub fn desc(q: &mut Question, v: Value) -> Result<(), Error> {
+    *q = serde_json::from_str(
+        &v.as_object()?.get("data")?.as_object()?.get("question")?.to_string()
+    )?;
+
+    Ok(())
+}

src/cache/schemas.rs

@@ -10,6 +10,6 @@ table! {
         percent -> Float,
         slug -> Text,
         starred -> Bool,
-        state -> Text,
+        status -> Text,
     }
 }

src/cache/sql.rs

@@ -9,7 +9,7 @@ pub static CREATE_PROBLEMS_IF_NOT_EXISTS: &'static str = r#"
     percent FLOAT NOT NULL,
     slug TEXT NOT NULL,
     starred BOOLEAN NOT NULL DEFAULT 0,
-    state TEXT NOT NULL
+    status TEXT NOT NULL
   )
 "#;