基于微信小程序图书馆座位预约管理系统

开发工具：IDEA、微信小程序

服务器：Tomcat9.0， jdk1.8

项目构建：maven

数据库：mysql5.7

前端技术：vue、uniapp

服务端技术：springboot+mybatis

本系统分微信小程序和管理后台两部分，项目采用前后端分离

项目功能描述：

1.微信小程序：登录、注册、主页、公告、轮播图、图书馆预约(座位选择、时间选择)，图书借阅、个人中心(预约状态、扫码签到、修改密码、设置、退出登录)

2.后台管理：登录、修改密码、系统管理(用户管理、角色管理、菜单管理、组织管理)、图书馆管理、座位管理、通知管理、预约管理、借阅管理、图书管理

文档截图：

基于微信小程序图书馆座位预约管理系统

微信小程序截图：

后台截图：

package com.yiyue.service.system;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.yiyue.common.exception.CustomException;
import com.yiyue.common.util.Assert;
import com.yiyue.common.util.PageUtil;
import com.yiyue.interceptor.SystemUserContextHolder;
import com.yiyue.mapper.system.SysOrganMapper;
import com.yiyue.mapper.system.SysUserMapper;
import com.yiyue.model.bean.system.SysOrgan;
import com.yiyue.model.bean.system.SysUser;
import com.yiyue.model.dto.system.SysUserDTO;
import com.yiyue.model.dto.system.UserPasswordDTO;
import com.yiyue.model.vo.system.SysUserVO;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.authc.credential.DefaultPasswordService;
import org.apache.shiro.subject.Subject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;


@Service
@Transactional
public class SysUserService {

    @Autowired
    private SysUserMapper sysUserMapper;

    @Autowired
    private SysOrganMapper sysOrganMapper;

    @Autowired
    private DefaultPasswordService passwordService;

    public IPage<SysUserVO> findSysUserList(SysUserDTO sysUserDTO) {
        QueryWrapper<SysUserVO> queryWrapper=new QueryWrapper<>();
        if(!StringUtils.isBlank(sysUserDTO.getUserName())){
            queryWrapper.like("su.user_name","%"+sysUserDTO.getUserName()+"%");
        }
        if(!StringUtils.isBlank(sysUserDTO.getLoginName())){
            queryWrapper.like("su.login_name","%"+sysUserDTO.getLoginName()+"%");
        }
        if(!StringUtils.isBlank(sysUserDTO.getPhone())){
            queryWrapper.like("su.phone","%"+sysUserDTO.getPhone()+"%");
        }
        if(!StringUtils.isBlank(sysUserDTO.getUserSex())){
            queryWrapper.eq("su.user_sex",sysUserDTO.getUserSex());
        }
        if(!StringUtils.isBlank(sysUserDTO.getOrgName())){
            queryWrapper.like("so.org_name","%"+sysUserDTO.getOrgName()+"%");
        }
        if(!StringUtils.isBlank(sysUserDTO.getOrgId())){
            queryWrapper.eq("su.org_id",sysUserDTO.getOrgId());
        }
        queryWrapper.eq("su.user_state",0);
        queryWrapper.eq("so.org_state",0);
        IPage<SysUserVO> ipage=sysUserMapper.findSysUserListByParam(PageUtil.getPagination(sysUserDTO),queryWrapper);
        return ipage;
    }

    public SysUser findSysUserByUserId(String userId) {
        SysUser sysUser=this.sysUserMapper.selectById(userId);
        SysOrgan sysOrgan=this.sysOrganMapper.selectById(sysUser.getOrgId());
        sysUser.setOrgName(sysOrgan.getOrgName());
        return sysUser;
    }


    public void insertSysUser(SysUser sysUser) {
        //验证用户登录名是否已注册过
        QueryWrapper<SysUser> queryWrapper=new QueryWrapper<>();
        queryWrapper.eq("login_name",sysUser.getLoginName());
        SysUser user=this.sysUserMapper.selectOne(queryWrapper);
        if(null!=user){
            throw new CustomException("用户登录名已被注册过，请换个登录名");
        }
        sysUser.setLoginPass(passwordService.encryptPassword(sysUser.getLoginPass()));
        sysUser.setCreateDate(new Date());
        sysUser.setUserState(0);
        this.sysUserMapper.insert(sysUser);
    }

    public void deleteSysUserById(String userId) {
        SysUser sysUser=sysUserMapper.selectById(userId);
        sysUser.setUserState(-1);
        this.sysUserMapper.updateById(sysUser);
    }

    public void updateSysUser(SysUser sysUser) {
        this.sysUserMapper.updateById(sysUser);
    }

    public void reset_user_login_pass(String userId) {
        SysUser sysUser=this.sysUserMapper.selectById(userId);
        sysUser.setLoginPass(passwordService.encryptPassword("123456"));
        this.sysUserMapper.updateById(sysUser);
    }

    public void updateLoginPassword(UserPasswordDTO userPasswordDTO) {
        SysUser sysUser = sysUserMapper.selectById(SystemUserContextHolder.getUserId());
        Assert.isBlank(userPasswordDTO.getOldPassword(), "用户旧密码不能为空");
        Assert.isMaxLength(userPasswordDTO.getOldPassword(), 20, "用户旧密码长度不能超过20位");

        try {
            Subject subject = SecurityUtils.getSubject();
            UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(sysUser.getLoginName(), userPasswordDTO.getOldPassword());
            subject.login(usernamePasswordToken);
        }catch (Exception e){
            throw new CustomException("用户旧密码错误");
        }
        Assert.isBlank(userPasswordDTO.getNewPassword(), "用户新密码不能为空");
        Assert.isMaxLength(userPasswordDTO.getNewPassword(), 20, "用户新密码长度不能超过20位");
        Assert.isBlank(userPasswordDTO.getConfirmPassword(), "用户确认密码不能为空");
        Assert.isMaxLength(userPasswordDTO.getConfirmPassword(), 20, "用户确认密码长度不能超过20位");
        if (!userPasswordDTO.getNewPassword().equals(userPasswordDTO.getConfirmPassword())) {
            throw new CustomException("用户新密码和确认密码不同");
        }
        sysUser.setLoginPass(passwordService.encryptPassword(userPasswordDTO.getNewPassword()));
        sysUserMapper.updateById(sysUser);
    }


    public IPage<SysUser> selectAllList(SysUserDTO sysUserDTO) {
        QueryWrapper<SysUser> queryWrapper=new QueryWrapper<>();
        if(!StringUtils.isBlank(sysUserDTO.getUserName())){
            queryWrapper.like("user_name","%"+sysUserDTO.getUserName()+"%");
        }
        if(!StringUtils.isBlank(sysUserDTO.getPhone())){
            queryWrapper.like("phone","%"+sysUserDTO.getPhone()+"%");
        }
        queryWrapper.eq("user_state",0);
        IPage<SysUser> ipage=sysUserMapper.selectPage(PageUtil.getPagination(sysUserDTO),queryWrapper);
        return ipage;
    }
}

package com.yiyue.service.wx;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.yiyue.common.util.PageUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.apache.commons.lang3.StringUtils;
import com.yiyue.model.bean.wx.BooksManger;
import com.yiyue.model.dto.wx.BooksMangerDTO;
import com.yiyue.mapper.wx.BooksMangerMapper;


@Service
@Transactional
public class BooksMangerService {

@Autowired
private BooksMangerMapper booksMangerMapper;

public IPage<BooksManger> findBooksMangerListPageByParam(BooksMangerDTO booksMangerDTO) {
// 从dto对象中获得查询条件，添加到queryWrapper对象中, 查询条件还需要视情况自行修改
QueryWrapper<BooksManger> queryWrapper=getQueryWrapper(booksMangerDTO);

IPage<BooksManger> booksMangerList=booksMangerMapper.findBooksMangerPageList(PageUtil. getPagination(booksMangerDTO),queryWrapper);
return booksMangerList;
}

private QueryWrapper getQueryWrapper(BooksMangerDTO booksMangerDTO){
QueryWrapper<BooksManger> queryWrapper=new QueryWrapper<>();
// 序号
if(!StringUtils. isBlank(booksMangerDTO.getId())){
queryWrapper.eq("id",booksMangerDTO.getId());
}
// 书名
if(!StringUtils. isBlank(booksMangerDTO.getBookName())){
queryWrapper.like("book_name","%"+booksMangerDTO.getBookName()+"%");
}
// 图片
if(!StringUtils. isBlank(booksMangerDTO.getBookImg())){
queryWrapper.eq("book_img",booksMangerDTO.getBookImg());
}
// 内容
if(!StringUtils. isBlank(booksMangerDTO.getBookText())){
queryWrapper.eq("book_text",booksMangerDTO.getBookText());
}
// 借阅状态(0,可借，1已借)
if(!StringUtils. isBlank(booksMangerDTO.getUseState())){
queryWrapper.eq("use_state",booksMangerDTO.getUseState());
}
// 备注
if(!StringUtils. isBlank(booksMangerDTO.getBookMark())){
queryWrapper.eq("book_mark",booksMangerDTO.getBookMark());
}
// 创建时间
if(!StringUtils. isBlank(booksMangerDTO.getCreateDate())){
queryWrapper.eq("create_date",booksMangerDTO.getCreateDate());
}
return queryWrapper;
}

public void insertBooksManger(BooksManger booksManger) {
booksMangerMapper.insert(booksManger);
}

public void updateBooksManger(BooksManger booksManger) {
this.booksMangerMapper.updateById(booksManger);
}

public void deleteBooksMangerById(String id) {
this.booksMangerMapper.deleteById(id);
}

public BooksManger findBooksMangerById(String id) {
return booksMangerMapper.selectById(id);
}

}