add exercises

Author: ritika-udacity

L1. API Design Principles/1. Structs/solution/main.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"fmt"
+)
+
+// Create the Rectangle struct
+type Rectangle struct {
+	Width  float64
+	Height float64
+}
+
+// Define Area method
+func (r Rectangle) Area() float64 {
+	return r.Width * r.Height
+}
+
+// Define Perimeter method
+func (r Rectangle) Perimeter() float64 {
+	return 2 * (r.Width + r.Height)
+}
+
+func main() {
+	// Create a new Rectangle
+	rect := Rectangle{
+		Width:  5.0,
+		Height: 10.0,
+	}
+
+	// Print area and perimeter
+	fmt.Printf("Area: %.2f\n", rect.Area())
+	fmt.Printf("Perimeter: %.2f\n", rect.Perimeter())
+}

L1. API Design Principles/1. Structs/starter/README.md

@@ -0,0 +1,13 @@
+# Exercise: Structs
+
+In this exercise, you'll practice creating a struct and adding methods to work with it.
+
+First, navigate to **/L1. API Design Principles/1. Structs/starter/main.go**.
+
+## Instructions:
+
+1. Create a struct called `Rectangle` with two fields: ` Width` and `Height` (both of type `float64`).
+2. Define a method for the `Rectangle` struct called `Area()`, which calculates and returns the area of the rectangle.
+3. Define another method for the `Rectangle` struct called `Perimeter()`, which calculates and returns the perimeter of the rectangle.
+4. In the `main()` function, create a new `Rectangle` with a width of `5.0` and a height of `10.0`.
+5. Print out the area and perimeter of the rectangle using the methods you've defined.

L1. API Design Principles/1. Structs/starter/main.go

@@ -0,0 +1,15 @@
+package main
+
+// TODO: Create the Rectangle struct
+
+
+// TODO: Define Area method
+
+
+// TODO: Define Perimeter method
+
+func main() {
+	// TODO: Create a new Rectangle
+
+	// TODO: Print area and perimeter
+}

L1. API Design Principles/2. Handlers/solution/main.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"encoding/json"
+	"log"
+	"net/http"
+)
+
+func main() {
+	// Register handlers for the routes
+	http.HandleFunc("/", greet)
+	http.HandleFunc("/user", userInfo)
+
+	// Serve on port 8080
+	log.Fatal(http.ListenAndServe(":8080", nil))
+}
+
+// greet responds with a simple greeting message
+func greet(w http.ResponseWriter, r *http.Request) {
+	w.Write([]byte("Welcome to my server!"))
+}
+
+// userInfo responds with a mock user data in JSON format
+func userInfo(w http.ResponseWriter, r *http.Request) {
+	user := struct {
+		Name  string `json:"name"`
+		Age   int    `json:"age"`
+		Email string `json:"email"`
+	}{
+		Name:  "Alice",
+		Age:   25,
+		Email: "[email protected]",
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(user)
+}

L1. API Design Principles/2. Handlers/starter/README.md

@@ -0,0 +1,19 @@
+# Exercise: Handlers
+
+In this exercise, you'll use the `net/http` package to set up a simple web server with two routes: one that returns a greeting message and another that provides mock user data in JSON format.
+
+By the end, your server will handle both plain text and JSON responses, giving you practical experience with HTTP handlers and JSON encoding in Go.
+
+First, navigate to **/L1. API Design Principles/2. Handlers/starter/main.go**.
+
+## Instructions:
+
+1. Uncomment the commented code.
+2. Create two handler functions:
+
+- `greet()`, which responds with a simple greeting message of your choice.
+- `userInfo()`, which responds with a JSON object representing a user with fields for name, age, and email.
+
+3. Make sure to register your handlers using the appropriate `net/http` functions.
+4. Serve your application on port `8080`.
+5. Test your endpoints using a browser, cURL, or Postman to ensure the proper response formats (plain text for the greeting, and JSON for the user information).

L1. API Design Principles/2. Handlers/starter/main.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"log"
+	"net/http"
+)
+
+func main() {
+	// TODO: Register your handlers here
+
+	// TODO: Serve on port 8080
+	log.Fatal(http.ListenAndServe(":8080", nil))
+}
+
+// TODO: Define greet and userInfo handler functions here

L1. API Design Principles/3. Data Validation/solution/main.go

@@ -0,0 +1,69 @@
+package main
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"strings"
+)
+
+func main() {
+	// Set up the route for the register endpoint and start the server on port 8080
+	http.HandleFunc("/register", registerHandler)
+	http.ListenAndServe(":8080", nil)
+}
+
+func registerHandler(w http.ResponseWriter, r *http.Request) {
+	// Ensure that only POST requests are allowed
+	if r.Method != http.MethodPost {
+		http.Error(w, "Invalid request method", http.StatusMethodNotAllowed)
+		return
+	}
+
+	var user User
+	// Decode the JSON body of the request into the User struct
+	err := json.NewDecoder(r.Body).Decode(&user)
+	if err != nil {
+		// If the JSON is malformed or cannot be decoded, return a 400 error
+		http.Error(w, "Invalid JSON data", http.StatusBadRequest)
+		return
+	}
+
+	// Validate the user input data
+	err = validateUser(user)
+	if err != nil {
+		// If validation fails, return a 400 error with the specific error message
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	// If the input is valid, respond with a 200 status and success message
+	w.WriteHeader(http.StatusOK)
+	fmt.Fprintf(w, "Registration successful!")
+}
+
+type User struct {
+	Name  string `json:"name"`
+	Email string `json:"email"`
+	Age   int    `json:"age"`
+}
+
+func validateUser(user User) error {
+	// Check if the name is empty
+	if user.Name == "" {
+		return errors.New("Name cannot be empty")
+	}
+
+	// Check if the email contains an "@" symbol
+	if !strings.Contains(user.Email, "@") {
+		return errors.New("Invalid email address")
+	}
+
+	// Ensure that the age is greater than 18
+	if user.Age <= 18 {
+		return errors.New("Age must be greater than 18")
+	}
+
+	return nil
+}

L1. API Design Principles/3. Data Validation/starter/README.md

@@ -0,0 +1,18 @@
+# Exercise: Data Validation
+
+In this exercise, you'll practice implementing simple data validation on incoming requests in a Go web server. You will set up a basic API that accepts user registration details and responds with a success or error message depending on the validity of the provided data.
+
+First, navigate to **/L1. API Design Principles/3. Data Validation/starter/main.go**.
+
+# Instructions:
+
+1. Create a new register handler function that accepts a POST request with a JSON payload containing `name`, `email`, and `age`.
+2. In your handler, implement the following validation rules:
+
+- The `name` field cannot be empty.
+- The `email` field must contain an `@` symbol.
+- The `age` field must be a number greater than `21`.
+
+3. If any of the data is invalid, return a `400 Bad Request` response with an error message.
+4. If all data is valid, return a `200 OK` response with a success message.
+5. Set up the server to run on port `8080`, and test your validation using tools like cURL or Postman.

L1. API Design Principles/3. Data Validation/starter/main.go

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+func main() {
+	http.HandleFunc("/register", registerHandler)
+	http.ListenAndServe(":8080", nil)
+}
+
+func registerHandler(w http.ResponseWriter, r *http.Request) {
+	// TODO: Implement handler logic
+}
+
+type User struct {
+	Name  string `json:"name"`
+	Email string `json:"email"`
+	Age   int    `json:"age"`
+}
+
+func validateUser(user User) error {
+	// TODO: Implement validation logic
+	return nil
+}

L1. API Design Principles/4. Database Setup/solution/main.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+
+	"gorm.io/driver/postgres"
+	"gorm.io/gorm"
+)
+
+type Task struct {
+	ID          uint   `gorm:"primaryKey"`
+	Title       string
+	Description string
+}
+
+// Declare the database connection
+var db *gorm.DB
+
+func main() {
+	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprintf(w, "Welcome to the Task Manager API!")
+	})
+
+	// Set up a connection to the PostgreSQL database using GORM
+	dsn := "host=localhost user=postgres password=yourpassword dbname=yourdb port=5432 sslmode=disable"
+	var err error
+	db, err = gorm.Open(postgres.Open(dsn), &gorm.Config{})
+	if err != nil {
+		log.Fatal("failed to connect to database:", err)
+	}
+
+	// Auto-migrate the Task model to the database
+	db.AutoMigrate(&Task{})
+
+	log.Println("Server running on port 8080")
+	http.ListenAndServe(":8080", nil)
+}