Book
- ID
- Title
- Author
- Publisher
- ISBN
- Status (Available, Checked Out)
- Borrower ID (if checked out)
- Due Date (if checked out)

User
- ID
- Name
- Email
- Password
- Role (Admin, User)

BorrowRecord
- ID
- Book ID
- User ID
- Borrow Date
- Return Date

public class User {
    private int id;
    private String username;
    private String password;
    private String email;
    private UserRole role;

    // Конструктор, методы получения и установки
}

public enum UserRole {
    ADMIN,
    USER
}

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class DatabaseConnection {
    private static final String URL = "jdbc:mysql://localhost:3306/library";
    private static final String USERNAME = "root";
    private static final String PASSWORD = "password";

    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(URL, USERNAME, PASSWORD);
    }
}

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class UserDao {
    private Connection connection;

    public UserDao() {
        try {
            connection = DatabaseConnection.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // Добавить пользователя
    public void addUser(User user) {
        String sql = "INSERT INTO users (username, password, email, role) VALUES (?, ?, ?, ?)";
        try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setString(1, user.getUsername());
            preparedStatement.setString(2, user.getPassword());
            preparedStatement.setString(3, user.getEmail());
            preparedStatement.setString(4, user.getRole().toString());

            preparedStatement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // Удалить пользователя
    public void deleteUser(int userId) {
        String sql = "DELETE FROM users WHERE id = ?";
        try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setInt(1, userId);
            preparedStatement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // Запрос пользователей по имени пользователя
    public User getUserByUsername(String username) {
        String sql = "SELECT * FROM users WHERE username = ?";
        try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setString(1, username);
            ResultSet resultSet = preparedStatement.executeQuery();

            if (resultSet.next()) {
                return extractUserFromResultSet(resultSet);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    // Опросить всех пользователей
    public List<User> getAllUsers() {
        List<User> userList = new ArrayList<>();
        String sql = "SELECT * FROM users";
        try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            ResultSet resultSet = preparedStatement.executeQuery();

            while (resultSet.next()) {
                userList.add(extractUserFromResultSet(resultSet));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return userList;
    }

    // Извлечение информации о пользователе из ResultSet
    private User extractUserFromResultSet(ResultSet resultSet) throws SQLException {
        User user = new User();
        user.setId(resultSet.getInt("id"));
        user.setUsername(resultSet.getString("username"));
        user.setPassword(resultSet.getString("password"));
        user.setEmail(resultSet.getString("email"));
        user.setRole(UserRole.valueOf(resultSet.getString("role")));
        return user;
    }
}

public class UserService {
    private UserDao userDao;

    public UserService() {
        userDao = new UserDao();
    }

    // Зарегистрированный пользователь
    public void registerUser(String username, String password, String email, UserRole role) {
        User user = new User();
        user.setUsername(username);
        user.setPassword(password);
        user.setEmail(email);
        user.setRole(role);

        userDao.addUser(user);
    }

    // Удалить пользователя
    public void deleteUser(int userId) {
        userDao.deleteUser(userId);
    }

    // Запрос пользователей по имени пользователя
    public User getUserByUsername(String username) {
        return userDao.getUserByUsername(username);
    }

    // Опросить всех пользователей
    public List<User> getAllUsers() {
        return userDao.getAllUsers();
    }
}

public class Book {
    private int id;
    private String title;
    private String author;
    private String publisher;
    private String isbn;
    private BookStatus status;
    private int borrowerId;
    private LocalDate dueDate;

    // Конструктор, методы получения и установки
}

public enum BookStatus {
    AVAILABLE,
    CHECKED_OUT
}

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class BookDao {
    private Connection connection;

    public BookDao() {
        try {
            connection = DatabaseConnection.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // добавить книгу
    public void addBook(Book book) {
        String sql = "INSERT INTO books (title, author, publisher, isbn, status, borrower_id, due_date) " +
                     "VALUES (?, ?, ?, ?, ?, ?, ?)";
        try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setString(1, book.getTitle());
            preparedStatement.setString(2, book.getAuthor());
            preparedStatement.setString(3, book.getPublisher());
            preparedStatement.setString(4, book.getIsbn());
            preparedStatement.setString(5, book.getStatus().toString());
            preparedStatement.setInt(6, book.getBorrowerId());
            preparedStatement.setDate(7, Date.valueOf(book.getDueDate()));

            preparedStatement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // Удалить книгу
    public void deleteBook(int bookId) {
        String sql = "DELETE FROM books WHERE id = ?";
        try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setInt(1, bookId);
            preparedStatement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // Запрос книг по идентификатору
    public Book getBookById(int bookId) {
        String sql = "SELECT * FROM books WHERE id = ?";
        try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setInt(1, bookId);
            ResultSet resultSet = preparedStatement.executeQuery();

            if (resultSet.next()) {
                return extractBookFromResultSet(resultSet);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    // Искать все книги
    public List<Book> getAllBooks() {
        List<Book> bookList = new ArrayList<>();
        String sql = "SELECT * FROM books";
        try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            ResultSet resultSet = preparedStatement.executeQuery();

            while (resultSet.next()) {
                bookList.add(extractBookFromResultSet(resultSet));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return bookList;
    }

    // Обновить статус книги
    public void updateBookStatus(int bookId, BookStatus status, int borrowerId, LocalDate dueDate) {
        String sql = "UPDATE books SET status = ?, borrower_id = ?, due_date = ? WHERE id = ?";
        try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setString(1, status.toString());
            preparedStatement.setInt(2, borrowerId);
            preparedStatement.setDate(3, Date.valueOf(dueDate));
            preparedStatement.setInt(4, bookId);
            preparedStatement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // Извлечь информацию о книге из ResultSet
    private Book extractBookFromResultSet(ResultSet resultSet) throws SQLException {
        Book book = new Book();
        book.setId(resultSet.getInt("id"));
        book.setTitle(resultSet.getString("title"));
        book.setAuthor(resultSet.getString("author"));
        book.setPublisher(resultSet.getString("publisher"));
        book.setIsbn(resultSet.getString("isbn"));
        book.setStatus(BookStatus.valueOf(resultSet.getString("status")));
        book.setBorrowerId(resultSet.getInt("borrower_id"));
        book.setDueDate(resultSet.getDate("due_date").toLocalDate());
        return book;
    }
}

import java.util.List;

public class BookService {
    private BookDao bookDao;

    public BookService() {
        bookDao = new BookDao();
    }

    // добавить книгу
    public void addBook(String title, String author, String publisher, String isbn) {
        Book book = new Book();
        book.setTitle(title);
        book.setAuthor(author);
        book.setPublisher(publisher);
        book.setIsbn(isbn);
        book.setStatus(BookStatus.AVAILABLE); // Доступно для заимствования по умолчанию

        bookDao.addBook(book);
    }

    // Удалить книгу
    public void deleteBook(int bookId) {
        bookDao.deleteBook(bookId);
    }

    // Запрос книг по идентификатору
    public Book getBookById(int bookId) {
        return bookDao.getBookById(bookId);
    }

    // Искать все книги
    public List<Book> getAllBooks() {
        return bookDao.getAllBooks();
    }

    // Взять книги напрокат
    public void borrowBook(int bookId, int userId, LocalDate dueDate) {
        Book book = bookDao.getBookById(bookId);
        if (book.getStatus() == BookStatus.AVAILABLE) {
            book.setStatus(BookStatus.CHECKED_OUT);
            book.setBorrowerId(userId);
            book.setDueDate(dueDate);
            bookDao.updateBookStatus(bookId, book.getStatus(), book.getBorrowerId(), book.getDueDate());
        }
    }

    // Возврат книг
    public void returnBook(int bookId) {
        Book book = bookDao.getBookById(bookId);
        if (book.getStatus() == BookStatus.CHECKED_OUT) {
            book.setStatus(BookStatus.AVAILABLE);
            book.setBorrowerId(0);
            book.setDueDate(null);
            bookDao.updateBookStatus(bookId, book.getStatus(), book.getBorrowerId(), book.getDueDate());
        }
    }
}

public class BorrowRecord {
    private int id;
    private int bookId;
    private int userId;
    private LocalDate borrowDate;
    private LocalDate returnDate;

    // Конструктор, методы получения и установки
}

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class BorrowRecordDao {
    private Connection connection;

    public BorrowRecordDao() {
        try {
            connection = DatabaseConnection.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // рекордное заимствование
    public void borrowBook(int bookId, int userId, LocalDate borrowDate) {
        String sql = "INSERT INTO borrow_records (book_id, user_id, borrow_date) VALUES (?, ?, ?)";
        try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setInt(1, bookId);
            preparedStatement.setInt(2, userId);
            preparedStatement.setDate(3, Date.valueOf(borrowDate));

            preparedStatement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // рекордный возврат
    public void returnBook(int bookId, LocalDate returnDate) {
        String sql = "UPDATE borrow_records SET return_date = ? WHERE book_id = ?";
        try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setDate(1, Date.valueOf(returnDate));
            preparedStatement.setInt(2, bookId);

            preparedStatement.executeUpdate();
        } catch (SQLException
        e) {
            e.printStackTrace();
        }
    }

    // Запрос записей о займах пользователя
    public List<BorrowRecord> getBorrowRecordsByUserId(int userId) {
        List<BorrowRecord> recordList = new ArrayList<>();
        String sql = "SELECT * FROM borrow_records WHERE user_id = ?";
        try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setInt(1, userId);
            ResultSet resultSet = preparedStatement.executeQuery();

            while (resultSet.next()) {
                recordList.add(extractBorrowRecordFromResultSet(resultSet));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return recordList;
    }

    // Проверьте записи о выдаче книг
    public List<BorrowRecord> getBorrowRecordsByBookId(int bookId) {
        List<BorrowRecord> recordList = new ArrayList<>();
        String sql = "SELECT * FROM borrow_records WHERE book_id = ?";
        try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setInt(1, bookId);
            ResultSet resultSet = preparedStatement.executeQuery();

            while (resultSet.next()) {
                recordList.add(extractBorrowRecordFromResultSet(resultSet));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return recordList;
    }

    // Извлечение информации о записи заимствования из ResultSet
    private BorrowRecord extractBorrowRecordFromResultSet(ResultSet resultSet) throws SQLException {
        BorrowRecord record = new BorrowRecord();
        record.setId(resultSet.getInt("id"));
        record.setBookId(resultSet.getInt("book_id"));
        record.setUserId(resultSet.getInt("user_id"));
        record.setBorrowDate(resultSet.getDate("borrow_date").toLocalDate());
        if (resultSet.getDate("return_date") != null) {
            record.setReturnDate(resultSet.getDate("return_date").toLocalDate());
        }
        return record;
    }
}

import java.util.List;

public class BorrowRecordService {
    private BorrowRecordDao borrowRecordDao;

    public BorrowRecordService() {
        borrowRecordDao = new BorrowRecordDao();
    }

    // рекордное заимствование
    public void borrowBook(int bookId, int userId, LocalDate borrowDate) {
        borrowRecordDao.borrowBook(bookId, userId, borrowDate);
    }

    // рекордный возврат
    public void returnBook(int bookId, LocalDate returnDate) {
        borrowRecordDao.returnBook(bookId, returnDate);
    }

    // Запрос записей о займах пользователя
    public List<BorrowRecord> getBorrowRecordsByUserId(int userId) {
        return borrowRecordDao.getBorrowRecordsByUserId(userId);
    }

    // Проверьте записи о выдаче книг
    public List<BorrowRecord> getBorrowRecordsByBookId(int bookId) {
        return borrowRecordDao.getBorrowRecordsByBookId(bookId);
    }
}

import java.time.LocalDate;
import java.util.List;
import java.util.Scanner;

public class LibraryManagementSystem {
    private UserService userService;
    private BookService bookService;
    private BorrowRecordService borrowRecordService;
    private User currentUser;

    public LibraryManagementSystem() {
        userService = new UserService();
        bookService = new BookService();
        borrowRecordService = new BorrowRecordService();
    }

    public void run() {
        Scanner scanner = new Scanner(System.in);

        while (true) {
            if (currentUser == null) {
                System.out.println("Welcome to the Library Management System!");
                System.out.println("1. Register");
                System.out.println("2. Login");
                System.out.println("3. Exit");
                System.out.print("Please select an option: ");

                int choice = scanner.nextInt();
                scanner.nextLine(); // Consume newline

                switch (choice) {
                    case 1:
                        registerUser(scanner);
                        break;
                    case 2:
                        loginUser(scanner);
                        break;
                    case 3:
                        System.out.println("Goodbye!");
                        return;
                    default:
                        System.out.println("Invalid option. Please try again.");
                        break;
                }
            } else {
                System.out.println("Welcome, " + currentUser.getUsername() + "!");
                System.out.println("1. Add Book");
                System.out.println("2. Borrow Book");
                System.out.println("3. Return Book");
                System.out.println("4. View Borrowed Books");
                System.out.println("5. Logout");
                System.out.print("Please select an option: ");

                int choice = scanner.nextInt();
                scanner.nextLine(); // Consume newline

                switch (choice) {
                    case 1:
                        addBook(scanner);
                        break;
                    case 2:
                        borrowBook(scanner);
                        break;
                    case 3:
                        returnBook(scanner);
                        break;
                    case 4:
                        viewBorrowedBooks();
                        break;
                    case 5:
                        currentUser = null;
                        System.out.println("Logged out successfully.");
                        break;
                    default:
                        System.out.println("Invalid option. Please try again.");
                        break;
                }
            }
        }
    }

    private void registerUser(Scanner scanner) {
        System.out.print("Enter username: ");
        String username = scanner.nextLine();
        System.out.print("Enter password: ");
        String password = scanner.nextLine();
        System.out.print("Enter email: ");
        String email = scanner.nextLine();
        // Assume default role is USER
        UserRole role = UserRole.USER;

        userService.registerUser(username, password, email, role);
        System.out.println("Registration successful. You can now log in.");
    }

    private void loginUser(Scanner scanner) {
        System.out.print("Enter username: ");
        String username = scanner.nextLine();
        System.out.print("Enter password: ");
        String password = scanner.nextLine();

        currentUser = userService.getUserByUsername(username);

        if (currentUser != null && currentUser.getPassword().equals(password)) {
            System.out.println("Login successful. Welcome, " + currentUser.getUsername() + "!");
        } else {
            currentUser = null;
            System.out.println("Login failed. Please check your username and password.");
        }
    }

    private void addBook(Scanner scanner) {
        System.out.print("Enter book title: ");
        String title = scanner.nextLine();
        System.out.print("Enter author: ");
        String author = scanner.nextLine();
        System.out.print("Enter publisher: ");
        String publisher = scanner.nextLine();
        System.out.print("Enter ISBN: ");
        String isbn = scanner.nextLine();

        bookService.addBook(title, author, publisher, isbn);
        System.out.println("Book added successfully.");
    }

    private void borrowBook(Scanner scanner) {
        System.out.print("Enter book ID to borrow: ");
        int bookId = scanner.nextInt();
        scanner.nextLine(); // Consume newline
        LocalDate dueDate = LocalDate.now().plusWeeks(2); // Borrow period of 2 weeks

        bookService.borrowBook(bookId, currentUser.getId(), dueDate);
        System.out.println("Book borrowed successfully.");
    }

    private void returnBook(Scanner scanner) {
        System.out.print("Enter book ID to return: ");
        int bookId = scanner.nextInt();
        scanner.nextLine(); // Consume newline

        bookService.returnBook(bookId);
        System.out.println("Book returned successfully.");
    }

    private void viewBorrowedBooks() {
        List<BorrowRecord> borrowRecords = borrowRecordService.getBorrowRecordsByUserId(currentUser.getId());
        if (borrowRecords.isEmpty()) {
            System.out.println("You have not borrowed any books.");
        } else {
            System.out.println("Your borrowed books:");
            for (BorrowRecord record : borrowRecords) {
                Book book = bookService.getBookById(record.getBookId());
                System.out.println("Book Title: " + book.getTitle());
                System.out.println("Borrow Date: " + record.getBorrowDate
() + "   Due Date: " + record.getDueDate());
                System.out.println("------------------------------------------------");
            }
        }
    }

    public static void main(String[] args) {
        LibraryManagementSystem libraryManagementSystem = new LibraryManagementSystem();
        libraryManagementSystem.run();
    }
}