Done testing exercise and http exercise by Nacchan

exercise_answers/nacchan/http_exercise.go

@@ -0,0 +1,138 @@
+package main
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"strconv"
+	"strings"
+)
+
+type UserAttributes struct {
+	Id         int    `json:"id"`
+	Name       string `json:"name"`
+	AccountIds []int  `json:"account_ids"`
+}
+
+type AccountAttributes struct {
+	Id      int    `json:"id"`
+	UserId  int    `json:"user_id"`
+	Name    string `json:"name"`
+	Balance int    `json:"balance"`
+}
+
+type UserResponse struct {
+	UserAttributes UserAttributes `json:"attributes"`
+}
+
+type AccountResponse struct {
+	AccountAttributes AccountAttributes `json:"attributes"`
+}
+
+const URL = "https://sample-accounts-api.herokuapp.com/users/"
+
+func main() {
+	var userId int
+	reader := bufio.NewReader(os.Stdin)
+	for {
+		fmt.Println("Enter user id: ")
+		userIdString, err := reader.ReadString('\n')
+		userIdString = strings.TrimSpace(userIdString)
+		userId, err = strconv.Atoi(userIdString)
+		if err != nil {
+			fmt.Println("please enter a valid integer")
+			continue
+		}
+		break
+	}
+
+	user, err := getUser(userId)
+	if err != nil {
+		fmt.Println("Error getting user: ", err)
+		return
+	}
+
+	accounts, err := getAccounts(userId)
+	if err != nil {
+		fmt.Println("Error getting accounts: ", err)
+		return
+	}
+
+	fmt.Println("User: ", user)
+	fmt.Println("Accounts: ")
+	printAccounts(accounts)
+}
+
+func getUser(id int) (string, error) {
+	resp, err := http.Get(URL + strconv.Itoa(id))
+
+	if err != nil {
+		return "", fmt.Errorf("error in making request: %v", err)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("response error: %v", resp.StatusCode)
+	}
+
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", fmt.Errorf("error in reading response body: %v", err)
+	}
+
+	var res UserResponse
+	err = json.Unmarshal(body, &res)
+
+	if err != nil {
+		return "", fmt.Errorf("error in parsing json: %v", err)
+	}
+
+	return res.UserAttributes.Name, nil
+}
+
+func getAccounts(id int) ([]AccountAttributes, error) {
+	resp, err := http.Get(URL + strconv.Itoa(id) + "/accounts")
+
+	if err != nil {
+		return nil, fmt.Errorf("error in making request: %v", err)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("response error: %v", resp.StatusCode)
+	}
+
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("error in reading response body: %v", err)
+	}
+
+	var res []AccountResponse
+	err = json.Unmarshal(body, &res)
+	if err != nil {
+		return nil, fmt.Errorf("error in parsing json: %v", err)
+	}
+
+	var accounts []AccountAttributes = []AccountAttributes{}
+
+	for _, account := range res {
+		accounts = append(accounts, account.AccountAttributes)
+	}
+
+	return accounts, nil
+}
+
+func printAccounts(accounts []AccountAttributes) {
+	var totalBalance int = 0
+
+	for _, account := range accounts {
+		fmt.Println(" -", account.Name, ": ", account.Balance)
+		totalBalance += account.Balance
+	}
+	fmt.Println("Total balance: ", totalBalance)
+}

exercise_answers/nacchan/validator/validator.go

@@ -0,0 +1,17 @@
+package validator
+
+// IsInRange checks if a number is within the specified range (inclusive)
+func IsInRange(num, min, max int) bool {
+	// Check if the number is less than the minimum
+	if num < min {
+		return false
+	}
+
+	// Check if the number is greater than the maximum
+	if num > max {
+		return false
+	}
+
+	// If we get here, the number is within range
+	return true
+}

exercise_answers/nacchan/validator/validator_test.go

@@ -0,0 +1,65 @@
+package validator
+
+import (
+	"testing"
+)
+
+func TestIsInRange(t *testing.T) {
+	tt := []struct {
+		name          string
+		num, min, max int
+		expected      bool
+	}{
+		{
+			name:     "within range",
+			num:      5,
+			min:      1,
+			max:      10,
+			expected: true,
+		},
+		{
+			name:     "below range",
+			num:      0,
+			min:      1,
+			max:      10,
+			expected: false,
+		},
+		{
+			name:     "above range",
+			num:      11,
+			min:      1,
+			max:      10,
+			expected: false,
+		},
+		{
+			name:     "equal to min",
+			num:      1,
+			min:      1,
+			max:      10,
+			expected: true,
+		},
+		{
+			name:     "equal to max",
+			num:      10,
+			min:      1,
+			max:      10,
+			expected: true,
+		},
+		{
+			name:     "zero",
+			num:      0,
+			min:      0,
+			max:      0,
+			expected: true,
+		},
+	}
+
+	for _, tc := range tt {
+		t.Run(tc.name, func(t *testing.T) {
+			result := IsInRange(tc.num, tc.min, tc.max)
+			if result != tc.expected {
+				t.Errorf("expected %v, got %v", tc.expected, result)
+			}
+		})
+	}
+}