Desktop app (#21)

* overview

* course modules

* remove sqlite and diesel

* reorder

* added: lessons 01,02,03,04, and exercises tab for the rust chapter

* ownership

* added: new exercise, lessons 07,08,09,10,11,12

* added: on data, lesson 01, 02, on networking 01, 02, 05

* added project ideas

* add slint course

* public apis

---------

Co-authored-by: robertDinca2003 <[email protected]>

Author: cristianaprecup

docs/desktop_applications/05_Networking/03_Fetching-public-apis.md

@@ -0,0 +1,141 @@
+# Fetching Public APIs in Rust 
+
+This guide shows how to fetch public APIs in Rust using `reqwest` and `tokio`.  
+We’ll walk through small examples and explain what’s happening.
+
+---
+
+## 1. Setup
+
+In `Cargo.toml`:
+
+```toml
+[dependencies]
+tokio   = { version = "1", features = ["full"] }
+reqwest = { version = "0.11", features = ["json"] }
+serde   = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+```
+
+**Explanation:**  
+- **tokio**: Async runtime that allows us to write asynchronous code (`async`/`await`).  
+- **reqwest**: HTTP client library for making GET/POST requests.  
+- **serde** and **serde_json**: For converting JSON data into Rust structs automatically.
+
+---
+
+## 2. Fetch a Joke
+
+```rust
+use reqwest::Client;
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize)]
+struct Joke { setup: String, punchline: String }
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let client = Client::new();
+    let url = "https://official-joke-api.appspot.com/random_joke";
+
+    let joke: Joke = client.get(url).send().await?.json().await?;
+
+    println!("{} — {}", joke.setup, joke.punchline);
+    Ok(())
+}
+```
+
+**Explanation:**  
+- We create a `Client` to make HTTP requests.  
+- `client.get(url)` creates a GET request.  
+- `.send().await?` sends the request and waits for the response.  
+- `.json().await?` converts the JSON into our `Joke` struct automatically using `serde`.  
+- We then print the joke’s setup and punchline.
+
+---
+
+## 3. Weather API Example (OpenWeatherMap)
+
+You can sign up for a free API key at [https://openweathermap.org/](https://openweathermap.org/).
+
+```rust
+use reqwest::Client;
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize)]
+struct WeatherResponse {
+    name: String,
+    main: Main,
+    weather: Vec<Weather>,
+}
+
+#[derive(Debug, Deserialize)]
+struct Main { temp: f64 }
+
+#[derive(Debug, Deserialize)]
+struct Weather { description: String }
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let api_key = "YOUR_API_KEY"; // from OpenWeather
+    let city = "London";
+    let url = format!(
+        "https://api.openweathermap.org/data/2.5/weather?q={}&appid={}&units=metric",
+        city, api_key
+    );
+
+    let client = Client::new();
+    let resp: WeatherResponse = client.get(&url).send().await?.json().await?;
+
+    println!("Weather in {}: {}°C, {}",
+        resp.name,
+        resp.main.temp,
+        resp.weather.first().map(|w| &w.description).unwrap_or(&"No data".to_string())
+    );
+
+    Ok(())
+}
+```
+
+**Explanation:**  
+- The `WeatherResponse` struct matches the JSON structure returned by OpenWeather.  
+- We use `format!` to insert the city name and API key into the URL.  
+- The `units=metric` parameter tells the API to return Celsius temperatures.  
+- After parsing the JSON, we display the city name, temperature, and weather description.  
+- Always store your API key in an environment variable in real apps for security.
+
+---
+
+## 4. Fetch a Random Cat Fact
+
+```rust
+use reqwest::Client;
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize)]
+struct CatFact { fact: String }
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let client = Client::new();
+    let url = "https://catfact.ninja/fact";
+
+    let fact: CatFact = client.get(url).send().await?.json().await?;
+    println!("Cat fact: {}", fact.fact);
+    Ok(())
+}
+```
+
+**Explanation:**  
+- This example is almost identical to the joke example but uses another API.  
+- The API returns JSON with a single field, `fact`.  
+- This is perfect for learning because you can easily change the URL and struct to fetch other simple APIs.
+
+---
+
+## General Notes
+
+- **Error handling**: In production, always check if the request succeeded before parsing. Use `.error_for_status()` to catch HTTP errors.  
+- **Performance**: Reuse the same `Client` across requests instead of creating a new one each time.  
+- **Security**: Never hardcode API keys in your source code. Use environment variables or secure config files.  
+- **Data mapping**: Struct field names must match the JSON keys or use `#[serde(rename = "json_key_name")]`.

docs/desktop_applications/05_Networking/04_Network-error-handling.md

@@ -0,0 +1,100 @@
+---
+title: Network Error Handling
+---
+
+---
+
+Network operations are inherently unreliable; connections can fail, servers can be offline, and data can be malformed. In Rust, the **`reqwest`** crate handles these possibilities by returning a `Result` for every operation, allowing you to build robust applications that can gracefully recover from failures. This lesson will show you how to handle these errors, from simple propagation to detailed analysis.
+
+---
+
+### 1\. The `reqwest::Error` Type
+
+All errors from `reqwest` are consolidated into a single, comprehensive **`reqwest::Error`** enum. This error type provides detailed information about what went wrong, including connection issues, HTTP status codes, and serialization failures. You don't need to import `reqwest::Error` explicitly; it's the type returned by `reqwest`'s functions, and the `?` operator works on it automatically.
+
+---
+
+### 2\. Simple Error Handling with `?`
+
+The simplest and most common way to handle a `reqwest` error is with the **`?`** operator. This works because most `reqwest` functions return a `Result<T, reqwest::Error>`. The `?` operator will propagate any error back to the caller, making your code concise.
+
+```rust
+use reqwest;
+use tokio;
+
+#[tokio::main]
+async fn main() -> Result<(), reqwest::Error> {
+    // This will work because main() returns a Result<(), reqwest::Error>
+    // The '?' operator will propagate any error from the get() call.
+    let response = reqwest::get("https://httpbin.org/get").await?;
+
+    // The '?' will also propagate an error if the response body cannot be read.
+    let body = response.text().await?;
+
+    println!("Response body:\n{}", body);
+
+    Ok(())
+}
+```
+
+This is perfect for small applications or for when you simply want to log an error and exit.
+
+---
+
+### 3\. Granular Error Handling with `match`
+
+For more advanced applications, you may want to handle different types of errors differently. For example, a network timeout might be retried, while a "404 Not Found" error might be displayed to the user. You can use a `match` expression or methods on the `reqwest::Error` type to get this level of detail.
+
+The `reqwest::Error` has several useful methods to check for specific error categories:
+
+- **`is_connect()`**: Returns true if the error was a connection issue (e.g., DNS failure, connection refused).
+- **`is_timeout()`**: Returns true if the operation timed out.
+- **`status()`**: Returns the `StatusCode` for non-successful HTTP responses. This is a `Option<StatusCode>`, so you must handle the `Some` and `None` cases.
+- **`is_client_error()`**: Returns true if the status code is a `4xx`.
+- **`is_server_error()`**: Returns true if the status code is a `5xx`.
+- **`is_decode()`**: Returns true if deserializing the response body (e.g., JSON) failed.
+
+<!-- end list -->
+
+```rust
+use reqwest::{self, StatusCode};
+use tokio;
+
+#[tokio::main]
+async fn main() {
+    let response = reqwest::get("https://httpbin.org/status/404").await;
+
+    match response {
+        Ok(res) => {
+            // Check if the status code indicates a success (200-299)
+            if res.status().is_success() {
+                println!("Request was successful!");
+            } else {
+                // If the status is not a success, you can handle it here.
+                println!("HTTP Error: {}", res.status());
+
+                // You can also match on the status code itself.
+                match res.status() {
+                    StatusCode::NOT_FOUND => println!("The resource was not found (404)"),
+                    StatusCode::UNAUTHORIZED => println!("Authentication failed (401)"),
+                    _ => println!("An unexpected HTTP error occurred."),
+                }
+            }
+        },
+        Err(e) => {
+            // Check for different kinds of network errors.
+            if e.is_connect() {
+                println!("A connection error occurred. Is the server running?");
+            } else if e.is_timeout() {
+                println!("The request timed out. Please check your network.");
+            } else if e.is_decode() {
+                println!("Failed to decode the response body. Is the format correct?");
+            } else {
+                println!("An unexpected request error occurred: {:?}", e);
+            }
+        },
+    }
+}
+```
+
+This granular approach gives you full control, allowing you to implement specific logic for each potential failure point.