企业员工管理体系（Springboot+Redis+Vue+uniapp）
一、媒介这个是实训时的一个企业员工管理体系，整体效果看起来还不错，文档和源代码及数据库有必要的可以在文末添加我的接洽方式或者直接私信我哈（有偿），可直接跳转到运行效果那先看看。
二、需求规格分析书
2.1产物前景
企业员工管理体系旨在帮助企业实现员工信息的高效管理。通过本体系，管理员可以快速完成员工档案录入、查询、更新、导出等操作；同时提供权限管理功能，以满足不同部分和脚色的安全访问需求。该体系未来还可扩展为支持员工培训记载、绩效评估、考勤管理等功能模块。
2.2产物功能
[*]1、员工管理：支持员工档案的新增、查询、修改、删除。
[*]2、权限管理：基于脚色的权限控制，管理员可以分配权限。
[*]3、考勤管理：员工工作日需打卡签到、签退。
[*]4、请假管理：管理员可审批员工请假申请。
[*]5、登录认证：基于账号暗码的登录认证，支持验证码校验。
[*]6、数据统计：天生企业员工统计报表，如部分员工人数分布。
[*]7、日志记载：记载全部用户的操作行为，支持管理员查询。
2.3功能需求
①体系管理员：负责体系管理（用户新增、查询、删除、修改、暗码重置、禁用、启用，分配脚色和权限）等。
②员工：负责考勤打卡和请假申请（信息查询、修改，请假申请、查察、取消，打卡签到/签退）
③部分管理员：负责本部分员工的管理（查察本部分员工出勤记载和请假记载，审批本部分请假申请，查询本部分出勤统计、导出部分考勤数据）
④HR（人力资源管理员）：负责公司层面的员工管理（全体员工信息查察、添加、删除、修改，查询员工出勤和请假记载，审批高级别请假申请（如特别环境需 HR 答应的申请），天生公司整体出勤和请假报表，统计员工出勤率、请假率，导出员工考勤和请假统计数据）
https://i-blog.csdnimg.cn/direct/b4f38fb8f1c7445f9bdc42d665b6c2cf.png
注：这个用例图可能画的有点问题，背面也不想改了就这样了，然后需求规格分析书上的需求可能和实际需求也不完全一样，以实际效果为主。
三、体系设计陈诉
3.1体系功能条理图
https://i-blog.csdnimg.cn/direct/aac39ae1b4784ce3bf4300af95c38ba1.png
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登录界面
https://i-blog.csdnimg.cn/direct/64d8da7a38ad42088807972bb8b134a8.png
5.2首页界面
首页有统计分析图标
https://i-blog.csdnimg.cn/direct/7d4ec3cd5aeb4975b64b98fb74cc2419.png
5.3部分管理界面
有个简朴的树形布局
https://i-blog.csdnimg.cn/direct/abc8cfa3e2eb44458c43bebffec06ffd.png
5.4岗位管理界面
https://i-blog.csdnimg.cn/direct/84e4aacc74ce414b8301995eb6a7d7ca.png
5.5员工管理界面
https://i-blog.csdnimg.cn/direct/1cb74a17b5d94362a91576d8e36690b6.png
5.6考勤管理界面
打卡在app端（调用了高德的API进行定位打卡）
https://i-blog.csdnimg.cn/direct/941e2f7069bf431b84a3a276c568eac1.png
5.7请假管理界面
https://i-blog.csdnimg.cn/direct/704a83a64f654fb9868bd80aadcc9593.png
https://i-blog.csdnimg.cn/direct/623e9cfa1f6447839bbbe638084ca384.png
5.8个人中心界面
https://i-blog.csdnimg.cn/direct/43c40eec82bf40da8bcb7686d3d2bbf7.png
5.9APP端打卡
我这里用的是MUMU模仿器模仿手机端。
https://i-blog.csdnimg.cn/direct/daf20e1045e44fb0af8e2cff16120f39.png
有必要的添加下方我的接洽方式。
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
页:
[1]