Merge branch 'dev'

Author: akarsh1995

CHANGELOG.md

@@ -22,6 +22,18 @@ All notable changes to this project will be documented in this file.
 
 - Invalidate questions cache through `userSessionProgress`
 
+## [0.2.1] - [Unreleased]
+
+### Added
+
+- Neetcode 75 question list.
+
+### Changed
+
+- Not null constraints on the fields that are never null from the server.
+- `QuestionModelContainer { question: RefCell<QuestionModel> }` changed to `Rc<RefCell<QuestionModel>>`
+    - As prior implemented hash. Hashables should not be mutable.
+
 ## [0.2.0] - 2023-07-30
 
 ### Added

src/app_ui/async_task_channel.rs

@@ -22,47 +22,37 @@ pub enum TaskRequest {
     DbUpdateQuestion(Request<QuestionModel>),
 }
 
-impl TaskRequest {
-    pub async fn execute(
-        self,
-        client: &reqwest::Client,
-        conn: &DatabaseConnection,
-    ) -> TaskResponse {
-        match self {
-            TaskRequest::QuestionDetail(Request {
-                content: slug,
-                widget_name,
-                request_id,
-            }) => get_question_details(request_id, widget_name, slug, client).await,
-            TaskRequest::GetAllQuestionsMap(Request {
-                widget_name,
-                request_id,
-                ..
-            }) => get_all_questions(request_id, widget_name, conn).await,
-            TaskRequest::GetAllTopicTags(Request {
-                widget_name,
-                request_id,
-                ..
-            }) => get_all_topic_tags(request_id, widget_name, conn).await,
-            TaskRequest::GetQuestionEditorData(Request {
-                request_id,
-                content,
-                widget_name,
-            }) => get_editor_data(request_id, widget_name, content, client).await,
-            TaskRequest::CodeRunRequest(Request {
-                request_id,
-                content,
-                widget_name,
-            }) => run_or_submit_question(request_id, widget_name, content, client).await,
-            TaskRequest::DbUpdateQuestion(Request {
-                request_id,
-                content,
-                widget_name,
-            }) => update_status_to_accepted(request_id, widget_name, content, conn).await,
+macro_rules! impl_task_request {
+    ($(($var:ident, $f_name: ident)),*) => {
+        impl TaskRequest {
+            pub async fn execute(
+                self,
+                client: &reqwest::Client,
+                conn: &DatabaseConnection,
+            ) -> TaskResponse {
+                match self {
+                    $(
+                        TaskRequest::$var(Request {
+                            content,
+                            widget_name,
+                            request_id,
+                        }) => $f_name(request_id, widget_name, content, client, conn).await,
+                    )*
+                }
+            }
         }
-    }
+    };
 }
 
+impl_task_request!(
+    (QuestionDetail, get_question_details),
+    (GetAllQuestionsMap, get_all_questions),
+    (GetAllTopicTags, get_all_topic_tags),
+    (GetQuestionEditorData, get_editor_data),
+    (CodeRunRequest, run_or_submit_question),
+    (DbUpdateQuestion, update_status_to_accepted)
+);
+
 #[derive(Debug)]
 pub struct Response<T> {
     pub(crate) request_id: String,
@@ -81,21 +71,31 @@ pub enum TaskResponse {
     Error(Response<String>),
 }
 
-impl TaskResponse {
-    pub fn get_widget_name(&self) -> WidgetName {
-        match self {
-            TaskResponse::QuestionDetail(Response { widget_name, .. }) => widget_name,
-            TaskResponse::GetAllQuestionsMap(Response { widget_name, .. }) => widget_name,
-            TaskResponse::AllTopicTags(Response { widget_name, .. }) => widget_name,
-            TaskResponse::Error(Response { widget_name, .. }) => widget_name,
-            TaskResponse::QuestionEditorData(Response { widget_name, .. }) => widget_name,
-            TaskResponse::RunResponseData(Response { widget_name, .. }) => widget_name,
-            TaskResponse::DbUpdateStatus(Response { widget_name, .. }) => widget_name,
+macro_rules! impl_task_response {
+    ($($variant:ident),*) => {
+        impl TaskResponse {
+            pub fn get_widget_name(&self) -> WidgetName {
+                match self {
+                    $(
+                        TaskResponse::$variant(Response { widget_name, .. }) => widget_name,
+                    )*
+                }
+                .clone()
+            }
         }
-        .clone()
-    }
+    };
 }
 
+impl_task_response!(
+    QuestionDetail,
+    GetAllQuestionsMap,
+    AllTopicTags,
+    QuestionEditorData,
+    RunResponseData,
+    DbUpdateStatus,
+    Error
+);
+
 pub type ChannelRequestSender = tokio::sync::mpsc::UnboundedSender<TaskRequest>;
 pub type ChannelRequestReceiver = tokio::sync::mpsc::UnboundedReceiver<TaskRequest>;
 

src/app_ui/components/list.rs

@@ -1,10 +1,9 @@
 use ratatui::widgets::ListState;
-use std::rc::Rc;
 
 #[derive(Debug, Clone)]
 pub struct StatefulList<T> {
     pub state: ListState,
-    pub items: Vec<Rc<T>>,
+    pub items: Vec<T>,
 }
 
 impl<T> Default for StatefulList<T> {
@@ -21,10 +20,10 @@ impl<T> StatefulList<T> {
         if self.items.is_empty() {
             self.state.select(Some(0))
         }
-        self.items.push(Rc::new(item))
+        self.items.push(item)
     }
 
-    pub fn get_selected_item(&self) -> Option<&Rc<T>> {
+    pub fn get_selected_item(&self) -> Option<&T> {
         match self.state.selected() {
             Some(i) => Some(&self.items[i]),
             None => None,
@@ -38,7 +37,7 @@ impl<T> StatefulList<T> {
         }
         StatefulList {
             state: list_state,
-            items: items.into_iter().map(|item| Rc::new(item)).collect(),
+            items,
         }
     }
 

src/app_ui/components/popups/selection_list.rs

@@ -60,7 +60,7 @@ impl Component for SelectionListPopup {
             .items
             .iter()
             .map(|item| {
-                let line_text = item.as_ref();
+                let line_text = item;
                 ListItem::new(Span::styled(line_text, Style::default()))
             })
             .collect::<Vec<_>>();

src/app_ui/helpers/question.rs

@@ -1,24 +1,9 @@
 use std::{cell::RefCell, rc::Rc};
 
 use crate::entities::QuestionModel;
-use std::hash::Hash;
-
-#[derive(PartialEq, Eq, Debug, Ord, PartialOrd)]
-pub struct QuestionModelContainer {
-    pub question: RefCell<QuestionModel>,
-}
-
-// RefCell keys are mutable and should not be used in types where hashing
-// is required. This implementation is valid until question_frontend_id change.
-// For more refer https://rust-lang.github.io/rust-clippy/master/index.html#/mutable_key_type
-impl Hash for QuestionModelContainer {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.question.borrow().hash(state)
-    }
-}
 
 pub struct Stats<'a> {
-    pub qm: &'a Vec<Rc<QuestionModelContainer>>,
+    pub qm: &'a Vec<Rc<RefCell<QuestionModel>>>,
 }
 
 impl<'a> Stats<'a> {
@@ -66,12 +51,8 @@ impl<'a> Stats<'a> {
         self.qm
             .iter()
             .filter(|q| {
-                if let Some(st) = &q.question.borrow().status {
-                    if let Some(at) = &q.question.borrow().difficulty {
-                        st.as_str() == status && difficulty == at.as_str()
-                    } else {
-                        false
-                    }
+                if let Some(st) = &q.borrow().status {
+                    st.as_str() == status && difficulty == q.borrow().difficulty.as_str()
                 } else {
                     false
                 }
@@ -83,7 +64,7 @@ impl<'a> Stats<'a> {
         self.qm
             .iter()
             .filter(|q| {
-                if let Some(st) = &q.question.borrow().status {
+                if let Some(st) = &q.borrow().status {
                     st.as_str() == status
                 } else {
                     false
@@ -95,13 +76,7 @@ impl<'a> Stats<'a> {
     fn get_diff_count(&self, difficulty: &str) -> usize {
         self.qm
             .iter()
-            .filter(|q| {
-                if let Some(diff) = &q.question.borrow().difficulty {
-                    diff.as_str() == difficulty
-                } else {
-                    false
-                }
-            })
+            .filter(|q| q.borrow().difficulty.as_str() == difficulty)
             .count()
     }
 }

src/app_ui/helpers/tasks.rs

@@ -13,8 +13,9 @@ pub async fn get_question_details(
     widget_name: WidgetName,
     slug: String,
     client: &reqwest::Client,
+    _conn: &DatabaseConnection,
 ) -> TaskResponse {
-    match QuestionGQLQuery::new(slug).post(client).await {
+    match QuestionGQLQuery::new(slug).send(client).await {
         Ok(resp) => {
             let query_response = resp;
             TaskResponse::QuestionDetail(Response {
@@ -36,8 +37,9 @@ pub async fn get_editor_data(
     widget_name: WidgetName,
     slug: String,
     client: &reqwest::Client,
+    _conn: &DatabaseConnection,
 ) -> TaskResponse {
-    match QuestionEditorDataQuery::new(slug).post(client).await {
+    match QuestionEditorDataQuery::new(slug).send(client).await {
         Ok(data) => TaskResponse::QuestionEditorData(Response {
             request_id,
             content: data.data.question,
@@ -54,6 +56,8 @@ pub async fn get_editor_data(
 pub async fn get_all_questions(
     request_id: String,
     widget_name: WidgetName,
+    _content: (),
+    _client: &reqwest::Client,
     conn: &DatabaseConnection,
 ) -> TaskResponse {
     match TopicTagEntity::get_all_topic_questions_map(conn).await {
@@ -73,6 +77,8 @@ pub async fn get_all_questions(
 pub async fn get_all_topic_tags(
     request_id: String,
     widget_name: WidgetName,
+    _content: (),
+    _client: &reqwest::Client,
     conn: &DatabaseConnection,
 ) -> TaskResponse {
     match TopicTagEntity::get_all_topics(conn).await {
@@ -94,6 +100,7 @@ pub async fn run_or_submit_question(
     widget_name: WidgetName,
     mut run_or_submit_code: graphql::RunOrSubmitCode,
     client: &reqwest::Client,
+    _conn: &DatabaseConnection,
 ) -> TaskResponse {
     if let RunOrSubmitCode::Run(RunCode {
         test_cases_stdin,
@@ -102,7 +109,7 @@ pub async fn run_or_submit_question(
     }) = &mut run_or_submit_code
     {
         match graphql::console_panel_config::Query::new(slug.clone())
-            .post(client)
+            .send(client)
             .await
         {
             Ok(resp) => {
@@ -136,6 +143,7 @@ pub async fn update_status_to_accepted(
     request_id: String,
     widget_name: WidgetName,
     question: QuestionModel,
+    _client: &reqwest::Client,
     db: &DatabaseConnection,
 ) -> TaskResponse {
     let mut am = question.into_active_model();

src/app_ui/widgets/notification.rs

@@ -1,12 +1,11 @@
-use std::rc::Rc;
+use std::{cell::RefCell, rc::Rc};
 
-use crate::app_ui::helpers::question::QuestionModelContainer;
 use crate::{
     app_ui::components::{
         help_text::HelpText,
         popups::{paragraph::ParagraphPopup, selection_list::SelectionListPopup},
     },
-    entities::TopicTagModel,
+    entities::{QuestionModel, TopicTagModel},
 };
 
 #[derive(Debug, Clone)]
@@ -54,7 +53,7 @@ impl<T> NotifContent<T> {
 #[derive(Debug, Clone)]
 pub enum Notification {
     Questions(NotifContent<Vec<TopicTagModel>>),
-    Stats(NotifContent<Vec<Rc<QuestionModelContainer>>>),
+    Stats(NotifContent<Vec<Rc<RefCell<QuestionModel>>>>),
     Popup(NotifContent<PopupMessage>),
     HelpText(NotifContent<IndexSet<HelpText>>),
     Event(NotifContent<KeyEvent>),