一、前言

  这个是实训时的一个企业员工管理系统，整体效果看起来还不错，文档和源代码及数据库有需要的可以在文末添加我的联系方式或者直接私信我哈（有偿），可直接跳转到运行效果那先看看。

二、需求规格说明书

2.1产品前景

  企业员工管理系统旨在帮助企业实现员工信息的高效管理。通过本系统，管理员可以快速完成员工档案录入、查询、更新、导出等操作；同时提供权限管理功能，以满足不同部门和角色的安全访问需求。该系统未来还可扩展为支持员工培训记录、绩效评估、考勤管理等功能模块。

2.2产品功能

• 1、员工管理：支持员工档案的新增、查询、修改、删除。
• 2、权限管理：基于角色的权限控制，管理员可以分配权限。
• 3、考勤管理：员工工作日需打卡签到、签退。
• 4、请假管理：管理员可审批员工请假申请。
• 5、登录认证：基于账号密码的登录认证，支持验证码校验。
• 6、数据统计：生成企业员工统计报表，如部门员工人数分布。
• 7、日志记录：记录所有用户的操作行为，支持管理员查询。

2.3功能需求

①系统管理员：负责系统管理（用户新增、查询、删除、修改、密码重置、禁用、启用，分配角色和权限）等。
②员工：负责考勤打卡和请假申请（信息查询、修改，请假申请、查看、取消，打卡签到/签退）
③部门管理员：负责本部门员工的管理（查看本部门员工出勤记录和请假记录，审批本部门请假申请，查询本部门出勤统计、导出部门考勤数据）
④HR（人力资源管理员）：负责公司层面的员工管理（全体员工信息查看、添加、删除、修改，查询员工出勤和请假记录，审批高级别请假申请（如特殊情况需 HR 批准的申请），生成公司整体出勤和请假报表，统计员工出勤率、请假率，导出员工考勤和请假统计数据）

注：这个用例图可能画的有点问题，后面也不想改了就这样了，然后需求规格说明书上的需求可能和实际需求也不完全一样，以实际效果为主。

三、系统设计报告

3.1系统功能层次图

3.2用户管理

3.2.1 用户登录

主执行者：系统所有用户
功能描述：登录后台管理
基本功能：在用户登录页面输入用户名和密码单击登录按钮进行登录，如果用户名和密码错误，系统会进行提示，登录成功后可跳转到系统前台。

3.3员工管理

3.3.1 员工信息显示

主执行者：系统所有用户
功能描述：查看并管理员工的基本信息。
基本功能：在员工信息页面，系统展示员工的基本资料，包括姓名、工号、部门、职位、入职时间等。管理员可以通过筛选条件（如姓名、部门、职位等）快速查找特定员工的信息。

3.3.2 员工入职处理

主执行者：HR
功能描述：处理新员工入职信息，完成员工档案的建立。
基本功能：HR登录系统后，进入员工入职管理页面，填写新员工的基本信息（如姓名、性别、工号、部门、职位、联系方式、入职日期等），并提交保存。系统会自动生成员工档案，并分配对应的权限和岗位信息。若填写的信息不完整或格式错误，系统将提示用户进行修改。

3.3.3 员工离职处理

主执行者：HR
功能描述：处理员工离职信息，完成员工档案的更新与归档。
基本功能：HR登录系统后，进入员工离职管理页面，选择需离职的员工，填写相关离职信息（如离职日期、离职原因等），并提交保存。系统会自动更新员工状态为“离职”，移除相关权限，并将员工档案归档。若操作中信息填写不完整或格式错误，系统将提示用户进行修改。

3.4部门管理

3.4.1 部门信息显示

主执行者：系统管理员、部门管理员、HR
功能描述：查看并管理部门的基本信息。
基本功能：在部门信息页面，系统展示部门的基本资料，包括部门名称、部门编号、部门负责人等信息。管理员可以通过筛选条件（如部门名称、部门编号等）快速查找特定部门的信息，并对部门信息进行查看或更新。

3.4.2 部门新增

主执行者：系统管理员
功能描述：创建新的部门信息，完善组织架构。
基本功能：系统管理员登录系统后，进入部门管理页面，选择新增部门功能，填写新部门的基本信息（如部门名称、部门编号、部门负责人），并提交保存。系统会自动创建新的部门记录，更新组织架构。如果填写的信息不完整或格式错误，系统将提示用户修改后再提交。

3.4.3 部门删除

主执行者：系统管理员
功能描述：删除部门信息，维护组织架构的合理性。
基本功能：系统管理员登录系统后，进入部门管理页面，选择需删除的部门，确认操作后提交。系统会验证该部门是否有未处理的关联信息（如在职员工或未完成的任务等）。如果有未处理的关联信息，系统将提示管理员完成相关处理后再删除；若无关联信息，系统会成功删除该部门并更新组织架构。

3.5岗位管理

3.5.1 岗位信息显示

主执行者：系统管理员
功能描述：查看并管理岗位的基本信息。
基本功能：在岗位信息页面，系统展示岗位的基本资料，包括岗位名称、岗位编号、岗位职责描述等信息。管理员可以通过筛选条件（如岗位名称、岗位编号等）快速查找特定岗位的信息，并对岗位信息进行查看或更新。

3.5.2 岗位新增

主执行者：系统管理员
功能描述：创建新的岗位信息，完善岗位体系。
基本功能：系统管理员登录系统后，进入岗位管理页面，选择新增岗位功能，填写新岗位的基本信息（如岗位名称、岗位编号、岗位职责、岗位等级等），并提交保存。系统会自动创建新的岗位记录并更新岗位体系。如果填写的信息不完整或格式错误，系统将提示用户修改后再提交。

3.5.3 岗位删除

主执行者：系统管理员
功能描述：删除部门信息，维护组织架构的合理性。
基本功能：系统管理员登录系统后，进入部门管理页面，选择需删除的部门，确认操作后提交。系统会验证该部门是否有未处理的关联信息（如在职员工或未完成的任务等）。如果有未处理的关联信息，系统将提示管理员完成相关处理后再删除；若无关联信息，系统会成功删除该部门并更新组织架构。

3.6请假管理

3.6.1 请假信息显示

主执行者：部门负责人、HR
功能描述：查看并管理员工的请假信息。
基本功能：在请假信息页面，系统展示员工的请假记录，包括员工姓名、请假日期、请假类型、请假时长、请假原因等信息。管理员可以通过筛选条件（如员工姓名、请假类型、请假日期等）快速查找特定员工的请假记录，并对记录进行查看或更新。

3.6.2 请假审批

主执行者：部门负责人、HR
功能描述：对员工提交的请假申请进行审核和处理。
基本功能：审批人员登录系统后，进入请假审批页面，查看员工提交的请假申请，包括员工姓名、请假类型、请假时长、请假原因等详细信息。审批人员可选择批准或驳回操作，并填写审批意见。系统会根据审批结果更新请假记录状态为“已批准”或“已驳回”，并通知相关员工。如果未填写审批意见或操作错误，系统将提示用户进行修改后再提交。

3.6.3 销假

主执行者：员工本人、HR、部门负责人
功能描述：处理员工请假结束后的销假操作，更新考勤记录
基本功能：员工、部门负责人、HR登录系统后，进入销假管理页面，选择需销假的请假记录，填写实际返回工作时间等相关信息，并提交保存。系统会验证销假信息的完整性并更新请假记录状态为“已销假”，同时同步更新考勤记录。若填写的信息不完整或操作错误，系统将提示用户修改后再提交。

注：系统设计报告和实际系统可能也有偏差，总之，还是以实际系统为准。

四、功能模块大全

4.1控制层代码

4.1.1考勤管理

package com.bo.controller;

import com.bo.domain.pojo.AttendanceRecords;
import com.bo.service.AttendanceRecordsService;
import com.bo.utils.Result;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.log4j.Log4j2;
import org.apache.ibatis.annotations.Delete;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * @author ctx
 * @version 1.0
 * @description: TODO
 * @date 2024/12/31 8:36
 */
@RestController
@RequestMapping("/records")
@Tag(name = "考勤记录相关 API", description = "考勤记录相关 API")
@Log4j2
@CrossOrigin
public class AttendanceRecordsController {
    @Autowired
    private AttendanceRecordsService attendanceRecordsService;
    @GetMapping("/getAll")
    @Operation(summary = "1.获取所有考勤记录")
    public Result getAll() {
        log.info("getAllcontroller");
        return Result.success(attendanceRecordsService.list1());
    }
    @GetMapping("/getOne")
    @Operation(summary = "2.获取一条考勤记录")
    public Result getOne(Integer id) {
        log.info("getOnecontroller");
        if(attendanceRecordsService.getOne(id)==null)
            return Result.error("没有该条考勤记录");
        return Result.success(attendanceRecordsService.getOne(id));
    }
    @PostMapping("/add")
    @Operation(summary = "3.上班打卡")
    public Result add(@RequestBody AttendanceRecords attendanceRecords) {
        log.info("addcontroller");
        if(attendanceRecordsService.save(attendanceRecords))
            return Result.success("添加成功");
        return Result.error("今日已打卡！");
    }

    @PostMapping("/update")
    @Operation(summary = "4.下班打卡")
    public Result update(@RequestBody AttendanceRecords attendanceRecords) {
        log.info("updatecontroller");
        if(attendanceRecordsService.updateById(attendanceRecords))
            return Result.success("修改成功");
        return Result.error("修改失败");
    }
    @DeleteMapping("/delete")
    @Operation(summary = "5.删除一条考勤记录")
    public Result delete(Integer id) {
        log.info("deletecontroller");
        if(attendanceRecordsService.removeById(id))
            return Result.success("删除成功");
        return Result.error("删除失败");
    }
    @GetMapping("/listmy")
        @Operation(summary = "6.获取本人考勤记录")
        public Result listmy() {
            log.info("listmycontroller");

            return Result.success(attendanceRecordsService.listmy());
        }
}

4.1.2部门管理

package com.bo.controller;

import com.bo.domain.pojo.Departments;
import com.bo.service.DepartmentsService;
import com.bo.utils.Result;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.models.security.SecurityScheme;
import lombok.extern.log4j.Log4j2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * @author ctx
 * @version 1.0
 * @description: TODO
 * @date 2024/12/31 9:37
 */
@RestController
@RequestMapping("/depar")
@Tag(name = "部门相关 API", description = "部门相关 API")
@Log4j2
@CrossOrigin
public class DepartmentsController {
    @Autowired
    private DepartmentsService departmentsService;
    @GetMapping("/getAll")
    @Operation(summary = "1.获取所有部门信息")
    public Result getAll(){
        return Result.success(departmentsService.list());
    }
    @GetMapping("/getOne")
    @Operation(summary = "2.获取一条部门信息")
    public Result getOne(Long id){
        log.info("getOnecontroller");
        if(departmentsService.getById(id)==null)
            return Result.error("没有该条部门信息");
        return Result.success(departmentsService.getById(id));
    }
    @DeleteMapping("/delete")
    @Operation(summary = "3.删除一条部门信息")
    public Result delete(Long id){
        if(departmentsService.removeById(id))
            return Result.success("删除成功");
        return Result.error("删除失败,该部门下有员工");
    }
    @PostMapping("/update")
    @Operation(summary = "4.修改一条部门信息")
    public Result update(@RequestBody Departments departments){
        log.info("updatecontroller");
        if(departmentsService.updateById(departments))
            return Result.success("修改成功");
        return Result.error("修改失败");
    }
    @PostMapping("/add")
    @Operation(summary = "5.添加一条部门信息")
    public Result add(@RequestBody Departments departments){
        log.info("addcontroller");
        if(departmentsService.save(departments))
            return Result.success("添加成功");
        return Result.error("添加失败");
    }

}

4.1.3员工管理

package com.bo.controller;

import com.bo.domain.dto.EmployeeDto;
import com.bo.domain.pojo.Employees;
import com.bo.domain.pojo.Users;
import com.bo.service.EmployeesService;
import com.bo.utils.Result;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.log4j.Log4j2;
import org.apache.ibatis.annotations.Delete;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * @author ctx
 * @version 1.0
 * @description: TODO
 * @date 2024/12/31 10:02
 */
@RestController
@RequestMapping("/emplyee")
@Tag(name = "员工相关 API", description = "员工相关 API")
@Log4j2
@CrossOrigin
public class EmployeesController {
    @Autowired
    private EmployeesService employeesService;
    @GetMapping("/list")
    @Operation(summary = "1.获取员工列表")
    public Result list(){
        return Result.success(employeesService.list1());
    }
    @GetMapping("/getOne")
    @Operation(summary = "2.获取一条员工信息")
    public Result getOne(Long id){
        log.info("getOnecontroller");
        if(employeesService.getById(id)==null)
            return Result.error("没有该条员工信息");
        return Result.success(employeesService.getById(id));
    }
    @DeleteMapping("/delete")
    @Operation(summary = "3.删除一条员工信息")
    public Result delete(Long id){
        if(employeesService.removeById(id))
            return Result.success("删除成功");
        return Result.error("删除失败");
    }
    @PostMapping("/update")
    @Operation(summary = "4.修改一条员工信息")
    public Result update(@RequestBody EmployeeDto employees){
        if(employeesService.updateById(employees))
            return Result.success("修改成功");
        return Result.error("修改失败");
    }
    @PostMapping("/add")
    @Operation(summary = "5.添加一条员工信息")
    public Result add(@RequestBody EmployeeDto employees){
        Users users = employeesService.save(employees) ;
        if(users!=null)
            return Result.success(users);
        return Result.error("添加失败");
    }
}

4.1.4请假管理

package com.bo.controller;

import com.bo.domain.pojo.LeaveRequests;
import com.bo.service.LeaveRequestsService;
import com.bo.utils.Result;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.Getter;
import lombok.extern.log4j.Log4j2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * @author ctx
 * @version 1.0
 * @description: TODO
 * @date 2024/12/31 10:22
 */
@RestController
@RequestMapping("/leave")
@Tag(name = "请假申请相关 API", description = "请假申请相关 API")
@Log4j2
@CrossOrigin
public class LeaveRequestsController {
    @Autowired
    private LeaveRequestsService leaveRequestsService;
    @GetMapping("/list")
    @Operation(summary = "1.获取所有请假申请")
    public Result list() {
        return Result.success(leaveRequestsService.list1());
    }
    @GetMapping("/getOne")
    @Operation(summary = "2.获取一条请假申请")
    public Result getOne(Long id) {
        log.info("getOnecontroller");
        if(leaveRequestsService.getOne(id)==null)
            return Result.error("没有该条请假申请");
        return Result.success(leaveRequestsService.getOne(id));
    }
    @PostMapping("/save")
    @Operation(summary = "3.添加一条请假申请")
    public Result save(@RequestBody LeaveRequests leaveRequests) {
        if(leaveRequestsService.save(leaveRequests))
            return Result.success("添加成功");
        return Result.error("添加失败");
    }
    @PostMapping("/update")
    @Operation(summary = "4.修改一条请假申请")
    public Result update(@RequestBody LeaveRequests leaveRequests) {
        if(leaveRequestsService.updateById(leaveRequests))
            return Result.success("修改成功");
        return Result.error("修改失败");
    }
    @DeleteMapping("/delete")
    @Operation(summary = "5.删除一条请假申请")
    public Result delete(Long id) {
        if(leaveRequestsService.removeById(id))
            return Result.success("删除成功");
        return Result.error("删除失败");
    }
    @GetMapping("/change")
    @Operation(summary = "6.请假审批成功")
    public Result change(Integer id) {
        if(leaveRequestsService.change(id))
            return Result.success("审批成功");
        return Result.error("权限不足");
    }
    @GetMapping("/reject")
    @Operation(summary = "7.请假审批失败")
    public Result reject(Integer id) {
        if(leaveRequestsService.reject(id))
            return Result.success("审批成功");
        return Result.error("权限不足");
    }
    @GetMapping("/listmy")
    @Operation(summary = "7.获取自己的请假申请列表")
    public Result listmy() {
        return Result.success(leaveRequestsService.listmy());
    }

}

4.1.5岗位管理

package com.bo.controller;

import com.bo.domain.pojo.Positions;
import com.bo.service.PositionsService;
import com.bo.utils.Result;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.log4j.Log4j2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * @author ctx
 * @version 1.0
 * @description: TODO
 * @date 2024/12/31 10:58
 */
@RestController
@RequestMapping("/position")
@Tag(name = "岗位相关 API", description = "岗位相关 API")
@Log4j2
@CrossOrigin
public class PositionsController {
    @Autowired
    private PositionsService positionsService;
    @GetMapping("/list")
    @Operation(summary = "1.获取所有岗位")
    public Result list(){
        return Result.success(positionsService.list());
    }
    @GetMapping("/getOne")
    @Operation(summary = "2.获取单个岗位")
    public Result getOne(Long id){
        return Result.success(positionsService.getOne(id));
    }
    @PostMapping("/save")
    @Operation(summary = "3.添加岗位")
    public Result save(@RequestBody Positions positions){
        log.info("添加岗位：{}",positions);
        if(positionsService.save(positions))
            return Result.success("添加成功");
        return Result.error("添加失败");
    }
    @PostMapping("/update")
    @Operation(summary = "4.修改岗位")
    public Result update(@RequestBody Positions positions){
        log.info("修改岗位：{}",positions);
        if(positionsService.updateById(positions))
            return Result.success("修改成功");
        return Result.error("修改失败");
    }
    @DeleteMapping("/delete")
    @Operation(summary = "5.删除岗位")
    public Result delete(Long id){
        log.info("删除岗位：{}",id);
        if(positionsService.removeById(id))
            return Result.success("删除成功");
        return Result.error("删除失败,该岗位下有员工");
    }
}

4.1.6用户管理

package com.bo.controller;

import com.bo.domain.dto.UserDto;
import com.bo.domain.pojo.Users;
import com.bo.service.UserService;
import com.bo.utils.JwtUtil;
import com.bo.utils.Result;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.log4j.Log4j2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.*;

import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * @author ctx
 * @version 1.0
 * @description: TODO
 * @date 2024/12/31 10:38
 */
@RestController
@RequestMapping("/users")
@Tag(name = "用户相关 API", description = "用户相关 API")
@Log4j2
@CrossOrigin
public class UsersController {
    @Autowired
    private UserService userService;
    @Autowired
    private StringRedisTemplate redisTemplate;
    @GetMapping("/getUserlist")
    @Operation(summary = "1.获取所有用户信息")
    public Result getUserlist() {
        return Result.success(userService.list());
    }
    @GetMapping("/getUser")
    @Operation(summary = "2.获取一条用户信息")
    public Result getUser(Long id) {
        if(userService.getUser(id)!=null)
        return Result.success(userService.getUser(id));
        return Result.error("用户不存在");
    }
    @PostMapping("/saveUser")
    @Operation(summary = "3.添加一条用户信息")
    public Result saveUser(@RequestBody Users users) {
        log.info("users:{}",users);
        if(userService.save(users))
            return Result.success("添加成功");
        return Result.error("添加失败");
    }
    @PostMapping("/updateUser")
    @Operation(summary = "4.修改一条用户信息")
    public Result updateUser(@RequestBody UserDto users) {
        log.info("users:{}",users);
        if(userService.updateById(users))
            return Result.success("修改成功");
        return Result.error("修改失败");
    }
    @DeleteMapping("/deleteUser")
    @Operation(summary = "5.删除一条用户信息")
    public Result deleteUser(Long id) {
        log.info("id:{}",id);
        if(userService.removeById(id))
            return Result.success("删除成功");
        return Result.error("删除失败");
    }
    @PostMapping("/login")
//    @CrossOrigin
    @Operation(summary = "6.用户登录")
    public Result login(@RequestBody Users users) {
        log.info("users:{}",users);
        Users user = userService.login(users);
        if(userService.login(users)!=null){
            Map<String, Object> claims = Map.of("id",user.getId());
            String token = JwtUtil.genToken(claims);
            //把token存入redis
            redisTemplate.opsForValue().set(token,token,1, TimeUnit.DAYS);
            return Result.success(token);
        }
        return Result.error("用户名或密码错误");
    }
    @GetMapping("/getUserBy")
    @Operation(summary = "7.获取当前用户的信息")
    public Result getUserBy() {
        return Result.success(userService.getUserBy());
    }
}

4.2服务层代码

4.2.1考勤管理

package com.bo.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.bo.domain.pojo.AttendanceRecords;
import com.bo.domain.vo.AttendanceRecordsVo;
import com.bo.mapper.AttendanceRecordsDao;
import com.bo.service.AttendanceRecordsService;
import com.bo.utils.ThreadLocalUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * @author ctx
 * @version 1.0
 * @description: TODO
 * @date 2024/12/31 8:51
 */
@Service
public class AttendanceRecordsServiceImpl extends ServiceImpl<AttendanceRecordsDao, AttendanceRecords> implements AttendanceRecordsService {
    @Autowired
    private AttendanceRecordsDao attendanceRecordsDao;
    @Override
    public List<AttendanceRecordsVo> list1(){
        return attendanceRecordsDao.list();
    }

    @Override
    public AttendanceRecords getOne(Integer id) {
        return attendanceRecordsDao.selectByPrimaryKey(id);
    }

    @Override
    public boolean save(AttendanceRecords attendanceRecords){
        Map<String ,Object> map = ThreadLocalUtil.get();
        Integer id = (Integer) map.get("id");
        attendanceRecords.setEmployeeId(id);
        //获取上次打卡记录，判断日期是否是今天
        AttendanceRecords attendanceRecordss = attendanceRecordsDao.selectByksy(id);
        if (attendanceRecordss != null) {
            return false;
        }
        //9点上班，17点下班
        //迟到分钟
        if (attendanceRecords.getCheckInTime().getHours() <= 9 ) {
            attendanceRecords.setLateMinutes(0);
            System.out.println("迟到分钟：" + attendanceRecords.getLateMinutes());
        } else {
            attendanceRecords.setLateMinutes((attendanceRecords.getCheckInTime().getHours() - 8-9) * 60 + attendanceRecords.getCheckInTime().getMinutes());
            System.out.println(attendanceRecords.getCheckInTime().getHours());
            System.out.println("迟到分钟：" + attendanceRecords.getLateMinutes());
        }

        return attendanceRecordsDao.insertSelective(attendanceRecords) > 0;
    }

    @Override
    public boolean updateById(AttendanceRecords attendanceRecord) {
        // 获取当前登录用户id
        Map<String, Object> map = ThreadLocalUtil.get();
        Integer id = (Integer) map.get("id");
        AttendanceRecords attendanceRecords = attendanceRecordsDao.selectByksy(id);


        // 设置下班打卡时间
        attendanceRecords.setCheckOutTime(attendanceRecord.getCheckOutTime());

        // 获取标准上下班时间
        Calendar standardStart = Calendar.getInstance();
        standardStart.setTime(attendanceRecords.getCheckInTime());
        standardStart.set(Calendar.HOUR_OF_DAY, 9); // 上班时间9点
        standardStart.set(Calendar.MINUTE, 0);
        standardStart.set(Calendar.SECOND, 0);

        Calendar standardEnd = Calendar.getInstance();
        standardEnd.setTime(attendanceRecords.getCheckInTime());
        standardEnd.set(Calendar.HOUR_OF_DAY, 17); // 下班时间17点
        standardEnd.set(Calendar.MINUTE, 0);
        standardEnd.set(Calendar.SECOND, 0);

        // 获取实际打卡时间
        Calendar actualEnd = Calendar.getInstance();
        actualEnd.setTime(attendanceRecords.getCheckOutTime());

        // 计算早退分钟数
        if (actualEnd.before(standardEnd)) {
            long diffMinutes = (standardEnd.getTimeInMillis() - actualEnd.getTimeInMillis()) / (60 * 1000);
            attendanceRecords.setEarlyLeaveMinutes((int) diffMinutes);
        } else {
            attendanceRecords.setEarlyLeaveMinutes(0);
        }

        // 计算加班分钟数
        if (actualEnd.after(standardEnd)) {
            long diffMinutes = (actualEnd.getTimeInMillis() - standardEnd.getTimeInMillis()) / (60 * 1000);
            attendanceRecords.setOvertimeMinutes((int) diffMinutes);
        } else {
            attendanceRecords.setOvertimeMinutes(0);
        }

        // 判断考勤状态
        Calendar actualStart = Calendar.getInstance();
        actualStart.setTime(attendanceRecords.getCheckInTime());

        // 如果上班打卡超过10点(9点后1小时)，记为缺勤
        Calendar lateLimit = (Calendar) standardStart.clone();
        lateLimit.add(Calendar.HOUR_OF_DAY, 1);

        if (actualStart.after(lateLimit)) {
            attendanceRecords.setStatus("缺勤");
        } else {
            attendanceRecords.setStatus("正常");
        }

        return attendanceRecordsDao.updateByPrimaryKeySelective(attendanceRecords) > 0;
    }

    @Override
    public boolean removeById(Integer id) {
        return attendanceRecordsDao.deleteByPrimaryKey(id) > 0;
    }

    @Override
    public List<AttendanceRecords> listmy() {
        Map<String ,Object> map = ThreadLocalUtil.get();
        Integer id = (Integer) map.get("id");
        return attendanceRecordsDao.listmy(id);
    }
}

4.2.2部门管理

package com.bo.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.bo.domain.pojo.AttendanceRecords;
import com.bo.domain.pojo.Departments;
import com.bo.domain.pojo.Employees;
import com.bo.mapper.AttendanceRecordsDao;
import com.bo.mapper.DepartmentsMapper;
import com.bo.mapper.EmployeesMapper;
import com.bo.service.AttendanceRecordsService;
import com.bo.service.DepartmentsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @author ctx
 * @version 1.0
 * @description: TODO
 * @date 2024/12/31 9:40
 */
@Service
public class DepartmentsServiceImpl extends ServiceImpl<DepartmentsMapper, Departments> implements DepartmentsService {
    @Autowired
    private DepartmentsMapper departmentsMapper;
    @Autowired
    private EmployeesMapper employeesMapper;
    @Override
    public List<Departments> list() {
        return departmentsMapper.list();
    }

    @Override
    public Departments getById(Long id) {
        return departmentsMapper.selectByPrimaryKey(id);
    }

    @Override
    public Boolean removeById(Long id) {
        List<Employees> employees = employeesMapper.selectlist(id);
        if (employees.size() > 0) {
            return false;
        }
        return departmentsMapper.deleteByPrimaryKey(id) > 0;
    }

    @Override
    public boolean updateById(Departments departments) {
        return departmentsMapper.updateByPrimaryKeySelective(departments) > 0;
    }

    @Override
    public boolean save(Departments departments) {
        return departmentsMapper.insertSelective(departments) > 0;
    }
}

4.2.3员工管理

package com.bo.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.bo.domain.dto.EmployeeDto;
import com.bo.domain.pojo.Departments;
import com.bo.domain.pojo.Employees;
import com.bo.domain.pojo.UserRoles;
import com.bo.domain.pojo.Users;
import com.bo.mapper.*;
import com.bo.service.DepartmentsService;
import com.bo.service.EmployeesService;
import com.bo.utils.ThreadLocalUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.UUID;

/**
 * @author ctx
 * @version 1.0
 * @description: TODO
 * @date 2024/12/31 10:04
 */
@Service
public class EmployeesServiceImpl extends ServiceImpl<EmployeesMapper, Employees> implements EmployeesService {
    @Autowired
    private EmployeesMapper employeesMapper;
    @Autowired
    private RolesMapper rolesMapper;
    @Autowired
    private UserRolesMapper userRolesMapper;
    @Autowired
    private UsersMapper usersMapper;
    @Override
    public List<EmployeeDto> list1(){
        return employeesMapper.list();
    }

    @Override
    public EmployeeDto getById(Long id) {
        return employeesMapper.selectByKey(id);
    }

    @Override
    public boolean removeById(Long id) {
        return employeesMapper.deleteByPrimaryKey(id) > 0;
    }

    @Override
    public boolean updateById(EmployeeDto employees) {
        Employees employee = new Employees();
        employee.setName(employees.getName());
        employee.setEmail(employees.getEmail());
        employee.setPhone(employees.getPhone());
        employee.setDepartmentId(employees.getDepartmentId());
        employee.setPositionId(employees.getPositionId());
        employee.setStatus(employees.getStatus());
        employee.setSalary(employees.getSalary());
        employee.setId(employees.getId());
        Integer roleid = rolesMapper.selectidbyname(employees.getRole());
        userRolesMapper.updateByuserId(employees.getId(),roleid);
        return employeesMapper.updateByPrimaryKeySelective(employee) > 0;
    }

    @Override
    public Users save(EmployeeDto employees) {
        Employees employee = new Employees();
        employee.setName(employees.getName());
        employee.setEmail(employees.getEmail());
        employee.setPhone(employees.getPhone());
        employee.setDepartmentId(employees.getDepartmentId());
        employee.setPositionId(employees.getPositionId());
        employee.setStatus(employees.getStatus());
        employee.setSalary(employees.getSalary());
        employee.setHireDate(employees.getHireDate());
//        employeesMapper.insertSelective(employee);
        employeesMapper.insertSelective(employee);
        Integer id = employee.getId();
        System.out.println(id);
//        Integer id =employeesMapper.selectidbyname(employees.getName());
        Integer roleid = rolesMapper.selectidbyname(employees.getRole());
//        Integer createid = ThreadLocalUtil.get();
//        System.out.println(createid);


        Users users = new Users();
//        生成随机的username
//        String randomUsername = UUID.randomUUID().toString().replace("-", "");
        String randomUsername = employees.getPhone();
        users.setUsername(randomUsername);
        users.setPassword("123456");
        users.setEmployeeId(id);
        usersMapper.insertSelective(users);

        UserRoles userRoles = new UserRoles();
        Integer idd = users.getId();
        userRoles.setUserId(idd);
        userRoles.setRoleId(roleid);
        userRolesMapper.insertSelective(userRoles);

        return users;
    }
}

4.2.4请假管理

package com.bo.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.bo.domain.dto.LeaveDto;
import com.bo.domain.pojo.LeaveRequests;
import com.bo.domain.pojo.Users;
import com.bo.domain.vo.LeaveRequestsVo;
import com.bo.mapper.LeaveRequestsMapper;
import com.bo.mapper.UsersMapper;
import com.bo.service.LeaveRequestsService;
import com.bo.utils.ThreadLocalUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;

/**
 * @author ctx
 * @version 1.0
 * @description: TODO
 * @date 2024/12/31 10:24
 */
@Service
public class LeaveRequestsServiceImpl extends ServiceImpl<LeaveRequestsMapper, LeaveRequests> implements LeaveRequestsService {
    @Autowired
    private LeaveRequestsMapper leaveRequestsMapper;
    @Autowired
    private UsersMapper usersMapper;
    public List<LeaveRequestsVo> list1()
    {
        return leaveRequestsMapper.list();
    }

    @Override
    public LeaveRequests getOne(Long id) {
        return leaveRequestsMapper.selectByPrimaryKey(id);
    }

    @Override
    public boolean save(LeaveRequests leaveRequests) {
        Map<String ,Object> map = ThreadLocalUtil.get();
        Integer id = (Integer) map.get("id");
        leaveRequests.setEmployeeId(id);
        return leaveRequestsMapper.insertSelective(leaveRequests) > 0;
    }

    @Override
    public boolean updateById(LeaveRequests leaveRequests) {
        return leaveRequestsMapper.updateByPrimaryKeySelective(leaveRequests) > 0;
    }

    @Override
    public boolean removeById(Long id) {
        return leaveRequestsMapper.deleteByPrimaryKey(id) > 0;
    }
    @Override
    public boolean change(Integer id1) {
        Map<String ,Object> map = ThreadLocalUtil.get();
        Integer id = (Integer) map.get("id");
//        Users users = usersMapper.selectByPrimaryKey(Long.valueOf((id)));
//        Integer empid = users.getId();
        System.out.println(id+":::"+id1);
        LeaveRequests leave = leaveRequestsMapper.selectByPrimaryKey(Long.valueOf(id1));
        Integer id2 = leave.getEmployeeId();
        System.out.println(id+":::"+id2);
        LeaveDto   leavedto= leaveRequestsMapper.change(id,id2);
//        LeaveDto   leavedto= leaveRequestsMapper.change(id,id2);
        System.out.println(leavedto);
//        LeaveRequests leaveRequest = leaveRequestsMapper.selectByPrimaryKey(Long.valueOf(id1));

        if( "部门主管".equals(leavedto.getApproverroles()))
        {
            LeaveRequests leaveRequests = new LeaveRequests();
            leaveRequests.setId(id1);
//            leaveRequests.setStatus("已审批");
            leaveRequests.setApprover1Id(id);
            leaveRequestsMapper.updateByPrimaryKeySelective(leaveRequests);
            LeaveRequests leaveRequest = leaveRequestsMapper.selectByPrimaryKey(Long.valueOf(id1));

            if(leaveRequest.getApprover1Id()!=null&& leaveRequest.getApprover2Id()!=null){
                LeaveRequests leaveRequests1 = new LeaveRequests();
                leaveRequests1.setId(id1);
                leaveRequests1.setStatus("已批准");
                leaveRequestsMapper.updateByPrimaryKeySelective(leaveRequests1);
            }
            return true;
        }else if( "人事主管".equals(leavedto.getApproverroles())){
            LeaveRequests leaveRequests = new LeaveRequests();
            leaveRequests.setId(id1);
            leaveRequests.setApprover2Id(id);
            leaveRequestsMapper.updateByPrimaryKeySelective(leaveRequests);
            LeaveRequests leaveRequest = leaveRequestsMapper.selectByPrimaryKey(Long.valueOf(id1));

            if(leaveRequest.getApprover1Id()!=null&& leaveRequest.getApprover2Id()!=null){
                LeaveRequests leaveRequests1 = new LeaveRequests();
                leaveRequests1.setId(id1);
                leaveRequests1.setStatus("已批准");
                leaveRequestsMapper.updateByPrimaryKeySelective(leaveRequests1);
            }
            return true;
        }


        return false;
//        return false;
    }

    @Override
    public List<LeaveRequests> listmy() {
        Map<String ,Object> map = ThreadLocalUtil.get();
        Integer id1 = (Integer) map.get("id");
        return leaveRequestsMapper.listmy(id1);
    }

    @Override
    public boolean reject(Integer id) {
        return leaveRequestsMapper.reject(id)>0;
    }
}

4.2.5用户管理

package com.bo.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.bo.domain.dto.UserDto;
import com.bo.domain.pojo.Employees;
import com.bo.domain.pojo.Users;
import com.bo.domain.vo.UserVo;
import com.bo.mapper.EmployeesMapper;
import com.bo.mapper.UsersMapper;
import com.bo.service.UserService;
import com.bo.utils.ThreadLocalUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;

/**
 * @author ctx
 * @version 1.0
 * @description: TODO
 * @date 2024/12/28 21:18
 */
@Service
public class UserServiceImpl extends ServiceImpl<UsersMapper, Users> implements UserService {
    @Autowired
    private UsersMapper usersMapper;
    @Autowired
    private EmployeesMapper employeesMapper;
    @Override
    public List<Users> list() {
        return usersMapper.list();
    }

    @Override
    public Users getUser(Long id) {
        return usersMapper.selectByPrimaryKey(id);
    }

    @Override
    public boolean save(Users users) {
        return usersMapper.insertSelective(users) > 0;
    }

    @Override
    public boolean updateById(UserDto users) {
        Users user = new Users();
        user.setId(users.getId());
        user.setPassword(users.getPassword());
        Employees employees = new Employees();
        employees.setId(users.getId());
        employees.setEmail(users.getEmail());
        employees.setPhone(users.getPhone());
        employeesMapper.updateByPrimaryKeySelective(employees);
        if(users.getPassword()==null)
            return true;
        return usersMapper.updateByPrimaryKeySelective(user) > 0;
    }

    @Override
    public boolean removeById(Long id) {
        return usersMapper.deleteByPrimaryKey(id) > 0;
    }

    @Override
    public Users login(Users users) {
        return usersMapper.login(users);
    }

    @Override
    public UserVo getUserBy() {
        Map<String ,Object> map = ThreadLocalUtil.get();
        Integer id = (Integer) map.get("id");
        return usersMapper.getUserBy(id);
    }
}

4.2.6岗位管理

package com.bo.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.bo.domain.pojo.Employees;
import com.bo.domain.pojo.Positions;
import com.bo.mapper.EmployeesMapper;
import com.bo.mapper.PositionsMapper;
import com.bo.service.PositionsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @author ctx
 * @version 1.0
 * @description: TODO
 * @date 2024/12/31 10:59
 */
@Service
public class PositionsServiceImpl extends ServiceImpl<PositionsMapper, Positions> implements PositionsService {
    @Autowired
    private PositionsMapper positionsMapper;
    @Autowired
    private EmployeesMapper employeesMapper;
    public List<Positions> list()
    {
        return positionsMapper.list();
    }

    @Override
    public Positions getOne(Long id) {
        return positionsMapper.selectByPrimaryKey(id);
    }

    @Override
    public boolean save(Positions positions) {
        return positionsMapper.insertSelective(positions) > 0;
    }

    @Override
    public boolean updateById(Positions positions) {
        return positionsMapper.updateByPrimaryKeySelective(positions) > 0;
    }

    @Override
    public boolean removeById(Long id) {
        List<Employees> employees = employeesMapper.selectlist2(id);
        if (employees.size() > 0) {
            return false;
        }
        return positionsMapper.deleteByPrimaryKey(id) > 0;
    }
}

4.3数据层代码

代码太多了，这里就不放了。

五、运行效果截图

5.1登录界面

5.2首页界面

首页有统计分析图标

5.3部门管理界面

有个简单的树形结构

5.4岗位管理界面

5.5员工管理界面

5.6考勤管理界面

打卡在app端（调用了高德的API进行定位打卡）

5.7请假管理界面

5.8个人中心界面

5.9APP端打卡

我这里用的是MUMU模拟器模拟手机端。

有需要的添加下方我的联系方式。