Add solution for Challenge 7 by livingpool (#1882)

Auto-merged after 2 days with all checks passing.

PR: #1882
Author: @livingpool

Author: livingpool

challenge-7/submissions/livingpool/solution-template.go

@@ -0,0 +1,138 @@
+// Package challenge7 contains the solution for Challenge 7: Bank Account with Error Handling.
+package challenge7
+
+import (
+	"fmt"
+	"sync"
+	// Add any other necessary imports
+)
+
+// BankAccount represents a bank account with balance management and minimum balance requirements.
+type BankAccount struct {
+	ID         string
+	Owner      string
+	Balance    float64
+	MinBalance float64
+	mu         sync.Mutex // For thread safety
+}
+
+// Constants for account operations
+const (
+	MaxTransactionAmount = 10000.0 // Example limit for deposits/withdrawals
+)
+
+// Custom error types
+
+// AccountError is a general error type for bank account operations.
+type AccountError struct {
+	StatusCode int
+	Message    string
+}
+
+func (e *AccountError) Error() string {
+	// Implement error message
+	return fmt.Sprintf("Account Error, code=%d, message=%s", e.StatusCode, e.Message)
+}
+
+// InsufficientFundsError occurs when a withdrawal or transfer would bring the balance below minimum.
+type InsufficientFundsError struct {
+	// Implement this error type
+}
+
+func (e *InsufficientFundsError) Error() string {
+	// Implement error message
+	return ""
+}
+
+// NegativeAmountError occurs when an amount for deposit, withdrawal, or transfer is negative.
+type NegativeAmountError struct {
+	// Implement this error type
+}
+
+func (e *NegativeAmountError) Error() string {
+	// Implement error message
+	return ""
+}
+
+// ExceedsLimitError occurs when a deposit or withdrawal amount exceeds the defined limit.
+type ExceedsLimitError struct {
+	// Implement this error type
+}
+
+func (e *ExceedsLimitError) Error() string {
+	// Implement error message
+	return ""
+}
+
+// NewBankAccount creates a new bank account with the given parameters.
+// It returns an error if any of the parameters are invalid.
+func NewBankAccount(id, owner string, initialBalance, minBalance float64) (*BankAccount, error) {
+	if id == "" || owner == "" {
+		return nil, &AccountError{}
+	}
+	if minBalance < 0 || initialBalance < 0 {
+		return nil, &NegativeAmountError{}
+	}
+	if initialBalance < minBalance {
+		return nil, &InsufficientFundsError{}
+	}
+	return &BankAccount{ID: id, Owner: owner, Balance: initialBalance, MinBalance: minBalance, mu: sync.Mutex{}}, nil
+}
+
+// Deposit adds the specified amount to the account balance.
+// It returns an error if the amount is invalid or exceeds the transaction limit.
+func (a *BankAccount) Deposit(amount float64) error {
+	// Implement deposit functionality with proper error handling
+	if amount < 0 {
+		return &NegativeAmountError{}
+	}
+	if amount > MaxTransactionAmount {
+		return &ExceedsLimitError{}
+	}
+	a.mu.Lock()
+	a.Balance += amount
+	a.mu.Unlock()
+
+	return nil
+}
+
+// Withdraw removes the specified amount from the account balance.
+// It returns an error if the amount is invalid, exceeds the transaction limit,
+// or would bring the balance below the minimum required balance.
+func (a *BankAccount) Withdraw(amount float64) error {
+	// Implement withdrawal functionality with proper error handling
+	if amount < 0 {
+		return &NegativeAmountError{}
+	}
+	if amount > MaxTransactionAmount {
+		return &ExceedsLimitError{}
+	}
+	if a.Balance-amount < a.MinBalance {
+		return &InsufficientFundsError{}
+	}
+	a.mu.Lock()
+	a.Balance -= amount
+	a.mu.Unlock()
+	return nil
+}
+
+// Transfer moves the specified amount from this account to the target account.
+// It returns an error if the amount is invalid, exceeds the transaction limit,
+// or would bring the balance below the minimum required balance.
+func (a *BankAccount) Transfer(amount float64, target *BankAccount) error {
+	// Implement transfer functionality with proper error handling
+	if amount < 0 {
+		return &NegativeAmountError{}
+	}
+	if amount > MaxTransactionAmount {
+		return &ExceedsLimitError{}
+	}
+	if a.Balance-amount < a.MinBalance {
+		return &InsufficientFundsError{}
+	}
+	a.mu.Lock()
+	a.Balance -= amount
+	target.Balance += amount
+	a.mu.Unlock()
+	return nil
+}