feat: ability to create a project #9
@ -7,11 +7,6 @@ use diesel::{RunQueryDsl, SelectableHelper};
|
||||
|
|
||||
use dioxus::prelude::*;
|
||||
use validator::Validate;
|
||||
|
||||
#[server]
|
||||
Ensure proper error handling for database connections. The **Ensure proper error handling for database connections.**
The `establish_database_connection` function call should handle potential errors instead of assuming a successful connection. Consider using `Result` to propagate errors.
```rust
let connection = establish_database_connection().map_err(|e| {
eprintln!("Failed to connect to the database: {}", e);
ServerFnError::from(e)
})?;
```
<!-- This is an auto-generated comment by CodeRabbit -->
Avoid using Using **Avoid using `expect` for error handling in production code.**
Using `expect` can cause the program to panic on errors. Consider using proper error handling to return a meaningful error message.
```rust
.get_result(&mut connection)
.map_err(|e| {
eprintln!("Error saving a new project: {}", e);
ServerFnError::from(e)
})
```
<!-- This is an auto-generated comment by CodeRabbit -->
Avoid using Using **Avoid using `expect` for error handling in production code.**
Using `expect` can cause the program to panic on errors. Consider using proper error handling to return a meaningful error message.
```rust
.get_result(&mut connection)
.map_err(|e| {
eprintln!("Error saving a new project: {}", e);
ServerFnError::from(e)
})
```
<!-- This is an auto-generated comment by CodeRabbit -->
Consider removing the The **Consider removing the `testing` function.**
The `testing` function is a simple utility that adds 1 to the input. If it's not used in production, consider removing it to keep the codebase clean.
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
pub(crate) async fn testing(input: i32) -> Result<i32, ServerFnError> {
|
||||
|
Ensure proper error handling for database connections. The **Ensure proper error handling for database connections.**
The `establish_database_connection` function call should handle potential errors instead of assuming a successful connection. Consider using `Result` to propagate errors.
```rust
let connection = establish_database_connection().map_err(|e| {
eprintln!("Failed to connect to the database: {}", e);
ServerFnError::from(e)
})?;
```
<!-- This is an auto-generated comment by CodeRabbit -->
Avoid using Using **Avoid using `expect` for error handling in production code.**
Using `expect` can cause the program to panic on errors. Consider using proper error handling to return a meaningful error message.
```rust
.get_result(&mut connection)
.map_err(|e| {
eprintln!("Error saving a new project: {}", e);
ServerFnError::from(e)
})
```
<!-- This is an auto-generated comment by CodeRabbit -->
Avoid using Using **Avoid using `expect` for error handling in production code.**
Using `expect` can cause the program to panic on errors. Consider using proper error handling to return a meaningful error message.
```rust
.get_result(&mut connection)
.map_err(|e| {
eprintln!("Error saving a new project: {}", e);
ServerFnError::from(e)
})
```
<!-- This is an auto-generated comment by CodeRabbit -->
Consider removing the The **Consider removing the `testing` function.**
The `testing` function is a simple utility that adds 1 to the input. If it's not used in production, consider removing it to keep the codebase clean.
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
Ok(input + 1)
|
||||
|
Ensure proper error handling for database connections. The **Ensure proper error handling for database connections.**
The `establish_database_connection` function call should handle potential errors instead of assuming a successful connection. Consider using `Result` to propagate errors.
```rust
let connection = establish_database_connection().map_err(|e| {
eprintln!("Failed to connect to the database: {}", e);
ServerFnError::from(e)
})?;
```
<!-- This is an auto-generated comment by CodeRabbit -->
Avoid using Using **Avoid using `expect` for error handling in production code.**
Using `expect` can cause the program to panic on errors. Consider using proper error handling to return a meaningful error message.
```rust
.get_result(&mut connection)
.map_err(|e| {
eprintln!("Error saving a new project: {}", e);
ServerFnError::from(e)
})
```
<!-- This is an auto-generated comment by CodeRabbit -->
Avoid using Using **Avoid using `expect` for error handling in production code.**
Using `expect` can cause the program to panic on errors. Consider using proper error handling to return a meaningful error message.
```rust
.get_result(&mut connection)
.map_err(|e| {
eprintln!("Error saving a new project: {}", e);
ServerFnError::from(e)
})
```
<!-- This is an auto-generated comment by CodeRabbit -->
Consider removing the The **Consider removing the `testing` function.**
The `testing` function is a simple utility that adds 1 to the input. If it's not used in production, consider removing it to keep the codebase clean.
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
}
|
||||
|
Ensure proper error handling for database connections. The **Ensure proper error handling for database connections.**
The `establish_database_connection` function call should handle potential errors instead of assuming a successful connection. Consider using `Result` to propagate errors.
```rust
let connection = establish_database_connection().map_err(|e| {
eprintln!("Failed to connect to the database: {}", e);
ServerFnError::from(e)
})?;
```
<!-- This is an auto-generated comment by CodeRabbit -->
Avoid using Using **Avoid using `expect` for error handling in production code.**
Using `expect` can cause the program to panic on errors. Consider using proper error handling to return a meaningful error message.
```rust
.get_result(&mut connection)
.map_err(|e| {
eprintln!("Error saving a new project: {}", e);
ServerFnError::from(e)
})
```
<!-- This is an auto-generated comment by CodeRabbit -->
Avoid using Using **Avoid using `expect` for error handling in production code.**
Using `expect` can cause the program to panic on errors. Consider using proper error handling to return a meaningful error message.
```rust
.get_result(&mut connection)
.map_err(|e| {
eprintln!("Error saving a new project: {}", e);
ServerFnError::from(e)
})
```
<!-- This is an auto-generated comment by CodeRabbit -->
Consider removing the The **Consider removing the `testing` function.**
The `testing` function is a simple utility that adds 1 to the input. If it's not used in production, consider removing it to keep the codebase clean.
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
|
||||
|
Ensure proper error handling for database connections. The **Ensure proper error handling for database connections.**
The `establish_database_connection` function call should handle potential errors instead of assuming a successful connection. Consider using `Result` to propagate errors.
```rust
let connection = establish_database_connection().map_err(|e| {
eprintln!("Failed to connect to the database: {}", e);
ServerFnError::from(e)
})?;
```
<!-- This is an auto-generated comment by CodeRabbit -->
Avoid using Using **Avoid using `expect` for error handling in production code.**
Using `expect` can cause the program to panic on errors. Consider using proper error handling to return a meaningful error message.
```rust
.get_result(&mut connection)
.map_err(|e| {
eprintln!("Error saving a new project: {}", e);
ServerFnError::from(e)
})
```
<!-- This is an auto-generated comment by CodeRabbit -->
Avoid using Using **Avoid using `expect` for error handling in production code.**
Using `expect` can cause the program to panic on errors. Consider using proper error handling to return a meaningful error message.
```rust
.get_result(&mut connection)
.map_err(|e| {
eprintln!("Error saving a new project: {}", e);
ServerFnError::from(e)
})
```
<!-- This is an auto-generated comment by CodeRabbit -->
Consider removing the The **Consider removing the `testing` function.**
The `testing` function is a simple utility that adds 1 to the input. If it's not used in production, consider removing it to keep the codebase clean.
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
#[server]
|
||||
pub(crate) async fn create_project(
|
||||
new_project: NewProject,
|
||||
|
||||
|
Ensure proper error handling for database connections. The **Ensure proper error handling for database connections.**
The `establish_database_connection` function call should handle potential errors instead of assuming a successful connection. Consider using `Result` to propagate errors.
```rust
let connection = establish_database_connection().map_err(|e| {
eprintln!("Failed to connect to the database: {}", e);
ServerFnError::from(e)
})?;
```
<!-- This is an auto-generated comment by CodeRabbit -->
Avoid using Using **Avoid using `expect` for error handling in production code.**
Using `expect` can cause the program to panic on errors. Consider using proper error handling to return a meaningful error message.
```rust
.get_result(&mut connection)
.map_err(|e| {
eprintln!("Error saving a new project: {}", e);
ServerFnError::from(e)
})
```
<!-- This is an auto-generated comment by CodeRabbit -->
Ensure proper error handling for database connections. The **Ensure proper error handling for database connections.**
The `establish_database_connection` function call should handle potential errors instead of assuming a successful connection. Consider using `Result` to propagate errors.
```rust
let connection = establish_database_connection().map_err(|e| {
eprintln!("Failed to connect to the database: {}", e);
ServerFnError::from(e)
})?;
```
<!-- This is an auto-generated comment by CodeRabbit -->
Avoid using Using **Avoid using `expect` for error handling in production code.**
Using `expect` can cause the program to panic on errors. Consider using proper error handling to return a meaningful error message.
```rust
.get_result(&mut connection)
.map_err(|e| {
eprintln!("Error saving a new project: {}", e);
ServerFnError::from(e)
})
```
<!-- This is an auto-generated comment by CodeRabbit -->
Avoid using Using **Avoid using `expect` for error handling in production code.**
Using `expect` can cause the program to panic on errors. Consider using proper error handling to return a meaningful error message.
```rust
.get_result(&mut connection)
.map_err(|e| {
eprintln!("Error saving a new project: {}", e);
ServerFnError::from(e)
})
```
<!-- This is an auto-generated comment by CodeRabbit -->
Avoid using Using **Avoid using `expect` for error handling in production code.**
Using `expect` can cause the program to panic on errors. Consider using proper error handling to return a meaningful error message.
```rust
.get_result(&mut connection)
.map_err(|e| {
eprintln!("Error saving a new project: {}", e);
ServerFnError::from(e)
})
```
<!-- This is an auto-generated comment by CodeRabbit -->
Consider removing the The **Consider removing the `testing` function.**
The `testing` function is a simple utility that adds 1 to the input. If it's not used in production, consider removing it to keep the codebase clean.
<!-- This is an auto-generated comment by CodeRabbit -->
Consider removing the The **Consider removing the `testing` function.**
The `testing` function is a simple utility that adds 1 to the input. If it's not used in production, consider removing it to keep the codebase clean.
<!-- This is an auto-generated comment by CodeRabbit -->
|
||||
Ensure proper error handling for database connections.
The
establish_database_connectionfunction call should handle potential errors instead of assuming a successful connection. Consider usingResultto propagate errors.Avoid using
expectfor error handling in production code.Using
expectcan cause the program to panic on errors. Consider using proper error handling to return a meaningful error message.Ensure proper error handling for database connections.
The
establish_database_connectionfunction call should handle potential errors instead of assuming a successful connection. Consider usingResultto propagate errors.Avoid using
expectfor error handling in production code.Using
expectcan cause the program to panic on errors. Consider using proper error handling to return a meaningful error message.Avoid using
expectfor error handling in production code.Using
expectcan cause the program to panic on errors. Consider using proper error handling to return a meaningful error message.Avoid using
expectfor error handling in production code.Using
expectcan cause the program to panic on errors. Consider using proper error handling to return a meaningful error message.Consider removing the
testingfunction.The
testingfunction is a simple utility that adds 1 to the input. If it's not used in production, consider removing it to keep the codebase clean.Consider removing the
testingfunction.The
testingfunction is a simple utility that adds 1 to the input. If it's not used in production, consider removing it to keep the codebase clean.