BookDAO

package org.app
package dao

import models.BookModel

import scala.collection.mutable.ListBuffer

//图书，数据操作
class BookDAO {
  //加载图书，从文件中读入
  def loadBooks(): ListBuffer[BookModel] = {
    val books = new ListBuffer[BookModel]()
    val source =scala.io.Source.fromFile("books.txt")
    for (line <- source.getLines()){
      val Array(id, name, author,available) = line.split(",")
      //
       books += BookModel(id.toInt, name, author, available.toBoolean)
    }
    //关闭连接
    source.close()
    books
  }

//保存图书，将图书写入文件
def saveBooks(books:ListBuffer[BookModel]):Unilt ={
	val writer = new java.io.PrintWriter(new java.io.File("books.txt"))
	for(book <- books){
	writer.println(book.id + "," + book.name + "," + book.author + "," + book.available)
}
writer.close()
}
}

BorrowRecordDAO

package org.app
package dao

import org.app.models.BorrowRecordModel

import scala.collection.mutable.ListBuffer
import scala.io.Source

class BorrowRecordDAO{
  // 读出借阅记录
  def loadBorrowRecords(): ListBuffer[BorrowRecordModel] = {
    val borrowRecords = ListBuffer[BorrowRecordModel]()
    val lines = Source.fromFile("borrow_records.txt")
    for(line <- lines.getLines()){
      val parts = line.split(",")

      borrowRecords += BorrowRecordModel(
        parts(0),
        parts(1).toInt,
        parts(2),
        parts(3),
        if(parts.length>4)Some(parts(4))else None
      )
      //      val Array(userName,bookID,bookName,borrowDate,returnDate) = line.split(",")
      //      borrowRecords += BorrowRecordModel(userName,bookID.toInt,bookName,borrowDate,Some(returnDate))
    }
    borrowRecords
  }

  // 写入借阅记录
  def saveBorrowRecords(records: ListBuffer[BorrowRecordModel]): Unit = {
    val writer = new java.io.PrintWriter("borrow_records.txt")
    for(record <- records){
      writer.println(record.userName+","+record.bookID+","+record.bookName+","+record.borrowDate+","+record.returnDate.getOrElse(""))
    }
    writer.close()
  }
}

package org.app
package dao

import models.UserModel

import scala.collection.mutable.ListBuffer

class UserDAO {


  //加载所有的用户
  def loadUsers():List[UserModel]={
    val books = new ListBuffer[UserModel]()
    val source = scala.io.Source.fromFile("books.txt")
    for (line <- source.getLines()) {
      val Array(username,password,role) = line.split(",")
      //
      books += UserModel(username,password,role)
    }
    //关闭连接
    source.close()
    users
  }
}

BookModel

package org.app
package models

//图书类
//id,书名，作者，available:是否外借
case class BookModel(id:Int,name:String,author:String,available:Boolean) {
  override def toString:String = {
    val availableStr = if(available) "可外借" else "已借出"
    s"编号：$id \t $name \t $author，$availableStr"
  }

}

BorrowRecordModel

package org.app
package models

//借阅记录类
case class BorrowRecordModel (
  userName: String,   //借书人
  bookID:Int,          //书籍ID
  bookName: String,      //书籍名称
  borrowDate: String,      //借书日期
  returnDate: Option[String] = None       //还书日期
                             )

UsreModel

package org.app
package models

case class UserModel (
                     username:String,
                       password:String,
                     role:String //普通用户
                     ){


}

BookService

package org.app
package service

import org.app.dao.{BookDAO, BorrowRecordDAO}
import org.app.models.{BookModel, BorrowRecordModel}

import java.time.{LocalDate, LocalDateTime}
import scala.collection.mutable.ListBuffer



//图书业务逻辑层
class BookService {
    private val bookDAO = new BookDAO()
    private val borrowRecordDAO = new BorrowRecordDAO()
  //查询所有图书
//  def searchBooks(query: String): List[Book对象] = {
def searchBooks(query: String): ListBuffer[BookModel] = {
  //从文本文件中读取书本信息，并保存列表中，返回

   val books =  bookDAO.loadBooks()
query match {
  case "" => books
  case _ => books.filter(b =>b.name.contains(query) || b.author.contains(query))//有条件，就过滤
}
}
//普通用户，借阅图书
def borrowBook(username:String,bookId:Int):Boolean ={
//service//1，根据图书的·ID查询图书，判断图书书否存
 val books =  bookDAO.loadBooks()
  val records =borrowRecordDAO.loadBorrowRecords()
 val book = books.find(b =>b.id == bookId)
 if(book.nonEmpty){
 val b = book.get
//2.判断图书是否被借出
if(book.get.available){
  val b = book.get
//3.借阅图书
//更新这本书的状态
val b.available = false
//把更新之后的图书信息写回txt文件中
bookDAO.saveBooks(books)
//TODO 添加一条借书的记录
  //读出当前全部记录
  //添加一条
  records += BorrowRecordModel(username,b.id,b.name,LocalDateTime.now().toString)
  //写回文件
borrowRecordDAO.saveBorrowRecords(records)
println("借阅成功")
true
}else{
println("这本书被借走了")
 false
}
}else {
   false
 }
}
}

UserService

package org.app
package service

import dao.UserDAO

import org.app.models.UserModel

class UserService {
  private val userDAO = new UserDAO()
  //身份校验
  def authenticateUser(username:String,password:String):Option[UserModel]={
    //根据用户名和密码查询，是否符合要求
    val users = userDAO.loadUsers()
    users.find(user=>user.username==username&&user.password==password)
  }

}

library

package org.app
package ui

import org.app.models.UserModel
import org.app.service.{BookService, UserService}

import scala.io.StdIn
import scala.io.StdIn.readLine

class library {

  private val BookService = new BookService()
  private val UserService = new UserService()
  // 显示游客的菜单
  def showVisitorMenu(): Unit = {
    var running = true
    while (running) {
      println("欢迎来到我的图书管理系统, 请选择")
      println("1. 查看所有图书")
      println("2. 查询图书")
      println("3. 登录")
      println("4. 离开")

      // 获取用户的操作
      val choice = StdIn.readLine().trim
      choice match {
        case "1" =>
          // 调用业务逻辑层的方法
          val results = BookService.searchBooks("")
          if(results.nonEmpty){
            results.foreach(println)
          } else {
            println("没有找到图书")
          }
        case "2" =>
          // 提示用户输入查询关键字
          val query = readLine("请输入查询关键字(书名，作者):").trim
          // 根据关键字去查询图书列表，找到满足条件的书
          val results = BookService.searchBooks(query)
          // 显示出来
          if(results.nonEmpty){
            println("=======查询图书的结果：=======")
            results.foreach(println)
          } else {
            println("没有找到图书")
          }
        case "3" =>
          println("请输入用户名：")
          val username = StdIn.readLine().trim
          println("请输入密码：")
          val password = StdIn.readLine().trim
          // 调用Service的方法，进行登录
          val userOpt = UserService.authenticateUser(username, password)
          if(userOpt.isEmpty){
            println("用户名或密码错误")
          } else {
            println("登录成功")
            // 登录成功，显示登录用户的菜单
            val user = userOpt.get
            user.role match {
              case "管理员" => showAdminMenu(user)
              case "普通用户" => showUserMenu(user)
            }
          }
        case "4" =>
          running = false
          println("感谢你的使用，下次再见")
        case _ => println("无效的选择")
      }
    }
  }

  // 显示管理员的菜单
  def showAdminMenu(user:UserModel): Unit = {
    var running = true
    while (running) {
      println(s"欢迎管理员:${user.username},来到我的图书管理系统, 请选择")
      println("1. 添加图书")
      println("2. 查询图书")
      println("4. 退出")

      // 获取用户的操作
      val choice = StdIn.readLine().trim
      choice match {
        case "1" => println("添加图书")
        case "2" => println("查询图书")
        case "4" => running = false
        case _ => println("无效的选择")
      }
    }
  }
  // 显示登录用户的菜单
  def showUserMenu(user:UserModel): Unit = {
    var running = true
    while (running) {
      println(s"欢迎用户:${user.username},来到我的图书管理系统, 请选择")
      println("1. 借阅图书")
      println("2. 查询借阅图书")
      println("3. 查询图书")
      println("4. 退出")

      // 获取用户的操作
      val choice = StdIn.readLine().trim
      choice match {
        case "1" =>
          // UI: 提示用户输入图书的ID。校验：判断是不是整数
          try {
            val id = readLine("请输入图书的ID:").toInt
            BookService.borrowBook(user.username, id)
          } catch {
            case e:Exception =>
              println(e)
              println("输入的图书ID无效")
          }

        case "2" =>
          println("查询借阅图书")
          // 在BookService中实现根据用户名去查询借阅图书
          val borrowRecords = BookService.queryBorrowRecords(user.username)
          //判断是否为空
          if(borrowRecords.isEmpty){
            println("没有借阅记录")
          }else{
            //遍历借阅记录
            for(record <- borrowRecords){
              println(record)
              val returnDate = record.returnDate.getOrElse("未归还")
              println(s"书名：${record.bookName}借阅日期：${record.borrowDate},归还日期:$returnDate")
            }
          }
        case "4" => running = false
        case _ => println("无效的选择")
      }
    }
  }

  def showMenu(): Unit = {
    showVisitorMenu()
  }
}