services/service/book/book.go

package book

import (
	"errors"
	"spaceofcheng/services/models"
	"spaceofcheng/services/models/book"
	"spaceofcheng/services/models/customer"
	"spaceofcheng/services/models/model"
	"spaceofcheng/services/service"
	"spaceofcheng/services/utils"
	"strconv"
	"time"
)

// BookServ 系统处理
type BookServ struct {
	ctx  *utils.Context
	dao  *book.BookDAO
	cdao *customer.CustomerDAO
}

// NewBookServ 初始化
func NewBookServ(ctx *utils.Context) *BookServ {
	return &BookServ{
		ctx:  ctx,
		dao:  book.NewBookDAO(ctx),
		cdao: customer.NewCustomerDAO(ctx),
	}
}

// GetBookRecommendList 获取推荐图书信息
func (s *BookServ) GetBookRecommendList(caseid string, page, pageSize int) (map[string]interface{}, error) {
	if pageSize == 0 {
		pageSize = service.PAGENUM
	}
	if page <= 0 {
		page = 1
	}
	list, err := s.dao.GetBookRecommendList(caseid, page, pageSize)
	if err != nil {
		utils.LogError("获取图书列表失败: " + err.Error())
		return nil, errors.New("获取图书列表失败")
	}

	return map[string]interface{}{
		"list":     list,
		"pageSize": pageSize,
		"page":     page,
	}, nil
}

func (s *BookServ) GetBookList(bookType, name, barcode, showzero, caseid string, page, pageSize int) (map[string]interface{}, error) {
	if pageSize == 0 {
		pageSize = service.PAGENUM
	}
	if page <= 0 {
		page = 1
	}
	list, err := s.dao.GetBookList(bookType, name, barcode, showzero, caseid, page, pageSize)
	if err != nil {
		utils.LogError("获取图书列表失败: " + err.Error())
		return nil, errors.New("获取图书列表失败")
	}
	total, err := s.dao.GetBookListCount(bookType, name, showzero, barcode, caseid)
	if err != nil {
		utils.LogError("获取图书列表失败: " + err.Error())
		return nil, errors.New("获取图书列表失败")
	}
	return map[string]interface{}{
		"list":     list,
		"pageSize": pageSize,
		"pagenum":  total,
		"page":     page,
	}, nil
}

func (s *BookServ) GetBookById(bookId string) (*model.TaBook, error) {
	book, err := s.dao.GetBookById(bookId)
	if err != nil {
		utils.LogError("获取图书详情失败: " + err.Error())
		return nil, errors.New("获取图书详情失败")
	}
	return book, nil
}
func (s *BookServ) AuthBook(book model.TaBook) error {
	if book.CaseId == "" {
		return errors.New("案场不能为空")
	}
	if book.BookBarcode == "" {
		return errors.New("条形码不能为空")
	}
	num, err := s.dao.IsBarcodeExist(book.BookBarcode, book.CaseId)
	if err != nil {
		utils.LogError("新增图书失败: " + err.Error())
		return errors.New("新增图书失败")
	}
	if num > 0 {
		return errors.New("条形码" + book.BookBarcode + "已存在")
	}
	if book.BookName == "" {
		return errors.New("图书名不能为空")
	}
	if book.InStock == 0 {
		return errors.New("总库存不能为0")
	}
	if book.BorrowDays == 0 {
		return errors.New("借阅天数不能为0")
	}
	return nil
}
func (s *BookServ) AuthBookEdit(book model.TaBook) error {
	if book.CaseId == "" {
		return errors.New("案场不能为空")
	}
	if book.BookName == "" {
		return errors.New("图书名不能为空")
	}
	if book.InStock == 0 {
		return errors.New("总库存不能为0")
	}
	if book.BorrowDays == 0 {
		return errors.New("借阅天数不能为0")
	}
	return nil
}
func (s *BookServ) AddBook(book model.TaBook) (*model.TaBook, error) {

	newBook, err := s.dao.AddBook(book)

	if err != nil {
		utils.LogError("新增图书失败: " + err.Error())
		return nil, errors.New("新增图书失败")
	}
	return newBook, err

}
func (s *BookServ) EditBook(book model.TaBook) (*model.TaBook, error) {
	editbook, err := s.dao.EditBook(book)
	if err != nil {
		utils.LogError("修改图书失败: " + err.Error())
		return nil, errors.New("修改图书失败")
	}
	return editbook, nil
}

// GetMineRecord 获取个人借阅记录
func (s *BookServ) GetMineRecord(status string, page, pageSize int) (map[string]interface{}, error) {
	if pageSize == 0 {
		pageSize = service.PAGENUM
	}
	if page <= 0 {
		page = 1
	}
	customer := s.ctx.Get("customer").(model.TaCustomer)
	list, err := s.dao.GetMineRecord(customer.CustomerId, status, page, pageSize)
	if err != nil {
		utils.LogError("获取图书列表失败: " + err.Error())
		return nil, errors.New("获取图书列表失败")
	}
	total, err := s.dao.GetMineRecordCount(customer.CustomerId, status)
	if err != nil {
		utils.LogError("获取图书列表失败: " + err.Error())
		return nil, errors.New("获取图书列表失败")
	}
	return map[string]interface{}{
		"list":     list,
		"pageSize": pageSize,
		"pagenum":  total,
		"page":     page,
	}, nil
}

func (s *BookServ) GetInStockChangeByBookId(bookId string, page, pageSize int) (map[string]interface{}, error) {
	if pageSize == 0 {
		pageSize = service.PAGENUM
	}
	if page <= 0 {
		page = 1
	}
	list, err := s.dao.GetInStockChangeByBookId(bookId, page, pageSize)
	if err != nil {
		utils.LogError("获取库存盘点列表失败: " + err.Error())
		return nil, errors.New("获取库存盘点列表失败")
	}
	total, err := s.dao.GetInStockChangeByBookIdCount(bookId)
	if err != nil {
		utils.LogError("获取库存盘点列表失败: " + err.Error())
		return nil, errors.New("获取库存盘点列表失败")
	}
	return map[string]interface{}{
		"list":     list,
		"pageSize": pageSize,
		"pagenum":  total,
		"page":     page,
	}, nil
}

func (s *BookServ) AddChangeRecord(change model.TaInStockChange) error {
	book, err := s.dao.GetBookById(change.BookId)
	if err != nil {
		utils.LogError("库存盘点失败: " + err.Error())
		return errors.New("库存盘点失败")
	}
	bookAdd := change.InStockAfter - change.InStockBefore
	book.InStock = book.InStock + bookAdd
	book.LeftNum = change.InStockAfter
	change.InStockTotal = book.InStock
	err = s.dao.AddChangeRecord(change)
	if err != nil {
		utils.LogError("库存盘点失败: " + err.Error())
		return errors.New("库存盘点失败")
	}
	var cols = []string{
		"in_stock",
		"left_num",
	}
	err = s.dao.UpdateInStockBook(book, cols)
	if err != nil {
		utils.LogError("库存盘点失败: " + err.Error())
		return errors.New("库存盘点失败")
	}
	return nil
}

func (s *BookServ) BorrowBook(bookId, customerId, orgId string) (*model.TaBookBorrowRecord, error) {
	reserveRecord, err := s.dao.CustomerReservedBook(bookId, customerId)
	if err != nil {
		utils.LogError("借阅失败: " + err.Error())
		return nil, errors.New("借阅失败")
	}
	book, err := s.dao.GetBookById(bookId)
	if err != nil {
		utils.LogError("借阅失败: " + err.Error())
		return nil, errors.New("借阅失败")
	}
	returnTime := book.BorrowDays * 24
	returnStr := strconv.Itoa(returnTime) + "h"
	dd, _ := time.ParseDuration(returnStr)
	if reserveRecord == nil {
		customer, err := s.cdao.GetCustomerByID(customerId)
		if err != nil {
			utils.LogError("借阅失败: " + err.Error())
			return nil, errors.New("借阅失败")
		}
		if book.LeftNum <= 0 {
			return nil, errors.New("该图书已无库存")
		}
		var borrowRecord = model.TaBookBorrowRecord{
			BookId:        bookId,
			BorrowStatus:  models.BORROW_TYPE_BORROWED,
			CustomerId:    customerId,
			CustomerName:  customer.Name,
			CustomerPhone: customer.Phone,
			BorrowDate:    time.Now(),
			EndDate:       time.Now().Add(dd),
			CaseId:        book.CaseId,
			OrgId:         orgId,
		}
		newBorrow, err := s.dao.AddBookRecord(borrowRecord)
		if err != nil {
			utils.LogError("借阅失败: " + err.Error())
			return nil, errors.New("借阅失败")
		}
		book.BorrowNum = book.BorrowNum + 1
		book.LeftNum = book.LeftNum - 1
		var cols = []string{
			"left_num",
			"borrow_num",
		}
		err = s.dao.UpdateInStockBook(book, cols)
		if err != nil {
			utils.LogError("借阅失败: " + err.Error())
			return nil, errors.New("借阅失败")
		}
		return newBorrow, nil
	}
	reserveRecord.BorrowDate = time.Now()
	reserveRecord.BorrowStatus = models.BORROW_TYPE_BORROWED
	reserveRecord.EndDate = time.Now().Add(dd)
	newBorrow, err := s.dao.UpdateBookRecord(reserveRecord)
	if err != nil {
		utils.LogError("借阅失败: " + err.Error())
		return nil, errors.New("借阅失败")
	}
	book.BorrowNum = book.BorrowNum + 1
	var cols = []string{
		"borrow_num",
	}
	err = s.dao.UpdateInStockBook(book, cols)
	if err != nil {
		utils.LogError("借阅失败: " + err.Error())
		return nil, errors.New("借阅失败")
	}
	return newBorrow, nil

}

func (s *BookServ) ReturnBook(borrowId string) error {
	record, err := s.dao.GetBorrowById(borrowId)
	if err != nil {
		utils.LogError("归还失败: " + err.Error())
		return errors.New("归还失败")
	}
	book, err := s.dao.GetBookById(record.BookId)
	if err != nil {
		utils.LogError("归还失败: " + err.Error())
		return errors.New("归还失败")
	}
	if record == nil {
		return errors.New("不存在的借阅信息")
	}
	if record.BorrowStatus == models.BORROW_TYPE_LATE {
		record.BorrowStatus = models.BORROW_TYPE_LATERETURN
	} else {
		record.BorrowStatus = models.BORROW_TYPE_RETURN
	}
	record.ReturnDate = time.Now()
	_, err = s.dao.UpdateBookRecord(record)
	if err != nil {
		utils.LogError("归还失败: " + err.Error())
		return errors.New("归还失败")
	}
	book.BorrowNum = book.BorrowNum - 1
	book.LeftNum = book.LeftNum + 1
	var cols = []string{
		"left_num",
		"borrow_num",
	}
	err = s.dao.UpdateInStockBook(book, cols)
	if err != nil {
		utils.LogError("归还失败: " + err.Error())
		return errors.New("归还失败")
	}
	return nil
}
func (s *BookServ) CancelReserve(recordId string) error {
	record, err := s.dao.GetRecordById(recordId)
	if err != nil {
		utils.LogError("取消失败: " + err.Error())
		return errors.New("取消失败")
	}
	book, err := s.dao.GetBookById(record.BookId)
	if err != nil {
		utils.LogError("取消失败: " + err.Error())
		return errors.New("取消失败")
	}
	book.LeftNum = book.LeftNum + 1
	var cols = []string{
		"left_num",
	}
	err = s.dao.UpdateInStockBook(book, cols)
	if err != nil {
		utils.LogError("归还失败: " + err.Error())
		return errors.New("归还失败")
	}

	record.BorrowStatus = models.BORROW_TYPE_CANCEL
	_, err = s.dao.UpdateBookRecord(record)
	if err != nil {
		utils.LogError("取消失败: " + err.Error())
		return errors.New("取消失败")
	}
	return nil

}

func (s *BookServ) GetCustomerReturnList(customerInfo, caseId string, page, pageSize int) (map[string]interface{}, error) {
	if pageSize == 0 {
		pageSize = service.PAGENUM
	}
	if page <= 0 {
		page = 1
	}
	list, err := s.dao.GetCustomerReturnList(customerInfo, caseId, page, pageSize)
	if err != nil {
		utils.LogError("获取库存盘点列表失败: " + err.Error())
		return nil, errors.New("获取库存盘点列表失败")
	}
	total, err := s.dao.GetCustomerReturnListCount(customerInfo, caseId)
	if err != nil {
		utils.LogError("获取库存盘点列表失败: " + err.Error())
		return nil, errors.New("获取库存盘点列表失败")
	}
	return map[string]interface{}{
		"list":     list,
		"pageSize": pageSize,
		"pagenum":  total,
		"page":     page,
	}, nil
}

// ReserveBook 图书预约
func (s *BookServ) ReserveBook(bookid string) (*model.TaBookBorrowRecord, error) {
	book, err := s.dao.GetBookById(bookid)
	if err != nil {
		utils.LogError("获取图书信息失败：", err.Error())
		return nil, errors.New("获取图书信息失败")
	}
	if book == nil || book.BookId == "" {
		return nil, errors.New("没有对应的图书信息")
	}
	if book.LeftNum < 1 {
		return nil, errors.New("预约失败，库存不足")
	}
	customer := s.ctx.Get("customer").(model.TaCustomer)
	if customer.Phone == "" {
		return nil, errors.New("请先绑定您的手机号，再进行预约！")
	}
	isok, err := s.dao.CheckUserReserveBook(customer.CustomerId, bookid)
	if err != nil {
		utils.LogError("判断用户是否已借阅此图书失败：", err.Error())
		return nil, errors.New("判断失败，请刷新后重试！")
	}
	if !isok {
		return nil, errors.New("您已预约或借阅此图书！")
	}
	var record = model.TaBookBorrowRecord{
		BookId:        book.BookId,
		CustomerId:    customer.CustomerId,
		CustomerName:  customer.Name,
		CustomerPhone: customer.Phone,
		OrgId:         book.OrgId,
		CaseId:        book.CaseId,
	}
	info, err := s.dao.ReserveBook(record)
	if err != nil {
		utils.LogError("预约失败：", err.Error())
		return nil, errors.New("预约失败")
	}
	// 减库存
	err = s.dao.BookLeftNumDel(book.BookId)
	if err != nil {
		utils.LogError("减库存失败：", err.Error())
		return nil, err
	}
	return &info, err
}

func (s *BookServ) GetCustomerByCustomerInfo(customerInfo string) (*model.TaCustomer, error) {
	list, err := s.dao.GetCustomerByCustomerInfo(customerInfo)
	if err != nil {
		utils.LogError("获取用户信息失败：", err.Error())
		return nil, errors.New("获取用户信息失败")
	}
	return list, nil
}

func (s *BookServ) GetRecordList(borrowStatus, caseid, customerName, customerPhone, bookName, barcode string, page, pageSize int) (map[string]interface{}, error) {
	if pageSize == 0 {
		pageSize = service.PAGENUM
	}
	if page <= 0 {
		page = 1
	}
	list, err := s.dao.GetRecordList(borrowStatus, caseid, customerName, customerPhone, bookName, barcode, page, pageSize)
	if err != nil {
		utils.LogError("获取借书记录列表失败: " + err.Error())
		return nil, errors.New("获取借书记录列表失败")
	}
	total, err := s.dao.GetRecordListCount(borrowStatus, caseid, customerName, customerPhone, bookName, barcode)
	if err != nil {
		utils.LogError("获取借书记录列表失败: " + err.Error())
		return nil, errors.New("获取借书记录列表失败")
	}
	return map[string]interface{}{
		"list":     list,
		"pageSize": pageSize,
		"pagenum":  total,
		"page":     page,
	}, nil
}

func (s *BookServ) DeleteBook(bookId string) error {
	book, err := s.dao.GetBookById(bookId)
	if err != nil {
		utils.LogError("删除失败: " + err.Error())
		return errors.New("删除失败")
	}
	if book.LeftNum != book.InStock {
		return errors.New("当前图书已有借出/预约，不能删除")
	}
	err = s.dao.DeleteBook(bookId)
	if err != nil {
		utils.LogError("删除失败: " + err.Error())
		return errors.New("删除失败")
	}
	return nil
}

// func (s *BookServ) SendMessageToCustomer() error {
// 	weekList, err := s.dao.GetAllOneWeekRecord()
// 	if err != nil {
// 		utils.LogError("发送消息失败失败: " + err.Error())
// 		return errors.New("发送消息失败失败")
// 	}
// 	lateList, err := s.dao.GetAllLateRecord()
// 	if err != nil {
// 		utils.LogError("发送消息失败失败: " + err.Error())
// 		return errors.New("发送消息失败失败")
// 	}
// 	if len(weekList) > 0 {
// 		for i := 0; i < len(weekList); i++ {
// 			userMap, err := s.dao.GetUserMappingById(weekList[i].CustomerId)
// 			if err != nil {
// 				utils.LogError("发送消息失败失败: " + err.Error())
// 				return errors.New("发送消息失败失败")
// 			}
// 			message := utils.Message{
// 				To: utils.ClientID{ID: userMap.Openid},
// 				Data: map[string]interface{}{
// 					"orgid": weekList[i].OrgId,
// 					"tplid": "6WoxRkdXrRyF0T7Kc4PU5CjkpzAPWKKsA6wBLAGSQQg",
// 					"data": map[string]string{
// 						"first":    "您好，您借阅图书即将逾期，请及时归还。",
// 						"keyword1": weekList[i].BookName,
// 						"keyword2": weekList[i].BorrowDate.Format("2006-01-02"),
// 						"keyword3": weekList[i].EndDate.Format("2006-01-02"),
// 						"remark":   fmt.Sprintf("避免影响您下次借阅，请及时归还至", weekList[i].CaseName),
// 					},
// 				},
// 			}
// 			go utils.SendWechat(message)
// 		}
// 	}
// 	if len(lateList) > 0 {
// 		for i := 0; i < len(lateList); i++ {
// 			userMap, err := s.dao.GetUserMappingById(lateList[i].CustomerId)
// 			if err != nil {
// 				utils.LogError("发送消息失败失败: " + err.Error())
// 				return errors.New("发送消息失败失败")
// 			}
// 			message := utils.Message{
// 				To: utils.ClientID{ID: userMap.Openid},
// 				Data: map[string]interface{}{
// 					"orgid": lateList[i].OrgId,
// 					"tplid": "ID:Be0a25NMb3fzLtNaaQn_YOuECQDnlCs1es5aVvfwRhs",
// 					"data": map[string]string{
// 						"first":    "您好，您借阅图书的时间已经逾期2天",
// 						"keyword1": lateList[i].BookName,
// 						"keyword2": weekList[i].BorrowDate.Format("2006-01-02"),
// 						"keyword3": weekList[i].EndDate.Format("2006-01-02"),
// 						"remark":   fmt.Sprintf("避免影响您下次借阅，请及时归还至", lateList[i].CaseName),
// 					},
// 				},
// 			}
// 			go utils.SendWechat(message)
// 		}
// 	}
// 	return nil
// }
func (s *BookServ) GetCustomerBorrowInfo(customerInfo string) (*book.CustomerInfo, error) {
	customer, err := s.dao.GetCustomerBorrowInfo(customerInfo)
	if err != nil {
		utils.LogError("获取用户信息失败: " + err.Error())
		return nil, errors.New("获取用户信息失败")
	}
	return customer, nil
}

func (s *BookServ) GetBookTypeByCaseId(caseId string) (map[string]string, error) {
	list, err := s.dao.GetBookTypeByCaseId(caseId)
	if err != nil {
		utils.LogError("查询图书类型失败: " + err.Error())
		return nil, errors.New("查询图书类型失败")
	}
	data := make(map[string]string)
	for i := 0; i < len(list); i++ {
		data[list[i].BookTypeName] = list[i].BookTypeId
	}
	return data, nil

}