Class Diagrams — Structure of Your System

from abc import ABC, abstractmethod
from dataclasses import dataclass, field
from datetime import date, timedelta
from enum import Enum
from typing import List, Optional


# UML Enum → Python Enum
class BookStatus(Enum):
    AVAILABLE = "available"
    BORROWED = "borrowed"
    RESERVED = "reserved"
    LOST = "lost"


# UML <<interface>> → Python ABC
class Searchable(ABC):
    @abstractmethod
    def search(self, query: str) -> list:
        pass


class Book(Searchable):
    """UML: Book implements Searchable, depends on BookStatus."""

    def __init__(self, title: str, isbn: str, author: str):
        self._title = title                # UML: - title : String  (private)
        self._isbn = isbn                  # UML: - isbn : String
        self._author = author              # UML: - author : String
        self._status = BookStatus.AVAILABLE # UML: - status : BookStatus

    def get_title(self) -> str:            # UML: + getTitle() : String
        return self._title

    def is_available(self) -> bool:        # UML: + isAvailable() : boolean
        return self._status == BookStatus.AVAILABLE

    def mark_as_borrowed(self) -> None:    # UML: + markAsBorrowed() : void
        self._status = BookStatus.BORROWED

    def mark_as_returned(self) -> None:
        self._status = BookStatus.AVAILABLE

    def search(self, query: str) -> list:
        query_lower = query.lower()
        if query_lower in self._title.lower() or query_lower in self._author.lower():
            return [self]
        return []


class Fine:
    """UML: Fine — created by Loan (dependency)."""

    def __init__(self, amount: float):
        self._amount = amount
        self._paid = False
        self._issue_date = date.today()

    def pay(self) -> None:
        self._paid = True

    def get_amount(self) -> float:
        return self._amount


class Loan:
    """UML: Loan has composition with DueDate, association with Book.
    Multiplicity: each Loan references exactly 1 Book."""

    DAILY_FINE_RATE = 0.50

    def __init__(self, book: Book, borrow_date: date, loan_days: int = 14):
        self._book = book                              # Association: 1-to-1
        self._borrow_date = borrow_date
        self._due_date = borrow_date + timedelta(days=loan_days)  # Composition
        self._return_date: Optional[date] = None
        self._returned = False

    def is_overdue(self) -> bool:
        if self._returned:
            return False
        return date.today() > self._due_date

    def calculate_fine(self) -> float:
        """Dependency: Loan uses Fine temporarily."""
        if not self.is_overdue():
            return 0.0
        check_date = self._return_date if self._returned else date.today()
        overdue_days = (check_date - self._due_date).days
        return overdue_days * self.DAILY_FINE_RATE

    def mark_returned(self) -> None:
        self._returned = True
        self._return_date = date.today()
        self._book.mark_as_returned()


class Member:
    """UML: Member has * Loans (one-to-many association)."""

    def __init__(self, name: str, member_id: str, email: str):
        self._name = name
        self._member_id = member_id
        self._email = email
        self._active_loans: List[Loan] = []  # Multiplicity: *

    def borrow_book(self, book: Book) -> Loan:
        if not book.is_available():
            raise ValueError(f"Book '{book.get_title()}' is not available")
        book.mark_as_borrowed()
        loan = Loan(book, date.today())
        self._active_loans.append(loan)
        return loan

    def return_book(self, loan: Loan) -> Optional[Fine]:
        loan.mark_returned()
        self._active_loans.remove(loan)
        fine_amount = loan.calculate_fine()
        if fine_amount > 0:
            return Fine(fine_amount)
        return None

    def get_active_loans(self) -> List[Loan]:
        return list(self._active_loans)


class Librarian(Member):
    """UML: Librarian inherits from Member (generalization)."""

    def __init__(self, name: str, member_id: str, email: str, employee_id: str):
        super().__init__(name, member_id, email)
        self._employee_id = employee_id

    def add_book(self, book: Book) -> None:
        print(f"Book '{book.get_title()}' added to catalog")

    def register_member(self, member: Member) -> None:
        print(f"Member '{member._name}' registered")

    def collect_fine(self, fine: Fine) -> None:
        fine.pay()
        print(f"Fine of ${fine.get_amount():.2f} collected")


# --- Usage ---
book = Book("Clean Code", "978-0132350884", "Robert C. Martin")
member = Member("Alice", "M-001", "alice@example.com")
librarian = Librarian("Bob", "M-002", "bob@example.com", "E-101")

librarian.add_book(book)
loan = member.borrow_book(book)
print(f"Borrowed: {book.get_title()}, Available: {book.is_available()}")
print(f"Active loans: {len(member.get_active_loans())}")

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.List;

// UML Enum → Java Enum
enum BookStatus {
    AVAILABLE, BORROWED, RESERVED, LOST
}

// UML <<interface>> → Java Interface
interface Searchable {
    List<Book> search(String query);
}

class Book implements Searchable {
    private String title;           // UML: - title : String
    private String isbn;            // UML: - isbn : String
    private String author;          // UML: - author : String
    private BookStatus status;      // UML: - status : BookStatus

    public Book(String title, String isbn, String author) {
        this.title = title;
        this.isbn = isbn;
        this.author = author;
        this.status = BookStatus.AVAILABLE;
    }

    public String getTitle() { return title; }        // UML: + getTitle() : String
    public boolean isAvailable() {                    // UML: + isAvailable() : boolean
        return status == BookStatus.AVAILABLE;
    }
    public void markAsBorrowed() { status = BookStatus.BORROWED; }
    public void markAsReturned() { status = BookStatus.AVAILABLE; }

    @Override
    public List<Book> search(String query) {
        List<Book> results = new ArrayList<>();
        if (title.toLowerCase().contains(query.toLowerCase())
                || author.toLowerCase().contains(query.toLowerCase())) {
            results.add(this);
        }
        return results;
    }
}

class Fine {
    private double amount;
    private boolean paid;
    private LocalDate issueDate;

    public Fine(double amount) {
        this.amount = amount;
        this.paid = false;
        this.issueDate = LocalDate.now();
    }

    public void pay() { this.paid = true; }
    public double getAmount() { return amount; }
}

class Loan {
    private static final double DAILY_FINE_RATE = 0.50;
    private Book book;                    // Association: 1-to-1
    private LocalDate borrowDate;
    private LocalDate dueDate;            // Composition: part of Loan
    private LocalDate returnDate;
    private boolean returned;

    public Loan(Book book, LocalDate borrowDate, int loanDays) {
        this.book = book;
        this.borrowDate = borrowDate;
        this.dueDate = borrowDate.plusDays(loanDays);
        this.returned = false;
    }

    public boolean isOverdue() {
        if (returned) return false;
        return LocalDate.now().isAfter(dueDate);
    }

    public double calculateFine() {
        if (!isOverdue()) return 0.0;
        LocalDate checkDate = returned ? returnDate : LocalDate.now();
        long overdueDays = ChronoUnit.DAYS.between(dueDate, checkDate);
        return overdueDays * DAILY_FINE_RATE;
    }

    public void markReturned() {
        this.returned = true;
        this.returnDate = LocalDate.now();
        this.book.markAsReturned();
    }
}

class Member {
    private String name;
    private String memberId;
    private String email;
    private List<Loan> activeLoans;      // Multiplicity: *

    public Member(String name, String memberId, String email) {
        this.name = name;
        this.memberId = memberId;
        this.email = email;
        this.activeLoans = new ArrayList<>();
    }

    public Loan borrowBook(Book book) {
        if (!book.isAvailable()) {
            throw new IllegalStateException("Book '" + book.getTitle() + "' is not available");
        }
        book.markAsBorrowed();
        Loan loan = new Loan(book, LocalDate.now(), 14);
        activeLoans.add(loan);
        return loan;
    }

    public Fine returnBook(Loan loan) {
        loan.markReturned();
        activeLoans.remove(loan);
        double fineAmount = loan.calculateFine();
        if (fineAmount > 0) {
            return new Fine(fineAmount);
        }
        return null;
    }

    public List<Loan> getActiveLoans() {
        return new ArrayList<>(activeLoans);
    }

    protected String getName() { return name; }
}

class Librarian extends Member {          // Inheritance: Librarian IS-A Member
    private String employeeId;

    public Librarian(String name, String memberId, String email, String employeeId) {
        super(name, memberId, email);
        this.employeeId = employeeId;
    }

    public void addBook(Book book) {
        System.out.println("Book '" + book.getTitle() + "' added to catalog");
    }

    public void registerMember(Member member) {
        System.out.println("Member '" + member.getName() + "' registered");
    }

    public void collectFine(Fine fine) {
        fine.pay();
        System.out.printf("Fine of $%.2f collected%n", fine.getAmount());
    }
}