feat: ability to view tasks in a category #19
@@ -4,6 +4,7 @@ mod models;
|
||||
mod route;
|
||||
mod schema;
|
||||
mod server;
|
||||
mod query;
|
||||
|
||||
use components::app::App;
|
||||
use dioxus::prelude::*;
|
||||
|
||||
22
src/query/mod.rs
Normal file
@@ -0,0 +1,22 @@
|
||||
use crate::errors::error::Error;
|
||||
use crate::errors::error_vec::ErrorVec;
|
||||
use crate::models::category::Category;
|
||||
use crate::models::task::Task;
|
||||
|
||||
pub(crate) mod tasks;
|
||||
|
||||
#[derive(PartialEq, Debug)]
|
||||
pub(crate) enum QueryValue {
|
||||
Tasks(Vec<Task>),
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub(crate) enum QueryErrors {
|
||||
Error(ErrorVec<Error>),
|
||||
}
|
||||
|
||||
#[derive(PartialEq, Eq, Hash, Clone, Debug)]
|
||||
pub(crate) enum QueryKey {
|
||||
Tasks,
|
||||
TasksInCategory(Category),
|
||||
}
|
||||
24
src/query/tasks.rs
Normal file
@@ -0,0 +1,24 @@
|
||||
|
|
||||
use dioxus::prelude::ServerFnError;
|
||||
Consider improving error handling in The use of Suggested changes to improve error handling: And for the unexpected keys: **Consider improving error handling in `fetch_tasks_in_category`.**
The use of `panic!` for handling unexpected errors (lines 19 and 22) is risky in a production environment as it can cause the application to crash. Consider logging these errors or returning a controlled error response instead.
Suggested changes to improve error handling:
```rust
Err(error) => {
log::error!("Unexpected error: {:?}", error);
Err(QueryErrors::UnexpectedError)
}
```
And for the unexpected keys:
```rust
else {
log::warn!("Unexpected query keys: {:?}", keys);
Err(QueryErrors::InvalidQuery)
}
```
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
use dioxus_query::prelude::{use_get_query, QueryResult, UseQuery};
|
||||
|
Consider improving error handling in The use of Suggested changes to improve error handling: And for the unexpected keys: **Consider improving error handling in `fetch_tasks_in_category`.**
The use of `panic!` for handling unexpected errors (lines 19 and 22) is risky in a production environment as it can cause the application to crash. Consider logging these errors or returning a controlled error response instead.
Suggested changes to improve error handling:
```rust
Err(error) => {
log::error!("Unexpected error: {:?}", error);
Err(QueryErrors::UnexpectedError)
}
```
And for the unexpected keys:
```rust
else {
log::warn!("Unexpected query keys: {:?}", keys);
Err(QueryErrors::InvalidQuery)
}
```
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
use crate::models::category::Category;
|
||||
|
Consider improving error handling in The use of Suggested changes to improve error handling: And for the unexpected keys: **Consider improving error handling in `fetch_tasks_in_category`.**
The use of `panic!` for handling unexpected errors (lines 19 and 22) is risky in a production environment as it can cause the application to crash. Consider logging these errors or returning a controlled error response instead.
Suggested changes to improve error handling:
```rust
Err(error) => {
log::error!("Unexpected error: {:?}", error);
Err(QueryErrors::UnexpectedError)
}
```
And for the unexpected keys:
```rust
else {
log::warn!("Unexpected query keys: {:?}", keys);
Err(QueryErrors::InvalidQuery)
}
```
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
use crate::query::{QueryErrors, QueryKey, QueryValue};
|
||||
|
Consider improving error handling in The use of Suggested changes to improve error handling: And for the unexpected keys: **Consider improving error handling in `fetch_tasks_in_category`.**
The use of `panic!` for handling unexpected errors (lines 19 and 22) is risky in a production environment as it can cause the application to crash. Consider logging these errors or returning a controlled error response instead.
Suggested changes to improve error handling:
```rust
Err(error) => {
log::error!("Unexpected error: {:?}", error);
Err(QueryErrors::UnexpectedError)
}
```
And for the unexpected keys:
```rust
else {
log::warn!("Unexpected query keys: {:?}", keys);
Err(QueryErrors::InvalidQuery)
}
```
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
use crate::server::tasks::get_tasks_in_category;
|
||||
|
Consider improving error handling in The use of Suggested changes to improve error handling: And for the unexpected keys: **Consider improving error handling in `fetch_tasks_in_category`.**
The use of `panic!` for handling unexpected errors (lines 19 and 22) is risky in a production environment as it can cause the application to crash. Consider logging these errors or returning a controlled error response instead.
Suggested changes to improve error handling:
```rust
Err(error) => {
log::error!("Unexpected error: {:?}", error);
Err(QueryErrors::UnexpectedError)
}
```
And for the unexpected keys:
```rust
else {
log::warn!("Unexpected query keys: {:?}", keys);
Err(QueryErrors::InvalidQuery)
}
```
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
|
||||
|
Consider improving error handling in The use of Suggested changes to improve error handling: And for the unexpected keys: **Consider improving error handling in `fetch_tasks_in_category`.**
The use of `panic!` for handling unexpected errors (lines 19 and 22) is risky in a production environment as it can cause the application to crash. Consider logging these errors or returning a controlled error response instead.
Suggested changes to improve error handling:
```rust
Err(error) => {
log::error!("Unexpected error: {:?}", error);
Err(QueryErrors::UnexpectedError)
}
```
And for the unexpected keys:
```rust
else {
log::warn!("Unexpected query keys: {:?}", keys);
Err(QueryErrors::InvalidQuery)
}
```
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
|
||||
|
Consider improving error handling in The use of Suggested changes to improve error handling: And for the unexpected keys: **Consider improving error handling in `fetch_tasks_in_category`.**
The use of `panic!` for handling unexpected errors (lines 19 and 22) is risky in a production environment as it can cause the application to crash. Consider logging these errors or returning a controlled error response instead.
Suggested changes to improve error handling:
```rust
Err(error) => {
log::error!("Unexpected error: {:?}", error);
Err(QueryErrors::UnexpectedError)
}
```
And for the unexpected keys:
```rust
else {
log::warn!("Unexpected query keys: {:?}", keys);
Err(QueryErrors::InvalidQuery)
}
```
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
|
||||
|
Consider improving error handling in The use of Suggested changes to improve error handling: And for the unexpected keys: **Consider improving error handling in `fetch_tasks_in_category`.**
The use of `panic!` for handling unexpected errors (lines 19 and 22) is risky in a production environment as it can cause the application to crash. Consider logging these errors or returning a controlled error response instead.
Suggested changes to improve error handling:
```rust
Err(error) => {
log::error!("Unexpected error: {:?}", error);
Err(QueryErrors::UnexpectedError)
}
```
And for the unexpected keys:
```rust
else {
log::warn!("Unexpected query keys: {:?}", keys);
Err(QueryErrors::InvalidQuery)
}
```
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
pub(crate) fn use_tasks_in_category_query(category: Category)
|
||||
|
Consider improving error handling in The use of Suggested changes to improve error handling: And for the unexpected keys: **Consider improving error handling in `fetch_tasks_in_category`.**
The use of `panic!` for handling unexpected errors (lines 19 and 22) is risky in a production environment as it can cause the application to crash. Consider logging these errors or returning a controlled error response instead.
Suggested changes to improve error handling:
```rust
Err(error) => {
log::error!("Unexpected error: {:?}", error);
Err(QueryErrors::UnexpectedError)
}
```
And for the unexpected keys:
```rust
else {
log::warn!("Unexpected query keys: {:?}", keys);
Err(QueryErrors::InvalidQuery)
}
```
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
-> UseQuery<QueryValue, QueryErrors, QueryKey> {
|
||||
|
Consider improving error handling in The use of Suggested changes to improve error handling: And for the unexpected keys: **Consider improving error handling in `fetch_tasks_in_category`.**
The use of `panic!` for handling unexpected errors (lines 19 and 22) is risky in a production environment as it can cause the application to crash. Consider logging these errors or returning a controlled error response instead.
Suggested changes to improve error handling:
```rust
Err(error) => {
log::error!("Unexpected error: {:?}", error);
Err(QueryErrors::UnexpectedError)
}
```
And for the unexpected keys:
```rust
else {
log::warn!("Unexpected query keys: {:?}", keys);
Err(QueryErrors::InvalidQuery)
}
```
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
use_get_query([QueryKey::TasksInCategory(category), QueryKey::Tasks], fetch_tasks_in_category)
|
||||
|
Consider improving error handling in The use of Suggested changes to improve error handling: And for the unexpected keys: **Consider improving error handling in `fetch_tasks_in_category`.**
The use of `panic!` for handling unexpected errors (lines 19 and 22) is risky in a production environment as it can cause the application to crash. Consider logging these errors or returning a controlled error response instead.
Suggested changes to improve error handling:
```rust
Err(error) => {
log::error!("Unexpected error: {:?}", error);
Err(QueryErrors::UnexpectedError)
}
```
And for the unexpected keys:
```rust
else {
log::warn!("Unexpected query keys: {:?}", keys);
Err(QueryErrors::InvalidQuery)
}
```
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
}
|
||||
|
Consider improving error handling in The use of Suggested changes to improve error handling: And for the unexpected keys: **Consider improving error handling in `fetch_tasks_in_category`.**
The use of `panic!` for handling unexpected errors (lines 19 and 22) is risky in a production environment as it can cause the application to crash. Consider logging these errors or returning a controlled error response instead.
Suggested changes to improve error handling:
```rust
Err(error) => {
log::error!("Unexpected error: {:?}", error);
Err(QueryErrors::UnexpectedError)
}
```
And for the unexpected keys:
```rust
else {
log::warn!("Unexpected query keys: {:?}", keys);
Err(QueryErrors::InvalidQuery)
}
```
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
|
||||
|
Consider improving error handling in The use of Suggested changes to improve error handling: And for the unexpected keys: **Consider improving error handling in `fetch_tasks_in_category`.**
The use of `panic!` for handling unexpected errors (lines 19 and 22) is risky in a production environment as it can cause the application to crash. Consider logging these errors or returning a controlled error response instead.
Suggested changes to improve error handling:
```rust
Err(error) => {
log::error!("Unexpected error: {:?}", error);
Err(QueryErrors::UnexpectedError)
}
```
And for the unexpected keys:
```rust
else {
log::warn!("Unexpected query keys: {:?}", keys);
Err(QueryErrors::InvalidQuery)
}
```
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
async fn fetch_tasks_in_category(keys: Vec<QueryKey>) -> QueryResult<QueryValue, QueryErrors> {
|
||||
|
Consider improving error handling in The use of Suggested changes to improve error handling: And for the unexpected keys: **Consider improving error handling in `fetch_tasks_in_category`.**
The use of `panic!` for handling unexpected errors (lines 19 and 22) is risky in a production environment as it can cause the application to crash. Consider logging these errors or returning a controlled error response instead.
Suggested changes to improve error handling:
```rust
Err(error) => {
log::error!("Unexpected error: {:?}", error);
Err(QueryErrors::UnexpectedError)
}
```
And for the unexpected keys:
```rust
else {
log::warn!("Unexpected query keys: {:?}", keys);
Err(QueryErrors::InvalidQuery)
}
```
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
if let Some(QueryKey::TasksInCategory(category)) = keys.first() {
|
||||
|
Consider improving error handling in The use of Suggested changes to improve error handling: And for the unexpected keys: **Consider improving error handling in `fetch_tasks_in_category`.**
The use of `panic!` for handling unexpected errors (lines 19 and 22) is risky in a production environment as it can cause the application to crash. Consider logging these errors or returning a controlled error response instead.
Suggested changes to improve error handling:
```rust
Err(error) => {
log::error!("Unexpected error: {:?}", error);
Err(QueryErrors::UnexpectedError)
}
```
And for the unexpected keys:
```rust
else {
log::warn!("Unexpected query keys: {:?}", keys);
Err(QueryErrors::InvalidQuery)
}
```
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
match get_tasks_in_category(category.clone()).await {
|
||||
|
Consider improving error handling in The use of Suggested changes to improve error handling: And for the unexpected keys: **Consider improving error handling in `fetch_tasks_in_category`.**
The use of `panic!` for handling unexpected errors (lines 19 and 22) is risky in a production environment as it can cause the application to crash. Consider logging these errors or returning a controlled error response instead.
Suggested changes to improve error handling:
```rust
Err(error) => {
log::error!("Unexpected error: {:?}", error);
Err(QueryErrors::UnexpectedError)
}
```
And for the unexpected keys:
```rust
else {
log::warn!("Unexpected query keys: {:?}", keys);
Err(QueryErrors::InvalidQuery)
}
```
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
Ok(tasks) => Ok(QueryValue::Tasks(tasks)),
|
||||
|
Consider improving error handling in The use of Suggested changes to improve error handling: And for the unexpected keys: **Consider improving error handling in `fetch_tasks_in_category`.**
The use of `panic!` for handling unexpected errors (lines 19 and 22) is risky in a production environment as it can cause the application to crash. Consider logging these errors or returning a controlled error response instead.
Suggested changes to improve error handling:
```rust
Err(error) => {
log::error!("Unexpected error: {:?}", error);
Err(QueryErrors::UnexpectedError)
}
```
And for the unexpected keys:
```rust
else {
log::warn!("Unexpected query keys: {:?}", keys);
Err(QueryErrors::InvalidQuery)
}
```
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
Err(ServerFnError::WrappedServerError(errors)) => Err(QueryErrors::Error(errors)),
|
||||
|
Consider improving error handling in The use of Suggested changes to improve error handling: And for the unexpected keys: **Consider improving error handling in `fetch_tasks_in_category`.**
The use of `panic!` for handling unexpected errors (lines 19 and 22) is risky in a production environment as it can cause the application to crash. Consider logging these errors or returning a controlled error response instead.
Suggested changes to improve error handling:
```rust
Err(error) => {
log::error!("Unexpected error: {:?}", error);
Err(QueryErrors::UnexpectedError)
}
```
And for the unexpected keys:
```rust
else {
log::warn!("Unexpected query keys: {:?}", keys);
Err(QueryErrors::InvalidQuery)
}
```
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
Err(error) => panic!("Unexpected error: {:?}", error)
|
||||
|
Consider improving error handling in The use of Suggested changes to improve error handling: And for the unexpected keys: **Consider improving error handling in `fetch_tasks_in_category`.**
The use of `panic!` for handling unexpected errors (lines 19 and 22) is risky in a production environment as it can cause the application to crash. Consider logging these errors or returning a controlled error response instead.
Suggested changes to improve error handling:
```rust
Err(error) => {
log::error!("Unexpected error: {:?}", error);
Err(QueryErrors::UnexpectedError)
}
```
And for the unexpected keys:
```rust
else {
log::warn!("Unexpected query keys: {:?}", keys);
Err(QueryErrors::InvalidQuery)
}
```
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
}.into()
|
||||
|
Consider improving error handling in The use of Suggested changes to improve error handling: And for the unexpected keys: **Consider improving error handling in `fetch_tasks_in_category`.**
The use of `panic!` for handling unexpected errors (lines 19 and 22) is risky in a production environment as it can cause the application to crash. Consider logging these errors or returning a controlled error response instead.
Suggested changes to improve error handling:
```rust
Err(error) => {
log::error!("Unexpected error: {:?}", error);
Err(QueryErrors::UnexpectedError)
}
```
And for the unexpected keys:
```rust
else {
log::warn!("Unexpected query keys: {:?}", keys);
Err(QueryErrors::InvalidQuery)
}
```
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
} else {
|
||||
|
Consider improving error handling in The use of Suggested changes to improve error handling: And for the unexpected keys: **Consider improving error handling in `fetch_tasks_in_category`.**
The use of `panic!` for handling unexpected errors (lines 19 and 22) is risky in a production environment as it can cause the application to crash. Consider logging these errors or returning a controlled error response instead.
Suggested changes to improve error handling:
```rust
Err(error) => {
log::error!("Unexpected error: {:?}", error);
Err(QueryErrors::UnexpectedError)
}
```
And for the unexpected keys:
```rust
else {
log::warn!("Unexpected query keys: {:?}", keys);
Err(QueryErrors::InvalidQuery)
}
```
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
panic!("Unexpected query keys: {:?}", keys);
|
||||
|
Consider improving error handling in The use of Suggested changes to improve error handling: And for the unexpected keys: **Consider improving error handling in `fetch_tasks_in_category`.**
The use of `panic!` for handling unexpected errors (lines 19 and 22) is risky in a production environment as it can cause the application to crash. Consider logging these errors or returning a controlled error response instead.
Suggested changes to improve error handling:
```rust
Err(error) => {
log::error!("Unexpected error: {:?}", error);
Err(QueryErrors::UnexpectedError)
}
```
And for the unexpected keys:
```rust
else {
log::warn!("Unexpected query keys: {:?}", keys);
Err(QueryErrors::InvalidQuery)
}
```
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
}
|
||||
|
Consider improving error handling in The use of Suggested changes to improve error handling: And for the unexpected keys: **Consider improving error handling in `fetch_tasks_in_category`.**
The use of `panic!` for handling unexpected errors (lines 19 and 22) is risky in a production environment as it can cause the application to crash. Consider logging these errors or returning a controlled error response instead.
Suggested changes to improve error handling:
```rust
Err(error) => {
log::error!("Unexpected error: {:?}", error);
Err(QueryErrors::UnexpectedError)
}
```
And for the unexpected keys:
```rust
else {
log::warn!("Unexpected query keys: {:?}", keys);
Err(QueryErrors::InvalidQuery)
}
```
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
}
|
||||
|
Consider improving error handling in The use of Suggested changes to improve error handling: And for the unexpected keys: **Consider improving error handling in `fetch_tasks_in_category`.**
The use of `panic!` for handling unexpected errors (lines 19 and 22) is risky in a production environment as it can cause the application to crash. Consider logging these errors or returning a controlled error response instead.
Suggested changes to improve error handling:
```rust
Err(error) => {
log::error!("Unexpected error: {:?}", error);
Err(QueryErrors::UnexpectedError)
}
```
And for the unexpected keys:
```rust
else {
log::warn!("Unexpected query keys: {:?}", keys);
Err(QueryErrors::InvalidQuery)
}
```
<!-- This is an auto-generated comment by CodeRabbit -->
Consider improving error handling in The use of Suggested changes to improve error handling: And for the unexpected keys: **Consider improving error handling in `fetch_tasks_in_category`.**
The use of `panic!` for handling unexpected errors (lines 19 and 22) is risky in a production environment as it can cause the application to crash. Consider logging these errors or returning a controlled error response instead.
Suggested changes to improve error handling:
```rust
Err(error) => {
log::error!("Unexpected error: {:?}", error);
Err(QueryErrors::UnexpectedError)
}
```
And for the unexpected keys:
```rust
else {
log::warn!("Unexpected query keys: {:?}", keys);
Err(QueryErrors::InvalidQuery)
}
```
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
Consider improving error handling in
fetch_tasks_in_category.The use of
panic!for handling unexpected errors (lines 19 and 22) is risky in a production environment as it can cause the application to crash. Consider logging these errors or returning a controlled error response instead.Suggested changes to improve error handling:
And for the unexpected keys:
Consider improving error handling in
fetch_tasks_in_category.The use of
panic!for handling unexpected errors (lines 19 and 22) is risky in a production environment as it can cause the application to crash. Consider logging these errors or returning a controlled error response instead.Suggested changes to improve error handling:
And for the unexpected keys: