src/main/java/com/controller/ChengbenjieyuController.java

@@ -0,0 +1,333 @@
+package com.controller;
+
+// 导入用于格式化日期的类
+import java.text.SimpleDateFormat;
+// 导入动态数组类
+import java.util.ArrayList;
+// 导入用于操作数组的工具类
+import java.util.Arrays;
+// 导入用于处理日期和时间的类
+import java.util.Calendar;
+// 导入 Map 接口，用于存储键值对
+import java.util.Map;
+// 导入 HashMap 类，是 Map 接口的实现类
+import java.util.HashMap;
+// 导入迭代器接口
+import java.util.Iterator;
+// 导入日期类
+import java.util.Date;
+// 导入列表接口
+import java.util.List;
+// 导入 HTTP 请求类
+import javax.servlet.http.HttpServletRequest;
+
+// 导入自定义的验证工具类
+import com.utils.ValidatorUtils;
+// 导入 Apache Commons Lang 工具类，用于字符串操作
+import org.apache.commons.lang3.StringUtils;
+// 导入 Spring 的依赖注入注解
+import org.springframework.beans.factory.annotation.Autowired;
+// 导入 Spring 的日期格式化注解
+import org.springframework.format.annotation.DateTimeFormat;
+// 导入 Spring 的路径变量注解
+import org.springframework.web.bind.annotation.PathVariable;
+// 导入 Spring 的请求体注解
+import org.springframework.web.bind.annotation.RequestBody;
+// 导入 Spring 的请求映射注解
+import org.springframework.web.bind.annotation.RequestMapping;
+// 导入 Spring 的请求参数注解
+import org.springframework.web.bind.annotation.RequestParam;
+// 导入 Spring 的 REST 控制器注解
+import org.springframework.web.bind.annotation.RestController;
+// 导入 MyBatis-Plus 的实体包装器类
+import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入 MyBatis-Plus 的包装器接口
+import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入自定义的忽略认证注解
+import com.annotation.IgnoreAuth;
+
+// 导入成本结余实体类
+import com.entity.ChengbenjieyuEntity;
+// 导入成本结余视图类
+import com.entity.view.ChengbenjieyuView;
+
+// 导入成本结余服务类
+import com.service.ChengbenjieyuService;
+// 导入令牌服务类
+import com.service.TokenService;
+// 导入自定义的分页工具类
+import com.utils.PageUtils;
+// 导入自定义的响应结果类
+import com.utils.R;
+// 导入自定义的 MD5 工具类
+import com.utils.MD5Util;
+// 导入自定义的 MyBatis-Plus 工具类
+import com.utils.MPUtil;
+// 导入自定义的通用工具类
+import com.utils.CommonUtil;
+
+
+
+//成本结余
+// 后端接口
+ // @author
+ // @email
+ //@date 2021-04-24 15:19:31
+
+// 标记为 REST 控制器，用于处理 HTTP 请求并返回 JSON 数据
+@RestController
+// 定义请求映射的基础路径
+@RequestMapping("/chengbenjieyu")
+public class ChengbenjieyuController {
+    // 自动注入成本结余服务类的实例
+    @Autowired
+    private ChengbenjieyuService chengbenjieyuService;
+
+
+    // 后端列表
+     // 该方法用于处理后端获取成本结余列表的请求，支持分页查询，同时可根据日期范围进行筛选。
+     // @param params 请求参数，包含分页、排序等信息
+     // @param chengbenjieyu 成本结余实体，用于构建查询条件
+     // @param riqistart 开始日期，可为空，用于筛选数据
+    // @param riqiend 结束日期，可为空，用于筛选数据
+     // @param request HTTP 请求对象
+    // @return 包含分页数据的响应结果
+
+    @RequestMapping("/page")
+    public R page(@RequestParam Map<String, Object> params, ChengbenjieyuEntity chengbenjieyu,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date riqistart,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date riqiend,
+                  HttpServletRequest request) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<ChengbenjieyuEntity> ew = new EntityWrapper<ChengbenjieyuEntity>();
+        // 如果开始日期不为空，则添加大于等于该日期的查询条件
+        if (riqistart != null) ew.ge("riqi", riqistart);
+        // 如果结束日期不为空，则添加小于等于该日期的查询条件
+        if (riqiend != null) ew.le("riqi", riqiend);
+        // 调用服务类的查询分页方法，传入请求参数和处理后的查询条件
+        PageUtils page = chengbenjieyuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, chengbenjieyu), params), params));
+        // 返回成功响应，并将分页数据放入响应结果中
+        return R.ok().put("data", page);
+    }
+
+
+     // 前端列表
+     // 该方法用于处理前端获取成本结余列表的请求，支持分页查询，同时可根据日期范围进行筛选。
+     // @param params 请求参数，包含分页、排序等信息
+    // @param chengbenjieyu 成本结余实体，用于构建查询条件
+     // @param riqistart 开始日期，可为空，用于筛选数据
+     // @param riqiend 结束日期，可为空，用于筛选数据
+     // @param request HTTP 请求对象
+     // @return 包含分页数据的响应结果
+
+    @RequestMapping("/list")
+    public R list(@RequestParam Map<String, Object> params, ChengbenjieyuEntity chengbenjieyu,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date riqistart,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date riqiend,
+                  HttpServletRequest request) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<ChengbenjieyuEntity> ew = new EntityWrapper<ChengbenjieyuEntity>();
+        // 如果开始日期不为空，则添加大于等于该日期的查询条件
+        if (riqistart != null) ew.ge("riqi", riqistart);
+        // 如果结束日期不为空，则添加小于等于该日期的查询条件
+        if (riqiend != null) ew.le("riqi", riqiend);
+        // 调用服务类的查询分页方法，传入请求参数和处理后的查询条件
+        PageUtils page = chengbenjieyuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, chengbenjieyu), params), params));
+        // 返回成功响应，并将分页数据放入响应结果中
+        return R.ok().put("data", page);
+    }
+
+
+    // 列表
+    // 该方法用于获取满足特定条件的成本结余列表。
+   // @param chengbenjieyu 成本结余实体，用于构建查询条件
+     // @return 包含成本结余列表的响应结果
+
+    @RequestMapping("/lists")
+    public R list(ChengbenjieyuEntity chengbenjieyu) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<ChengbenjieyuEntity> ew = new EntityWrapper<ChengbenjieyuEntity>();
+        // 设置查询条件，使所有字段相等
+        ew.allEq(MPUtil.allEQMapPre(chengbenjieyu, "chengbenjieyu"));
+        // 调用服务类的查询列表视图方法，传入查询条件
+        return R.ok().put("data", chengbenjieyuService.selectListView(ew));
+    }
+
+     // 查询
+     // 该方法用于根据条件查询单个成本结余信息。
+     // @param chengbenjieyu 成本结余实体，用于构建查询条件
+     // @return 包含查询结果的响应结果
+
+    @RequestMapping("/query")
+    public R query(ChengbenjieyuEntity chengbenjieyu) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<ChengbenjieyuEntity> ew = new EntityWrapper<ChengbenjieyuEntity>();
+        // 设置查询条件，使所有字段相等
+        ew.allEq(MPUtil.allEQMapPre(chengbenjieyu, "chengbenjieyu"));
+        // 调用服务类的查询视图方法，传入查询条件
+        ChengbenjieyuView chengbenjieyuView = chengbenjieyuService.selectView(ew);
+        // 返回成功响应，并将查询结果放入响应结果中
+        return R.ok("查询成本结余成功").put("data", chengbenjieyuView);
+    }
+
+
+     // 后端详情
+     // 该方法用于获取指定 ID 的成本结余详细信息。
+     //@param id 成本结余的 ID
+     // @return 包含成本结余详细信息的响应结果
+
+    @RequestMapping("/info/{id}")
+    public R info(@PathVariable("id") Long id) {
+        // 根据 ID 查询成本结余实体
+        ChengbenjieyuEntity chengbenjieyu = chengbenjieyuService.selectById(id);
+        // 返回成功响应，并将成本结余详细信息放入响应结果中
+        return R.ok().put("data", chengbenjieyu);
+    }
+
+
+    //前端详情
+     // 该方法用于获取指定 ID 的成本结余详细信息。
+     //@param id 成本结余的 ID
+    // @return 包含成本结余详细信息的响应结果
+
+    @RequestMapping("/detail/{id}")
+    public R detail(@PathVariable("id") Long id) {
+        // 根据 ID 查询成本结余实体
+        ChengbenjieyuEntity chengbenjieyu = chengbenjieyuService.selectById(id);
+        // 返回成功响应，并将成本结余详细信息放入响应结果中
+        return R.ok().put("data", chengbenjieyu);
+    }
+
+
+    // 后端保存
+     // 该方法用于在后端保存新的成本结余信息。
+    //@param chengbenjieyu 成本结余实体，包含要保存的信息
+   // @param request HTTP 请求对象
+     // @return 保存成功的响应结果
+
+    @RequestMapping("/save")
+    public R save(@RequestBody ChengbenjieyuEntity chengbenjieyu, HttpServletRequest request) {
+        // 为成本结余实体设置一个唯一的 ID，由当前时间戳和随机数组成
+        chengbenjieyu.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(chengbenjieyu);
+        // 调用服务类的插入方法，保存成本结余信息
+        chengbenjieyuService.insert(chengbenjieyu);
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     //前端保存
+     // 该方法用于在前端保存新的成本结余信息。
+     // @param chengbenjieyu 成本结余实体，包含要保存的信息
+     //@param request HTTP 请求对象
+     // @return 保存成功的响应结果
+
+    @RequestMapping("/add")
+    public R add(@RequestBody ChengbenjieyuEntity chengbenjieyu, HttpServletRequest request) {
+        // 为成本结余实体设置一个唯一的 ID，由当前时间戳和随机数组成
+        chengbenjieyu.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(chengbenjieyu);
+        // 调用服务类的插入方法，保存成本结余信息
+        chengbenjieyuService.insert(chengbenjieyu);
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 修改
+     //该方法用于修改已有的成本结余信息。
+     //@param chengbenjieyu 成本结余实体，包含要修改的信息
+     // @param request HTTP 请求对象
+    // @return 修改成功的响应结果
+
+    @RequestMapping("/update")
+    public R update(@RequestBody ChengbenjieyuEntity chengbenjieyu, HttpServletRequest request) {
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(chengbenjieyu);
+        // 调用服务类的更新方法，根据 ID 更新成本结余信息
+        chengbenjieyuService.updateById(chengbenjieyu); // 全部更新
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 删除
+     // 该方法用于批量删除指定 ID 的成本结余信息。
+     // @param ids 要删除的成本结余的 ID 数组
+    // @return 删除成功的响应结果
+
+    @RequestMapping("/delete")
+    public R delete(@RequestBody Long[] ids) {
+        // 调用服务类的批量删除方法，根据 ID 列表删除成本结余信息
+        chengbenjieyuService.deleteBatchIds(Arrays.asList(ids));
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 提醒接口
+     // 该方法用于根据指定列和时间范围统计满足条件的成本结余数量。
+     // @param columnName 要统计的列名
+     // @param request HTTP 请求对象
+  // @param type 提醒类型
+     // @param map 请求参数，包含提醒开始时间和结束时间等信息
+    // @return 包含统计数量的响应结果
+
+    @RequestMapping("/remind/{columnName}/{type}")
+    public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
+                         @PathVariable("type") String type, @RequestParam Map<String, Object> map) {
+        // 将列名和提醒类型放入请求参数中
+        map.put("column", columnName);
+        map.put("type", type);
+
+        if (type.equals("2")) {
+            // 创建日期格式化对象
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+            // 获取日历实例
+            Calendar c = Calendar.getInstance();
+            Date remindStartDate = null;
+            Date remindEndDate = null;
+            if (map.get("remindstart") != null) {
+                // 获取提醒开始时间的偏移量
+                Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
+                // 设置日历时间为当前时间
+                c.setTime(new Date());
+                // 计算提醒开始日期
+                c.add(Calendar.DAY_OF_MONTH, remindStart);
+                remindStartDate = c.getTime();
+                // 将格式化后的提醒开始日期放入请求参数中
+                map.put("remindstart", sdf.format(remindStartDate));
+            }
+            if (map.get("remindend") != null) {
+                // 获取提醒结束时间的偏移量
+                Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
+                // 设置日历时间为当前时间
+                c.setTime(new Date());
+                // 计算提醒结束日期
+                c.add(Calendar.DAY_OF_MONTH, remindEnd);
+                remindEndDate = c.getTime();
+                // 将格式化后的提醒结束日期放入请求参数中
+                map.put("remindend", sdf.format(remindEndDate));
+            }
+        }
+
+        // 创建一个包装器，用于构建 SQL 查询条件
+        Wrapper<ChengbenjieyuEntity> wrapper = new EntityWrapper<ChengbenjieyuEntity>();
+        if (map.get("remindstart") != null) {
+            // 设置查询条件，列值大于等于提醒开始日期
+            wrapper.ge(columnName, map.get("remindstart"));
+        }
+        if (map.get("remindend") != null) {
+            // 设置查询条件，列值小于等于提醒结束日期
+            wrapper.le(columnName, map.get("remindend"));
+        }
+
+        // 调用服务类的统计数量方法，根据查询条件统计满足条件的成本结余数量
+        int count = chengbenjieyuService.selectCount(wrapper);
+        // 返回成功响应，并将统计数量放入响应结果中
+        return R.ok().put("count", count);
+    }
+}

src/main/java/com/controller/CommonController.java

@@ -0,0 +1,334 @@
+package com.controller;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.servlet.http.HttpServletRequest;
+
+import org.apache.commons.lang3.StringUtils;
+import org.json.JSONObject;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.util.ResourceUtils;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import com.annotation.IgnoreAuth;
+import com.baidu.aip.face.AipFace;
+import com.baidu.aip.face.MatchRequest;
+import com.baidu.aip.util.Base64Util;
+import com.baomidou.mybatisplus.mapper.EntityWrapper;
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.entity.ConfigEntity;
+import com.service.CommonService;
+import com.service.ConfigService;
+import com.utils.BaiduUtil;
+import com.utils.FileUtil;
+import com.utils.R;
+
+
+// 通用接口
+ // 该控制器类提供了一系列通用的业务接口，用于处理各种不同的功能需求，
+ // 如地理位置信息获取、人脸比对、数据查询、状态修改、统计计算等。
+
+@RestController
+public class CommonController {
+	// 自动注入通用服务类的实例，用于调用通用业务逻辑方法
+	@Autowired
+	private CommonService commonService;
+
+	// 自动注入配置服务类的实例，用于获取和管理系统配置信息
+	@Autowired
+	private ConfigService configService;
+
+	// 静态变量，用于存储百度人脸识别客户端实例，保证全局唯一
+	private static AipFace client = null;
+
+	// 静态变量，用于存储百度地图 API 的访问密钥
+	private static String BAIDU_DITU_AK = null;
+
+
+	 // 根据经纬度获取所在城市信息
+	 // @param lng 经度
+	// @param lat 纬度
+	// @return R 响应对象，包含操作结果和城市信息数据
+
+	@RequestMapping("/location")
+	public R location(String lng, String lat) {
+		// 如果百度地图 API 密钥为空，则从配置中获取
+		if (BAIDU_DITU_AK == null) {
+			BAIDU_DITU_AK = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "baidu_ditu_ak")).getValue();
+			// 如果获取到的密钥仍为空，则返回错误响应
+			if (BAIDU_DITU_AK == null) {
+				return R.error("请在配置管理中正确配置baidu_ditu_ak");
+			}
+		}
+		// 调用工具类方法，根据经纬度和 API 密钥获取城市信息
+		Map<String, String> map = BaiduUtil.getCityByLonLat(BAIDU_DITU_AK, lng, lat);
+		// 返回成功响应，并将城市信息数据放入响应结果中
+		return R.ok().put("data", map);
+	}
+
+
+	 //人脸比对接口
+	 // @param face1 第一张人脸的文件名
+	// @param face2 第二张人脸的文件名
+	// @param request HTTP 请求对象，用于获取文件路径等信息
+	 //@return R 响应对象，包含操作结果和人脸比对结果数据
+
+	@RequestMapping("/matchFace")
+	public R matchFace(String face1, String face2, HttpServletRequest request) {
+		// 如果百度人脸识别客户端实例为空，则进行初始化
+		if (client == null) {
+			/*String AppID = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "AppID")).getValue();*/
+			// 从配置中获取 API 密钥和 Secret 密钥
+			String APIKey = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "APIKey")).getValue();
+			String SecretKey = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "SecretKey")).getValue();
+			// 使用密钥获取访问令牌
+			String token = BaiduUtil.getAuth(APIKey, SecretKey);
+			// 如果令牌获取失败，则返回错误响应
+			if (token == null) {
+				return R.error("请在配置管理中正确配置APIKey和SecretKey");
+			}
+			// 初始化百度人脸识别客户端
+			client = new AipFace(null, APIKey, SecretKey);
+			// 设置连接超时时间为 2000 毫秒
+			client.setConnectionTimeoutInMillis(2000);
+			// 设置套接字超时时间为 60000 毫秒
+			client.setSocketTimeoutInMillis(60000);
+		}
+		JSONObject res = null;
+		try {
+			// 根据文件名和文件路径构建人脸文件对象
+			File file1 = new File(request.getSession().getServletContext().getRealPath("/upload") + "/" + face1);
+			File file2 = new File(request.getSession().getServletContext().getRealPath("/upload") + "/" + face2);
+			// 将文件转换为字节数组，并进行 Base64 编码
+			String img1 = Base64Util.encode(FileUtil.FileToByte(file1));
+			String img2 = Base64Util.encode(FileUtil.FileToByte(file2));
+			// 创建人脸比对请求对象
+			MatchRequest req1 = new MatchRequest(img1, "BASE64");
+			MatchRequest req2 = new MatchRequest(img2, "BASE64");
+			// 将两个请求对象添加到列表中
+			ArrayList<MatchRequest> requests = new ArrayList<MatchRequest>();
+			requests.add(req1);
+			requests.add(req2);
+			// 调用百度人脸识别客户端进行人脸比对
+			res = client.match(requests);
+			// 打印比对结果
+			System.out.println(res.get("result"));
+		} catch (FileNotFoundException e) {
+			// 如果文件不存在，打印异常堆栈信息并返回错误响应
+			e.printStackTrace();
+			return R.error("文件不存在");
+		} catch (IOException e) {
+			// 如果发生 I/O 异常，打印异常堆栈信息
+			e.printStackTrace();
+		}
+		// 返回成功响应，并将人脸比对结果数据放入响应结果中
+		return R.ok().put("data", com.alibaba.fastjson.JSONObject.parse(res.get("result").toString()));
+	}
+
+
+	 // 获取 table 表中的 column 列表(联动接口)
+	 // @param tableName 表名
+	// @param columnName 列名
+	 //@param level 层级信息，可选参数
+	 // @param parent 父级信息，可选参数
+	 // @return R 响应对象，包含操作结果和查询到的列值列表数据
+
+	@IgnoreAuth
+	@RequestMapping("/option/{tableName}/{columnName}")
+	public R getOption(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName, String level, String parent) {
+		// 创建参数 Map，用于存储表名和列名等信息
+		Map<String, Object> params = new HashMap<String, Object>();
+		params.put("table", tableName);
+		params.put("column", columnName);
+		// 如果层级信息不为空，则添加到参数中
+		if (StringUtils.isNotBlank(level)) {
+			params.put("level", level);
+		}
+		// 如果父级信息不为空，则添加到参数中
+		if (StringUtils.isNotBlank(parent)) {
+			params.put("parent", parent);
+		}
+		// 调用通用服务类的方法，获取列值列表
+		List<String> data = commonService.getOption(params);
+		// 返回成功响应，并将列值列表数据放入响应结果中
+		return R.ok().put("data", data);
+	}
+
+
+	 // 根据 table 中的 column 获取单条记录
+	 // @param tableName 表名
+	 // @param columnName 列名
+	 // @param columnValue 列值
+	 // @return R 响应对象，包含操作结果和查询到的单条记录数据
+
+	@IgnoreAuth
+	@RequestMapping("/follow/{tableName}/{columnName}")
+	public R getFollowByOption(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName, @RequestParam String columnValue) {
+		// 创建参数 Map，用于存储表名、列名和列值等信息
+		Map<String, Object> params = new HashMap<String, Object>();
+		params.put("table", tableName);
+		params.put("column", columnName);
+		params.put("columnValue", columnValue);
+		// 调用通用服务类的方法，获取单条记录
+		Map<String, Object> result = commonService.getFollowByOption(params);
+		// 返回成功响应，并将单条记录数据放入响应结果中
+		return R.ok().put("data", result);
+	}
+
+
+	 //修改 table 表的 sfsh 状态
+	// @param tableName 表名
+	 //@param map 包含修改信息的 Map 对象
+	// @return R 响应对象，包含操作结果
+
+	@RequestMapping("/sh/{tableName}")
+	public R sh(@PathVariable("tableName") String tableName, @RequestBody Map<String, Object> map) {
+		// 将表名添加到参数 Map 中
+		map.put("table", tableName);
+		// 调用通用服务类的方法，进行状态修改操作
+		commonService.sh(map);
+		// 返回成功响应
+		return R.ok();
+	}
+
+
+	 // 获取需要提醒的记录数
+	// @param tableName 表名
+	 // @param columnName 列名
+	// @param type 类型，1 表示数字，2 表示日期
+	// @param map 请求参数 Map，包含提醒相关信息
+	 //@return R 响应对象，包含操作结果和需要提醒的记录数
+
+	@IgnoreAuth
+	@RequestMapping("/remind/{tableName}/{columnName}/{type}")
+	public R remindCount(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName,
+						 @PathVariable("type") String type, @RequestParam Map<String, Object> map) {
+		// 将表名、列名和类型添加到参数 Map 中
+		map.put("table", tableName);
+		map.put("column", columnName);
+		map.put("type", type);
+
+		// 如果类型为日期（2），则进行日期相关的处理
+		if (type.equals("2")) {
+			// 创建日期格式化对象
+			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+			// 获取日历实例
+			Calendar c = Calendar.getInstance();
+			Date remindStartDate = null;
+			Date remindEndDate = null;
+			// 如果存在提醒开始时间参数，则进行计算和格式化
+			if (map.get("remindstart") != null) {
+				Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
+				c.setTime(new Date());
+				c.add(Calendar.DAY_OF_MONTH, remindStart);
+				remindStartDate = c.getTime();
+				map.put("remindstart", sdf.format(remindStartDate));
+			}
+			// 如果存在提醒结束时间参数，则进行计算和格式化
+			if (map.get("remindend") != null) {
+				Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
+				c.setTime(new Date());
+				c.add(Calendar.DAY_OF_MONTH, remindEnd);
+				remindEndDate = c.getTime();
+				map.put("remindend", sdf.format(remindEndDate));
+			}
+		}
+
+		// 调用通用服务类的方法，获取需要提醒的记录数
+		int count = commonService.remindCount(map);
+		// 返回成功响应，并将记录数放入响应结果中
+		return R.ok().put("count", count);
+	}
+
+
+	 // 单列求和
+	 //@param tableName 表名
+	 // @param columnName 列名
+	// @return R 响应对象，包含操作结果和求和结果数据
+
+	@IgnoreAuth
+	@RequestMapping("/cal/{tableName}/{columnName}")
+	public R cal(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName) {
+		// 创建参数 Map，用于存储表名和列名等信息
+		Map<String, Object> params = new HashMap<String, Object>();
+		params.put("table", tableName);
+		params.put("column", columnName);
+		// 调用通用服务类的方法，进行单列求和操作
+		Map<String, Object> result = commonService.selectCal(params);
+		// 返回成功响应，并将求和结果数据放入响应结果中
+		return R.ok().put("data", result);
+	}
+
+
+	 // 分组统计
+	 // @param tableName 表名
+	 // @param columnName 列名
+	 // @return R 响应对象，包含操作结果和分组统计结果数据
+
+	@IgnoreAuth
+	@RequestMapping("/group/{tableName}/{columnName}")
+	public R group(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName) {
+		// 创建参数 Map，用于存储表名和列名等信息
+		Map<String, Object> params = new HashMap<String, Object>();
+		params.put("table", tableName);
+		params.put("column", columnName);
+		// 调用通用服务类的方法，进行分组统计操作
+		List<Map<String, Object>> result = commonService.selectGroup(params);
+		// 创建日期格式化对象
+		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+		// 遍历统计结果，将日期类型的数据进行格式化
+		for (Map<String, Object> m : result) {
+			for (String k : m.keySet()) {
+				if (m.get(k) instanceof Date) {
+					m.put(k, sdf.format((Date) m.get(k)));
+				}
+			}
+		}
+		// 返回成功响应，并将分组统计结果数据放入响应结果中
+		return R.ok().put("data", result);
+	}
+
+
+	 // （按值统计）
+	 // @param tableName 表名
+	 // @param yColumnName y 列名
+	 // @param xColumnName x 列名
+	 //@return R 响应对象，包含操作结果和按值统计结果数据
+
+	@IgnoreAuth
+	@RequestMapping("/value/{tableName}/{xColumnName}/{yColumnName}")
+	public R value(@PathVariable("tableName") String tableName, @PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName) {
+		// 创建参数 Map，用于存储表名、x 列名和 y 列名等信息
+		Map<String, Object> params = new HashMap<String, Object>();
+		params.put("table", tableName);
+		params.put("xColumn", xColumnName);
+		params.put("yColumn", yColumnName);
+		// 调用通用服务类的方法，进行按值统计操作
+		List<Map<String, Object>> result = commonService.selectValue(params);
+		// 创建日期格式化对象
+		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+		// 遍历统计结果，将日期类型的数据进行格式化
+		for (Map<String, Object> m : result) {
+			for (String k : m.keySet()) {
+				if (m.get(k) instanceof Date) {
+					m.put(k, sdf.format((Date) m.get(k)));
+				}
+			}
+		}
+		// 返回成功响应，并将按值统计结果数据放入响应结果中
+		return R.ok().put("data", result);
+	}
+}

src/main/java/com/controller/ConfigController.java

@@ -0,0 +1,151 @@
+
+package com.controller;
+
+import java.util.Arrays;
+import java.util.Map;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import com.annotation.IgnoreAuth;
+import com.baomidou.mybatisplus.mapper.EntityWrapper;
+import com.entity.ConfigEntity;
+import com.service.ConfigService;
+import com.utils.PageUtils;
+import com.utils.R;
+import com.utils.ValidatorUtils;
+
+
+ // 登录相关
+ // 该控制器类主要处理与系统配置相关的业务逻辑，包括配置信息的查询、保存、修改和删除等操作。
+
+@RequestMapping("config")
+@RestController
+public class ConfigController {
+
+    // 自动注入配置服务类的实例，用于调用配置相关的业务逻辑方法
+    @Autowired
+    private ConfigService configService;
+
+
+     // 获取配置信息列表（支持分页）
+     // @param params 请求参数，包含分页、排序等信息
+    // @param config 配置实体，可用于构建查询条件（当前未实际使用）
+     // @return R 响应对象，包含操作结果和分页后的配置信息数据
+
+    @RequestMapping("/page")
+    public R page(@RequestParam Map<String, Object> params, ConfigEntity config) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件（当前未添加具体条件）
+        EntityWrapper<ConfigEntity> ew = new EntityWrapper<ConfigEntity>();
+        // 调用配置服务类的查询分页方法，传入请求参数
+        PageUtils page = configService.queryPage(params);
+        // 返回成功响应，并将分页后的配置信息数据放入响应结果中
+        return R.ok().put("data", page);
+    }
+
+
+     //获取配置信息列表（支持分页，无需身份验证）
+     //@param params 请求参数，包含分页、排序等信息
+     // @param config 配置实体，可用于构建查询条件（当前未实际使用）
+     // @return R 响应对象，包含操作结果和分页后的配置信息数据
+
+    @IgnoreAuth
+    @RequestMapping("/list")
+    public R list(@RequestParam Map<String, Object> params, ConfigEntity config) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件（当前未添加具体条件）
+        EntityWrapper<ConfigEntity> ew = new EntityWrapper<ConfigEntity>();
+        // 调用配置服务类的查询分页方法，传入请求参数
+        PageUtils page = configService.queryPage(params);
+        // 返回成功响应，并将分页后的配置信息数据放入响应结果中
+        return R.ok().put("data", page);
+    }
+
+
+     //根据 ID 获取配置信息详情
+     //@param id 配置信息的 ID
+    // @return R 响应对象，包含操作结果和指定 ID 的配置信息数据
+
+    @RequestMapping("/info/{id}")
+    public R info(@PathVariable("id") String id) {
+        // 根据 ID 查询配置实体
+        ConfigEntity config = configService.selectById(id);
+        // 返回成功响应，并将配置信息数据放入响应结果中
+        return R.ok().put("data", config);
+    }
+
+
+     // 根据 ID 获取配置信息详情（无需身份验证）
+     // @param id 配置信息的 ID
+     //@return R 响应对象，包含操作结果和指定 ID 的配置信息数据
+
+    @IgnoreAuth
+    @RequestMapping("/detail/{id}")
+    public R detail(@PathVariable("id") String id) {
+        // 根据 ID 查询配置实体
+        ConfigEntity config = configService.selectById(id);
+        // 返回成功响应，并将配置信息数据放入响应结果中
+        return R.ok().put("data", config);
+    }
+
+
+     //根据配置名称获取配置信息
+     // @param name 配置名称
+     // @return R 响应对象，包含操作结果和指定名称的配置信息数据
+
+    @RequestMapping("/info")
+    public R infoByName(@RequestParam String name) {
+        // 创建实体包装器，设置查询条件为配置名称等于指定名称
+        // 注意：此处代码写死了查询名称为 "faceFile"，与传入的 name 参数无关，可能存在逻辑错误
+        ConfigEntity config = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "faceFile"));
+        // 返回成功响应，并将配置信息数据放入响应结果中
+        return R.ok().put("data", config);
+    }
+
+
+    // 保存配置信息
+     // @param config 要保存的配置实体
+     // @return R 响应对象，包含操作结果
+
+    @PostMapping("/save")
+    public R save(@RequestBody ConfigEntity config) {
+        // 注释掉的验证实体方法，可用于验证配置实体数据的合法性
+        // ValidatorUtils.validateEntity(config);
+        // 调用配置服务类的插入方法，保存配置信息
+        configService.insert(config);
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 修改配置信息
+    // @param config 要修改的配置实体
+    // @return R 响应对象，包含操作结果
+
+    @RequestMapping("/update")
+    public R update(@RequestBody ConfigEntity config) {
+        // 注释掉的验证实体方法，可用于验证配置实体数据的合法性
+        // ValidatorUtils.validateEntity(config);
+        // 调用配置服务类的更新方法，根据 ID 更新配置信息（全部更新）
+        configService.updateById(config);
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 删除配置信息（批量删除）
+    // @param ids 要删除的配置信息的 ID 数组
+     //@return R 响应对象，包含操作结果
+
+    @RequestMapping("/delete")
+    public R delete(@RequestBody Long[] ids) {
+        // 调用配置服务类的批量删除方法，根据 ID 列表删除配置信息
+        configService.deleteBatchIds(Arrays.asList(ids));
+        // 返回成功响应
+        return R.ok();
+    }
+}

src/main/java/com/controller/FileController.java

@@ -0,0 +1,115 @@
+package com.controller;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Date;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.apache.commons.io.FileUtils;
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.multipart.MultipartFile;
+
+import com.annotation.IgnoreAuth;
+import com.baomidou.mybatisplus.mapper.EntityWrapper;
+import com.entity.ConfigEntity;
+import com.entity.EIException;
+import com.service.ConfigService;
+import com.utils.R;
+
+
+ // 上传文件映射表
+ // 该控制器类主要用于处理文件的上传和下载操作，提供了与文件相关的接口。
+
+@RestController
+@RequestMapping("file")
+@SuppressWarnings({"unchecked", "rawtypes"})
+public class FileController {
+	// 自动注入配置服务类的实例，用于操作配置相关数据
+	@Autowired
+	private ConfigService configService;
+
+
+	 // 上传文件
+	 // 该方法用于处理文件上传请求，将上传的文件保存到服务器指定目录，并根据条件更新配置信息。
+	 // @param file 上传的文件，通过 @RequestParam 注解绑定到 MultipartFile 对象
+	 // @param type 文件类型标识，用于判断是否需要更新配置信息
+	 // @param request HTTP 请求对象，用于获取服务器相关路径信息
+	 // @return R 响应对象，包含操作结果和上传后的文件名
+	 // @throws Exception 可能抛出的异常，如文件上传过程中的异常
+
+	@RequestMapping("/upload")
+	public R upload(@RequestParam("file") MultipartFile file, String type, HttpServletRequest request) throws Exception {
+		// 检查文件是否为空
+		if (file.isEmpty()) {
+			// 如果文件为空，抛出自定义异常
+			throw new EIException("上传文件不能为空");
+		}
+		// 获取文件扩展名
+		String fileExt = file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf(".") + 1);
+		// 生成新的文件名，由当前时间戳和文件扩展名组成
+		String fileName = new Date().getTime() + "." + fileExt;
+		// 创建目标文件对象，指定文件保存路径为服务器的 /upload 目录下
+		File dest = new File(request.getSession().getServletContext().getRealPath("/upload") + "/" + fileName);
+		// 将上传的文件保存到目标路径
+		file.transferTo(dest);
+		// 如果 type 不为空且等于 "1"，则进行配置信息的更新操作
+		if (StringUtils.isNotBlank(type) && type.equals("1")) {
+			// 根据配置名称 "faceFile" 查询配置实体
+			ConfigEntity configEntity = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "faceFile"));
+			// 如果配置实体不存在，则创建一个新的配置实体
+			if (configEntity == null) {
+				configEntity = new ConfigEntity();
+				configEntity.setName("faceFile");
+				configEntity.setValue(fileName);
+			} else {
+				// 如果配置实体存在，则更新其值为上传后的文件名
+				configEntity.setValue(fileName);
+			}
+			// 插入或更新配置实体
+			configService.insertOrUpdate(configEntity);
+		}
+		// 返回成功响应，并将上传后的文件名放入响应结果中
+		return R.ok().put("file", fileName);
+	}
+
+
+	// 下载文件
+	 // 该方法用于处理文件下载请求，将指定文件从服务器下载到客户端。
+	 // @param fileName 要下载的文件名，通过 @RequestParam 注解获取
+	 // @param request HTTP 请求对象，用于获取服务器相关路径信息
+	 // @param response HTTP 响应对象，用于设置响应头和输出文件内容
+
+	@IgnoreAuth
+	@RequestMapping("/download")
+	public void download(@RequestParam String fileName, HttpServletRequest request, HttpServletResponse response) {
+		try {
+			// 创建要下载的文件对象，指定文件路径为服务器的 /upload 目录下
+			File file = new File(request.getSession().getServletContext().getRealPath("/upload") + "/" + fileName);
+			// 检查文件是否存在
+			if (file.exists()) {
+				// 重置响应
+				response.reset();
+				// 设置响应头，指定文件为附件并设置文件名
+				response.setHeader("Content-Disposition", "attachment; filename=\"" + fileName + "\"");
+				// 设置缓存控制，不缓存文件
+				response.setHeader("Cache-Control", "no-cache");
+				// 设置允许跨域携带凭证
+				response.setHeader("Access-Control-Allow-Credentials", "true");
+				// 设置响应内容类型为二进制流
+				response.setContentType("application/octet-stream; charset=UTF-8");
+				// 将文件内容写入响应输出流，实现文件下载
+				IOUtils.write(FileUtils.readFileToByteArray(file), response.getOutputStream());
+			}
+		} catch (IOException e) {
+			// 如果发生 I/O 异常，打印异常堆栈信息
+			e.printStackTrace();
+		}
+	}
+}

src/main/java/com/controller/JizhangpingzhengController.java

@@ -0,0 +1,298 @@
+package com.controller;
+
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Date;
+import java.util.List;
+import javax.servlet.http.HttpServletRequest;
+
+import com.utils.ValidatorUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.format.annotation.DateTimeFormat;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import com.baomidou.mybatisplus.mapper.EntityWrapper;
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.annotation.IgnoreAuth;
+
+import com.entity.JizhangpingzhengEntity;
+import com.entity.view.JizhangpingzhengView;
+
+import com.service.JizhangpingzhengService;
+import com.service.TokenService;
+import com.utils.PageUtils;
+import com.utils.R;
+import com.utils.MD5Util;
+import com.utils.MPUtil;
+import com.utils.CommonUtil;
+
+
+ // 记账凭证
+ // 后端接口
+ // @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+@RestController
+@RequestMapping("/jizhangpingzheng")
+public class JizhangpingzhengController {
+    // 自动注入记账凭证服务类的实例，用于处理记账凭证相关业务逻辑
+    @Autowired
+    private JizhangpingzhengService jizhangpingzhengService;
+
+
+     // 后端列表
+     // 该方法用于获取记账凭证的分页列表（后端使用），支持根据记账凭证实体和时间范围构建查询条件
+     // @param params 请求参数，包含分页、排序等信息
+     // @param jizhangpingzheng 记账凭证实体，用于构建查询条件
+     // @param dengjiriqistart 登记日期开始时间，可选参数
+     // @param dengjiriqiend 登记日期结束时间，可选参数
+     // @param request HTTP 请求对象
+     // @return R 响应对象，包含操作结果和分页后的记账凭证数据
+
+    @RequestMapping("/page")
+    public R page(@RequestParam Map<String, Object> params, JizhangpingzhengEntity jizhangpingzheng,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date dengjiriqistart,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date dengjiriqiend,
+                  HttpServletRequest request) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<JizhangpingzhengEntity> ew = new EntityWrapper<JizhangpingzhengEntity>();
+        // 如果登记日期开始时间不为空，添加大于等于该时间的查询条件
+        if (dengjiriqistart != null)
+            ew.ge("dengjiriqi", dengjiriqistart);
+        // 如果登记日期结束时间不为空，添加小于等于该时间的查询条件
+        if (dengjiriqiend != null)
+            ew.le("dengjiriqi", dengjiriqiend);
+        // 调用记账凭证服务类的 queryPage 方法进行分页查询，MPUtil 用于处理排序和条件查询
+        PageUtils page = jizhangpingzhengService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, jizhangpingzheng), params), params));
+        // 返回成功响应，并将分页数据放入响应结果中
+        return R.ok().put("data", page);
+    }
+
+
+   // 前端列表
+     // 该方法用于获取记账凭证的分页列表（前端使用），支持根据记账凭证实体和时间范围构建查询条件
+     // @param params 请求参数，包含分页、排序等信息
+     // @param jizhangpingzheng 记账凭证实体，用于构建查询条件
+    // @param dengjiriqistart 登记日期开始时间，可选参数
+     // @param dengjiriqiend 登记日期结束时间，可选参数
+     // @param request HTTP 请求对象
+     // @return R 响应对象，包含操作结果和分页后的记账凭证数据
+
+    @RequestMapping("/list")
+    public R list(@RequestParam Map<String, Object> params, JizhangpingzhengEntity jizhangpingzheng,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date dengjiriqistart,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date dengjiriqiend,
+                  HttpServletRequest request) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<JizhangpingzhengEntity> ew = new EntityWrapper<JizhangpingzhengEntity>();
+        // 如果登记日期开始时间不为空，添加大于等于该时间的查询条件
+        if (dengjiriqistart != null)
+            ew.ge("dengjiriqi", dengjiriqistart);
+        // 如果登记日期结束时间不为空，添加小于等于该时间的查询条件
+        if (dengjiriqiend != null)
+            ew.le("dengjiriqi", dengjiriqiend);
+        // 调用记账凭证服务类的 queryPage 方法进行分页查询，MPUtil 用于处理排序和条件查询
+        PageUtils page = jizhangpingzhengService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, jizhangpingzheng), params), params));
+        // 返回成功响应，并将分页数据放入响应结果中
+        return R.ok().put("data", page);
+    }
+
+
+     // 列表
+    // 该方法用于获取满足特定条件的记账凭证列表
+     // @param jizhangpingzheng 记账凭证实体，用于构建查询条件
+    // @return R 响应对象，包含操作结果和查询到的记账凭证列表数据
+
+    @RequestMapping("/lists")
+    public R list(JizhangpingzhengEntity jizhangpingzheng) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<JizhangpingzhengEntity> ew = new EntityWrapper<JizhangpingzhengEntity>();
+        // 设置查询条件，使所有字段相等
+        ew.allEq(MPUtil.allEQMapPre(jizhangpingzheng, "jizhangpingzheng"));
+        // 调用记账凭证服务类的 selectListView 方法获取列表数据
+        return R.ok().put("data", jizhangpingzhengService.selectListView(ew));
+    }
+
+
+     // 查询
+    // 该方法用于根据记账凭证实体的条件查询单个记账凭证视图
+     // @param jizhangpingzheng 记账凭证实体，用于构建查询条件
+     // @return R 响应对象，包含操作结果和查询到的记账凭证视图数据
+
+    @RequestMapping("/query")
+    public R query(JizhangpingzhengEntity jizhangpingzheng) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<JizhangpingzhengEntity> ew = new EntityWrapper<JizhangpingzhengEntity>();
+        // 设置查询条件，使所有字段相等
+        ew.allEq(MPUtil.allEQMapPre(jizhangpingzheng, "jizhangpingzheng"));
+        // 调用记账凭证服务类的 selectView 方法获取记账凭证视图
+        JizhangpingzhengView jizhangpingzhengView = jizhangpingzhengService.selectView(ew);
+        // 返回成功响应，并将查询结果放入响应结果中
+        return R.ok("查询记账凭证成功").put("data", jizhangpingzhengView);
+    }
+
+
+     // 后端详情
+     // 该方法用于获取指定 ID 的记账凭证详情（后端使用）
+     // @param id 记账凭证的 ID
+    // @return R 响应对象，包含操作结果和指定 ID 的记账凭证数据
+
+    @RequestMapping("/info/{id}")
+    public R info(@PathVariable("id") Long id) {
+        // 根据 ID 调用记账凭证服务类的 selectById 方法获取记账凭证实体
+        JizhangpingzhengEntity jizhangpingzheng = jizhangpingzhengService.selectById(id);
+        // 返回成功响应，并将记账凭证实体放入响应结果中
+        return R.ok().put("data", jizhangpingzheng);
+    }
+
+
+     // 前端详情
+     // 该方法用于获取指定 ID 的记账凭证详情（前端使用）
+     // @param id 记账凭证的 ID
+     // @return R 响应对象，包含操作结果和指定 ID 的记账凭证数据
+
+    @RequestMapping("/detail/{id}")
+    public R detail(@PathVariable("id") Long id) {
+        // 根据 ID 调用记账凭证服务类的 selectById 方法获取记账凭证实体
+        JizhangpingzhengEntity jizhangpingzheng = jizhangpingzhengService.selectById(id);
+        // 返回成功响应，并将记账凭证实体放入响应结果中
+        return R.ok().put("data", jizhangpingzheng);
+    }
+
+
+     // 后端保存
+     // 该方法用于在后端保存新的记账凭证
+     // @param jizhangpingzheng 要保存的记账凭证实体
+     // @param request HTTP 请求对象
+     // @return R 响应对象，包含操作结果
+
+    @RequestMapping("/save")
+    public R save(@RequestBody JizhangpingzhengEntity jizhangpingzheng, HttpServletRequest request) {
+        // 为记账凭证实体设置一个唯一的 ID，由当前时间戳和随机数组成
+        jizhangpingzheng.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(jizhangpingzheng);
+        // 调用记账凭证服务类的 insert 方法保存记账凭证
+        jizhangpingzhengService.insert(jizhangpingzheng);
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 前端保存
+     // 该方法用于在前端保存新的记账凭证
+     // @param jizhangpingzheng 要保存的记账凭证实体
+     // @param request HTTP 请求对象
+     // @return R 响应对象，包含操作结果
+
+    @RequestMapping("/add")
+    public R add(@RequestBody JizhangpingzhengEntity jizhangpingzheng, HttpServletRequest request) {
+        // 为记账凭证实体设置一个唯一的 ID，由当前时间戳和随机数组成
+        jizhangpingzheng.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(jizhangpingzheng);
+        // 调用记账凭证服务类的 insert 方法保存记账凭证
+        jizhangpingzhengService.insert(jizhangpingzheng);
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     //修改
+     // 该方法用于修改已有的记账凭证
+     // @param jizhangpingzheng 要修改的记账凭证实体
+    //@param request HTTP 请求对象
+     // @return R 响应对象，包含操作结果
+
+    @RequestMapping("/update")
+    public R update(@RequestBody JizhangpingzhengEntity jizhangpingzheng, HttpServletRequest request) {
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(jizhangpingzheng);
+        // 调用记账凭证服务类的 updateById 方法根据 ID 更新记账凭证
+        jizhangpingzhengService.updateById(jizhangpingzheng); // 全部更新
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 删除
+     // 该方法用于批量删除指定 ID 的记账凭证
+     // @param ids 要删除的记账凭证的 ID 数组
+     // @return R 响应对象，包含操作结果
+
+    @RequestMapping("/delete")
+    public R delete(@RequestBody Long[] ids) {
+        // 调用记账凭证服务类的 deleteBatchIds 方法批量删除记账凭证
+        jizhangpingzhengService.deleteBatchIds(Arrays.asList(ids));
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 提醒接口
+    // 该方法用于根据指定列和时间范围统计满足条件的记账凭证数量
+    // @param columnName 要统计的列名
+    // @param request HTTP 请求对象
+    // @param type 类型，1 表示数字，2 表示日期
+    // @param map 请求参数，包含提醒开始时间和结束时间等信息
+     // @return R 响应对象，包含操作结果和统计的数量
+
+    @RequestMapping("/remind/{columnName}/{type}")
+    public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
+                         @PathVariable("type") String type, @RequestParam Map<String, Object> map) {
+        // 将列名、类型等信息放入请求参数中
+        map.put("column", columnName);
+        map.put("type", type);
+
+        // 如果类型为日期（2），则进行日期相关的处理
+        if (type.equals("2")) {
+            // 创建日期格式化对象
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+            // 获取日历实例
+            Calendar c = Calendar.getInstance();
+            Date remindStartDate = null;
+            Date remindEndDate = null;
+            // 如果存在提醒开始时间参数，则进行计算和格式化
+            if (map.get("remindstart") != null) {
+                Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
+                c.setTime(new Date());
+                c.add(Calendar.DAY_OF_MONTH, remindStart);
+                remindStartDate = c.getTime();
+                map.put("remindstart", sdf.format(remindStartDate));
+            }
+            // 如果存在提醒结束时间参数，则进行计算和格式化
+            if (map.get("remindend") != null) {
+                Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
+                c.setTime(new Date());
+                c.add(Calendar.DAY_OF_MONTH, remindEnd);
+                remindEndDate = c.getTime();
+                map.put("remindend", sdf.format(remindEndDate));
+            }
+        }
+
+        // 创建一个包装器，用于构建 SQL 查询条件
+        Wrapper<JizhangpingzhengEntity> wrapper = new EntityWrapper<JizhangpingzhengEntity>();
+        // 根据提醒开始时间和结束时间设置查询条件
+        if (map.get("remindstart") != null) {
+            wrapper.ge(columnName, map.get("remindstart"));
+        }
+        if (map.get("remindend") != null) {
+            wrapper.le(columnName, map.get("remindend"));
+        }
+
+        // 调用记账凭证服务类的 selectCount 方法统计满足条件的数量
+        int count = jizhangpingzhengService.selectCount(wrapper);
+        // 返回成功响应，并将统计数量放入响应结果中
+        return R.ok().put("count", count);
+    }
+}

src/main/java/com/controller/RijizhangController.java

@@ -0,0 +1,313 @@
+package com.controller;
+
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Date;
+import java.util.List;
+import javax.servlet.http.HttpServletRequest;
+
+import com.utils.ValidatorUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.format.annotation.DateTimeFormat;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import com.baomidou.mybatisplus.mapper.EntityWrapper;
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.annotation.IgnoreAuth;
+
+import com.entity.RijizhangEntity;
+import com.entity.view.RijizhangView;
+
+import com.service.RijizhangService;
+import com.service.TokenService;
+import com.utils.PageUtils;
+import com.utils.R;
+import com.utils.MD5Util;
+import com.utils.MPUtil;
+import com.utils.CommonUtil;
+
+
+ // 日记账
+ // 后端接口
+ // @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+@RestController
+@RequestMapping("/rijizhang")
+public class RijizhangController {
+    // 自动注入日记账服务类的实例，用于处理日记账相关业务逻辑
+    @Autowired
+    private RijizhangService rijizhangService;
+
+
+     // 后端列表
+     // 该方法用于获取日记账的分页列表（后端使用），支持根据日记账实体和日期范围构建查询条件，
+     // 并且根据会话中的 tableName 和 username 信息添加额外的查询条件
+    // @param params 请求参数，包含分页、排序等信息
+     // @param rijizhang 日记账实体，用于构建查询条件
+    // @param riqistart 日期开始时间，可选参数，格式为 yyyy-MM-dd
+    // @param riqiend 日期结束时间，可选参数，格式为 yyyy-MM-dd
+    //@param request HTTP 请求对象
+    // @return R 响应对象，包含操作结果和分页后的日记账数据
+
+    @RequestMapping("/page")
+    public R page(@RequestParam Map<String, Object> params, RijizhangEntity rijizhang,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date riqistart,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date riqiend,
+                  HttpServletRequest request) {
+        // 从会话中获取 tableName
+        String tableName = request.getSession().getAttribute("tableName").toString();
+        // 如果 tableName 是 "yuangongguanli"，则设置日记账实体的管理工号为会话中的 username
+        if (tableName.equals("yuangongguanli")) {
+            rijizhang.setGuanligonghao((String) request.getSession().getAttribute("username"));
+        }
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<RijizhangEntity> ew = new EntityWrapper<RijizhangEntity>();
+        // 如果日期开始时间不为空，添加大于等于该时间的查询条件
+        if (riqistart != null)
+            ew.ge("riqi", riqistart);
+        // 如果日期结束时间不为空，添加小于等于该时间的查询条件
+        if (riqiend != null)
+            ew.le("riqi", riqiend);
+        // 调用日记账服务类的 queryPage 方法进行分页查询，MPUtil 用于处理排序和条件查询
+        PageUtils page = rijizhangService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, rijizhang), params), params));
+        // 返回成功响应，并将分页数据放入响应结果中
+        return R.ok().put("data", page);
+    }
+
+
+     // 前端列表
+     // 该方法用于获取日记账的分页列表（前端使用），支持根据日记账实体和日期范围构建查询条件
+     // @param params 请求参数，包含分页、排序等信息
+    // @param rijizhang 日记账实体，用于构建查询条件
+    // @param riqistart 日期开始时间，可选参数，格式为 yyyy-MM-dd
+     // @param riqiend 日期结束时间，可选参数，格式为 yyyy-MM-dd
+     // @param request HTTP 请求对象
+    // @return R 响应对象，包含操作结果和分页后的日记账数据
+
+    @RequestMapping("/list")
+    public R list(@RequestParam Map<String, Object> params, RijizhangEntity rijizhang,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date riqistart,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date riqiend,
+                  HttpServletRequest request) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<RijizhangEntity> ew = new EntityWrapper<RijizhangEntity>();
+        // 如果日期开始时间不为空，添加大于等于该时间的查询条件
+        if (riqistart != null)
+            ew.ge("riqi", riqistart);
+        // 如果日期结束时间不为空，添加小于等于该时间的查询条件
+        if (riqiend != null)
+            ew.le("riqi", riqiend);
+        // 调用日记账服务类的 queryPage 方法进行分页查询，MPUtil 用于处理排序和条件查询
+        PageUtils page = rijizhangService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, rijizhang), params), params));
+        // 返回成功响应，并将分页数据放入响应结果中
+        return R.ok().put("data", page);
+    }
+
+
+     // 列表
+     // 该方法用于获取满足特定条件的日记账列表
+    // @param rijizhang 日记账实体，用于构建查询条件
+    // @return R 响应对象，包含操作结果和查询到的日记账列表数据
+
+    @RequestMapping("/lists")
+    public R list(RijizhangEntity rijizhang) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<RijizhangEntity> ew = new EntityWrapper<RijizhangEntity>();
+        // 设置查询条件，使所有字段相等
+        ew.allEq(MPUtil.allEQMapPre(rijizhang, "rijizhang"));
+        // 调用日记账服务类的 selectListView 方法获取列表数据
+        return R.ok().put("data", rijizhangService.selectListView(ew));
+    }
+
+
+     // 查询
+     // 该方法用于根据日记账实体的条件查询单个日记账视图
+     //@param rijizhang 日记账实体，用于构建查询条件
+    // @return R 响应对象，包含操作结果和查询到的日记账视图数据
+
+    @RequestMapping("/query")
+    public R query(RijizhangEntity rijizhang) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<RijizhangEntity> ew = new EntityWrapper<RijizhangEntity>();
+        // 设置查询条件，使所有字段相等
+        ew.allEq(MPUtil.allEQMapPre(rijizhang, "rijizhang"));
+        // 调用日记账服务类的 selectView 方法获取日记账视图
+        RijizhangView rijizhangView = rijizhangService.selectView(ew);
+        // 返回成功响应，并将查询结果放入响应结果中
+        return R.ok("查询日记账成功").put("data", rijizhangView);
+    }
+
+
+     // 后端详情
+     // 该方法用于获取指定 ID 的日记账详情（后端使用）
+     // @param id 日记账的 ID
+     // @return R 响应对象，包含操作结果和指定 ID 的日记账数据
+
+    @RequestMapping("/info/{id}")
+    public R info(@PathVariable("id") Long id) {
+        // 根据 ID 调用日记账服务类的 selectById 方法获取日记账实体
+        RijizhangEntity rijizhang = rijizhangService.selectById(id);
+        // 返回成功响应，并将日记账实体放入响应结果中
+        return R.ok().put("data", rijizhang);
+    }
+
+
+    // 前端详情
+     // 该方法用于获取指定 ID 的日记账详情（前端使用）
+     //@param id 日记账的 ID
+     // @return R 响应对象，包含操作结果和指定 ID 的日记账数据
+
+    @RequestMapping("/detail/{id}")
+    public R detail(@PathVariable("id") Long id) {
+        // 根据 ID 调用日记账服务类的 selectById 方法获取日记账实体
+        RijizhangEntity rijizhang = rijizhangService.selectById(id);
+        // 返回成功响应，并将日记账实体放入响应结果中
+        return R.ok().put("data", rijizhang);
+    }
+
+
+     // 后端保存
+     // 该方法用于在后端保存新的日记账
+     // @param rijizhang 要保存的日记账实体
+     // @param request HTTP 请求对象
+     // @return R 响应对象，包含操作结果
+
+    @RequestMapping("/save")
+    public R save(@RequestBody RijizhangEntity rijizhang, HttpServletRequest request) {
+        // 为日记账实体设置一个唯一的 ID，由当前时间戳和随机数组成
+        rijizhang.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(rijizhang);
+        // 调用日记账服务类的 insert 方法保存日记账
+        rijizhangService.insert(rijizhang);
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 前端保存
+     // 该方法用于在前端保存新的日记账
+    // @param rijizhang 要保存的日记账实体
+     // @param request HTTP 请求对象
+     // @return R 响应对象，包含操作结果
+
+    @RequestMapping("/add")
+    public R add(@RequestBody RijizhangEntity rijizhang, HttpServletRequest request) {
+        // 为日记账实体设置一个唯一的 ID，由当前时间戳和随机数组成
+        rijizhang.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(rijizhang);
+        // 调用日记账服务类的 insert 方法保存日记账
+        rijizhangService.insert(rijizhang);
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 修改
+     // 该方法用于修改已有的日记账
+     // @param rijizhang 要修改的日记账实体
+     // @param request HTTP 请求对象
+     //@return R 响应对象，包含操作结果
+
+    @RequestMapping("/update")
+    public R update(@RequestBody RijizhangEntity rijizhang, HttpServletRequest request) {
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(rijizhang);
+        // 调用日记账服务类的 updateById 方法根据 ID 更新日记账
+        rijizhangService.updateById(rijizhang); // 全部更新
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 删除
+    // 该方法用于批量删除指定 ID 的日记账
+     //@param ids 要删除的日记账的 ID 数组
+    // @return R 响应对象，包含操作结果
+
+    @RequestMapping("/delete")
+    public R delete(@RequestBody Long[] ids) {
+        // 调用日记账服务类的 deleteBatchIds 方法批量删除日记账
+        rijizhangService.deleteBatchIds(Arrays.asList(ids));
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 提醒接口
+     // 该方法用于根据指定列和时间范围统计满足条件的日记账数量，
+     // 并且根据会话中的 tableName 和 username 信息添加额外的查询条件
+     // @param columnName 要统计的列名
+    // @param request HTTP 请求对象
+    // @param type 类型，1 表示数字，2 表示日期
+     // @param map 请求参数，包含提醒开始时间和结束时间等信息
+     // @return R 响应对象，包含操作结果和统计的数量
+ 
+    @RequestMapping("/remind/{columnName}/{type}")
+    public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
+                         @PathVariable("type") String type, @RequestParam Map<String, Object> map) {
+        // 将列名、类型等信息放入请求参数中
+        map.put("column", columnName);
+        map.put("type", type);
+
+        // 如果类型为日期（2），则进行日期相关的处理
+        if (type.equals("2")) {
+            // 创建日期格式化对象
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+            // 获取日历实例
+            Calendar c = Calendar.getInstance();
+            Date remindStartDate = null;
+            Date remindEndDate = null;
+            // 如果存在提醒开始时间参数，则进行计算和格式化
+            if (map.get("remindstart") != null) {
+                Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
+                c.setTime(new Date());
+                c.add(Calendar.DAY_OF_MONTH, remindStart);
+                remindStartDate = c.getTime();
+                map.put("remindstart", sdf.format(remindStartDate));
+            }
+            // 如果存在提醒结束时间参数，则进行计算和格式化
+            if (map.get("remindend") != null) {
+                Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
+                c.setTime(new Date());
+                c.add(Calendar.DAY_OF_MONTH, remindEnd);
+                remindEndDate = c.getTime();
+                map.put("remindend", sdf.format(remindEndDate));
+            }
+        }
+
+        // 创建一个包装器，用于构建 SQL 查询条件
+        Wrapper<RijizhangEntity> wrapper = new EntityWrapper<RijizhangEntity>();
+        // 根据提醒开始时间和结束时间设置查询条件
+        if (map.get("remindstart") != null) {
+            wrapper.ge(columnName, map.get("remindstart"));
+        }
+        if (map.get("remindend") != null) {
+            wrapper.le(columnName, map.get("remindend"));
+        }
+
+        // 从会话中获取 tableName
+        String tableName = request.getSession().getAttribute("tableName").toString();
+        // 如果 tableName 是 "yuangongguanli"，则添加管理工号等于会话中 username 的查询条件
+        if (tableName.equals("yuangongguanli")) {
+            wrapper.eq("guanligonghao", (String) request.getSession().getAttribute("username"));
+        }
+
+        // 调用日记账服务类的 selectCount 方法统计满足条件的数量
+        int count = rijizhangService.selectCount(wrapper);
+        // 返回成功响应，并将统计数量放入响应结果中
+        return R.ok().put("count", count);
+    }
+}

src/main/java/com/controller/ShangpinchukuController.java

@@ -0,0 +1,313 @@
+package com.controller;
+
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Date;
+import java.util.List;
+import javax.servlet.http.HttpServletRequest;
+
+import com.utils.ValidatorUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.format.annotation.DateTimeFormat;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import com.baomidou.mybatisplus.mapper.EntityWrapper;
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.annotation.IgnoreAuth;
+
+import com.entity.ShangpinchukuEntity;
+import com.entity.view.ShangpinchukuView;
+
+import com.service.ShangpinchukuService;
+import com.service.TokenService;
+import com.utils.PageUtils;
+import com.utils.R;
+import com.utils.MD5Util;
+import com.utils.MPUtil;
+import com.utils.CommonUtil;
+
+
+// 商品出库
+ //后端接口
+ // @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+@RestController
+@RequestMapping("/shangpinchuku")
+public class ShangpinchukuController {
+    // 自动注入商品出库服务类的实例，用于处理商品出库相关业务逻辑
+    @Autowired
+    private ShangpinchukuService shangpinchukuService;
+
+
+     //后端列表
+     // 该方法用于获取商品出库信息的分页列表（后端使用），支持根据商品出库实体和出库时间范围构建查询条件，
+     // 并且根据会话中的 tableName 和 username 信息添加额外的查询条件
+     // @param params 请求参数，包含分页、排序等信息
+     // @param shangpinchuku 商品出库实体，用于构建查询条件
+     // @param chukushijianstart 出库时间开始时间，可选参数，格式为 yyyy-MM-dd HH:mm:ss
+     // @param chukushijianend 出库时间结束时间，可选参数，格式为 yyyy-MM-dd HH:mm:ss
+     // @param request HTTP 请求对象
+     // @return R 响应对象，包含操作结果和分页后的商品出库数据
+
+    @RequestMapping("/page")
+    public R page(@RequestParam Map<String, Object> params, ShangpinchukuEntity shangpinchuku,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date chukushijianstart,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date chukushijianend,
+                  HttpServletRequest request) {
+        // 从会话中获取 tableName
+        String tableName = request.getSession().getAttribute("tableName").toString();
+        // 如果 tableName 是 "yuangong"，则设置商品出库实体的员工工号为会话中的 username
+        if (tableName.equals("yuangong")) {
+            shangpinchuku.setYuangonggonghao((String) request.getSession().getAttribute("username"));
+        }
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<ShangpinchukuEntity> ew = new EntityWrapper<ShangpinchukuEntity>();
+        // 如果出库时间开始时间不为空，添加大于等于该时间的查询条件
+        if (chukushijianstart != null)
+            ew.ge("chukushijian", chukushijianstart);
+        // 如果出库时间结束时间不为空，添加小于等于该时间的查询条件
+        if (chukushijianend != null)
+            ew.le("chukushijian", chukushijianend);
+        // 调用商品出库服务类的 queryPage 方法进行分页查询，MPUtil 用于处理排序和条件查询
+        PageUtils page = shangpinchukuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, shangpinchuku), params), params));
+        // 返回成功响应，并将分页数据放入响应结果中
+        return R.ok().put("data", page);
+    }
+
+
+     // 前端列表
+     // 该方法用于获取商品出库信息的分页列表（前端使用），支持根据商品出库实体和出库时间范围构建查询条件
+     // @param params 请求参数，包含分页、排序等信息
+     // @param shangpinchuku 商品出库实体，用于构建查询条件
+     // @param chukushijianstart 出库时间开始时间，可选参数，格式为 yyyy-MM-dd HH:mm:ss
+     // @param chukushijianend 出库时间结束时间，可选参数，格式为 yyyy-MM-dd HH:mm:ss
+     //@param request HTTP 请求对象
+     // @return R 响应对象，包含操作结果和分页后的商品出库数据
+
+    @RequestMapping("/list")
+    public R list(@RequestParam Map<String, Object> params, ShangpinchukuEntity shangpinchuku,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date chukushijianstart,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date chukushijianend,
+                  HttpServletRequest request) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<ShangpinchukuEntity> ew = new EntityWrapper<ShangpinchukuEntity>();
+        // 如果出库时间开始时间不为空，添加大于等于该时间的查询条件
+        if (chukushijianstart != null)
+            ew.ge("chukushijian", chukushijianstart);
+        // 如果出库时间结束时间不为空，添加小于等于该时间的查询条件
+        if (chukushijianend != null)
+            ew.le("chukushijian", chukushijianend);
+        // 调用商品出库服务类的 queryPage 方法进行分页查询，MPUtil 用于处理排序和条件查询
+        PageUtils page = shangpinchukuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, shangpinchuku), params), params));
+        // 返回成功响应，并将分页数据放入响应结果中
+        return R.ok().put("data", page);
+    }
+
+
+     // 列表
+     // 该方法用于获取满足特定条件的商品出库信息列表
+     // @param shangpinchuku 商品出库实体，用于构建查询条件
+     // @return R 响应对象，包含操作结果和查询到的商品出库信息列表数据
+
+    @RequestMapping("/lists")
+    public R list(ShangpinchukuEntity shangpinchuku) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<ShangpinchukuEntity> ew = new EntityWrapper<ShangpinchukuEntity>();
+        // 设置查询条件，使所有字段相等
+        ew.allEq(MPUtil.allEQMapPre(shangpinchuku, "shangpinchuku"));
+        // 调用商品出库服务类的 selectListView 方法获取列表数据
+        return R.ok().put("data", shangpinchukuService.selectListView(ew));
+    }
+
+
+     //查询
+     // 该方法用于根据商品出库实体的条件查询单个商品出库视图
+     // @param shangpinchuku 商品出库实体，用于构建查询条件
+     // @return R 响应对象，包含操作结果和查询到的商品出库视图数据
+
+    @RequestMapping("/query")
+    public R query(ShangpinchukuEntity shangpinchuku) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<ShangpinchukuEntity> ew = new EntityWrapper<ShangpinchukuEntity>();
+        // 设置查询条件，使所有字段相等
+        ew.allEq(MPUtil.allEQMapPre(shangpinchuku, "shangpinchuku"));
+        // 调用商品出库服务类的 selectView 方法获取商品出库视图
+        ShangpinchukuView shangpinchukuView = shangpinchukuService.selectView(ew);
+        // 返回成功响应，并将查询结果放入响应结果中
+        return R.ok("查询商品出库成功").put("data", shangpinchukuView);
+    }
+
+
+     // 后端详情
+     // 该方法用于获取指定 ID 的商品出库详情（后端使用）
+     // @param id 商品出库记录的 ID
+     // @return R 响应对象，包含操作结果和指定 ID 的商品出库数据
+
+    @RequestMapping("/info/{id}")
+    public R info(@PathVariable("id") Long id) {
+        // 根据 ID 调用商品出库服务类的 selectById 方法获取商品出库实体
+        ShangpinchukuEntity shangpinchuku = shangpinchukuService.selectById(id);
+        // 返回成功响应，并将商品出库实体放入响应结果中
+        return R.ok().put("data", shangpinchuku);
+    }
+
+
+    // 前端详情
+     //该方法用于获取指定 ID 的商品出库详情（前端使用）
+     // @param id 商品出库记录的 ID
+     //@return R 响应对象，包含操作结果和指定 ID 的商品出库数据
+
+    @RequestMapping("/detail/{id}")
+    public R detail(@PathVariable("id") Long id) {
+        // 根据 ID 调用商品出库服务类的 selectById 方法获取商品出库实体
+        ShangpinchukuEntity shangpinchuku = shangpinchukuService.selectById(id);
+        // 返回成功响应，并将商品出库实体放入响应结果中
+        return R.ok().put("data", shangpinchuku);
+    }
+
+
+     //后端保存
+     // 该方法用于在后端保存新的商品出库记录
+     // @param shangpinchuku 要保存的商品出库实体
+     // @param request HTTP 请求对象
+     //@return R 响应对象，包含操作结果
+
+    @RequestMapping("/save")
+    public R save(@RequestBody ShangpinchukuEntity shangpinchuku, HttpServletRequest request) {
+        // 为商品出库实体设置一个唯一的 ID，由当前时间戳和随机数组成
+        shangpinchuku.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(shangpinchuku);
+        // 调用商品出库服务类的 insert 方法保存商品出库记录
+        shangpinchukuService.insert(shangpinchuku);
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 前端保存
+     // 该方法用于在前端保存新的商品出库记录
+     // @param shangpinchuku 要保存的商品出库实体
+     // @param request HTTP 请求对象
+     //@return R 响应对象，包含操作结果
+
+    @RequestMapping("/add")
+    public R add(@RequestBody ShangpinchukuEntity shangpinchuku, HttpServletRequest request) {
+        // 为商品出库实体设置一个唯一的 ID，由当前时间戳和随机数组成
+        shangpinchuku.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(shangpinchuku);
+        // 调用商品出库服务类的 insert 方法保存商品出库记录
+        shangpinchukuService.insert(shangpinchuku);
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 修改
+    //该方法用于修改已有的商品出库记录
+     // @param shangpinchuku 要修改的商品出库实体
+     // @param request HTTP 请求对象
+     // @return R 响应对象，包含操作结果
+
+    @RequestMapping("/update")
+    public R update(@RequestBody ShangpinchukuEntity shangpinchuku, HttpServletRequest request) {
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(shangpinchuku);
+        // 调用商品出库服务类的 updateById 方法根据 ID 更新商品出库记录
+        shangpinchukuService.updateById(shangpinchuku); // 全部更新
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 删除
+     //该方法用于批量删除指定 ID 的商品出库记录
+     // @param ids 要删除的商品出库记录的 ID 数组
+     // @return R 响应对象，包含操作结果
+
+    @RequestMapping("/delete")
+    public R delete(@RequestBody Long[] ids) {
+        // 调用商品出库服务类的 deleteBatchIds 方法批量删除商品出库记录
+        shangpinchukuService.deleteBatchIds(Arrays.asList(ids));
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     //提醒接口
+     //该方法用于根据指定列和时间范围统计满足条件的商品出库记录数量，
+     // 并且根据会话中的 tableName 和 username 信息添加额外的查询条件
+     // @param columnName 要统计的列名
+     //@param request HTTP 请求对象
+     //@param type 类型，1 表示数字，2 表示日期
+     //@param map 请求参数，包含提醒开始时间和结束时间等信息
+     // @return R 响应对象，包含操作结果和统计的数量
+
+    @RequestMapping("/remind/{columnName}/{type}")
+    public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
+                         @PathVariable("type") String type, @RequestParam Map<String, Object> map) {
+        // 将列名、类型等信息放入请求参数中
+        map.put("column", columnName);
+        map.put("type", type);
+
+        // 如果类型为日期（2），则进行日期相关的处理
+        if (type.equals("2")) {
+            // 创建日期格式化对象
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+            // 获取日历实例
+            Calendar c = Calendar.getInstance();
+            Date remindStartDate = null;
+            Date remindEndDate = null;
+            // 如果存在提醒开始时间参数，则进行计算和格式化
+            if (map.get("remindstart") != null) {
+                Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
+                c.setTime(new Date());
+                c.add(Calendar.DAY_OF_MONTH, remindStart);
+                remindStartDate = c.getTime();
+                map.put("remindstart", sdf.format(remindStartDate));
+            }
+            // 如果存在提醒结束时间参数，则进行计算和格式化
+            if (map.get("remindend") != null) {
+                Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
+                c.setTime(new Date());
+                c.add(Calendar.DAY_OF_MONTH, remindEnd);
+                remindEndDate = c.getTime();
+                map.put("remindend", sdf.format(remindEndDate));
+            }
+        }
+
+        // 创建一个包装器，用于构建 SQL 查询条件
+        Wrapper<ShangpinchukuEntity> wrapper = new EntityWrapper<ShangpinchukuEntity>();
+        // 根据提醒开始时间和结束时间设置查询条件
+        if (map.get("remindstart") != null) {
+            wrapper.ge(columnName, map.get("remindstart"));
+        }
+        if (map.get("remindend") != null) {
+            wrapper.le(columnName, map.get("remindend"));
+        }
+
+        // 从会话中获取 tableName
+        String tableName = request.getSession().getAttribute("tableName").toString();
+        // 如果 tableName 是 "yuangong"，则添加员工工号等于会话中 username 的查询条件
+        if (tableName.equals("yuangong")) {
+            wrapper.eq("yuangonggonghao", (String) request.getSession().getAttribute("username"));
+        }
+
+        // 调用商品出库服务类的 selectCount 方法统计满足条件的数量
+        int count = shangpinchukuService.selectCount(wrapper);
+        // 返回成功响应，并将统计数量放入响应结果中
+        return R.ok().put("count", count);
+    }
+}

src/main/java/com/controller/ShangpinkucunController.java

@@ -0,0 +1,298 @@
+package com.controller;
+
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Date;
+import java.util.List;
+import javax.servlet.http.HttpServletRequest;
+
+import com.utils.ValidatorUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.format.annotation.DateTimeFormat;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import com.baomidou.mybatisplus.mapper.EntityWrapper;
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.annotation.IgnoreAuth;
+
+import com.entity.ShangpinkucunEntity;
+import com.entity.view.ShangpinkucunView;
+
+import com.service.ShangpinkucunService;
+import com.service.TokenService;
+import com.utils.PageUtils;
+import com.utils.R;
+import com.utils.MD5Util;
+import com.utils.MPUtil;
+import com.utils.CommonUtil;
+
+
+ //商品库存
+ // 后端接口
+ // @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+@RestController
+@RequestMapping("/shangpinkucun")
+public class ShangpinkucunController {
+    // 自动注入商品库存服务类的实例，用于处理商品库存相关业务逻辑
+    @Autowired
+    private ShangpinkucunService shangpinkucunService;
+
+
+     //后端列表
+    // 该方法用于获取商品库存信息的分页列表（后端使用），支持根据商品库存实体和登记日期范围构建查询条件
+     //@param params 请求参数，包含分页、排序等信息
+     //@param shangpinkucun 商品库存实体，用于构建查询条件
+     // @param dengjiriqistart 登记日期开始时间，可选参数，格式为 yyyy-MM-dd HH:mm:ss
+     // @param dengjiriqiend 登记日期结束时间，可选参数，格式为 yyyy-MM-dd HH:mm:ss
+     // @param request HTTP 请求对象
+     // @return R 响应对象，包含操作结果和分页后的商品库存数据
+
+    @RequestMapping("/page")
+    public R page(@RequestParam Map<String, Object> params, ShangpinkucunEntity shangpinkucun,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date dengjiriqistart,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date dengjiriqiend,
+                  HttpServletRequest request) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<ShangpinkucunEntity> ew = new EntityWrapper<ShangpinkucunEntity>();
+        // 如果登记日期开始时间不为空，添加大于等于该时间的查询条件
+        if (dengjiriqistart != null)
+            ew.ge("dengjiriqi", dengjiriqistart);
+        // 如果登记日期结束时间不为空，添加小于等于该时间的查询条件
+        if (dengjiriqiend != null)
+            ew.le("dengjiriqi", dengjiriqiend);
+        // 调用商品库存服务类的 queryPage 方法进行分页查询，MPUtil 用于处理排序和条件查询
+        PageUtils page = shangpinkucunService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, shangpinkucun), params), params));
+        // 返回成功响应，并将分页数据放入响应结果中
+        return R.ok().put("data", page);
+    }
+
+
+     //前端列表
+     //该方法用于获取商品库存信息的分页列表（前端使用），支持根据商品库存实体和登记日期范围构建查询条件
+     // @param params 请求参数，包含分页、排序等信息
+     // @param shangpinkucun 商品库存实体，用于构建查询条件
+     // @param dengjiriqistart 登记日期开始时间，可选参数，格式为 yyyy-MM-dd HH:mm:ss
+     // @param dengjiriqiend 登记日期结束时间，可选参数，格式为 yyyy-MM-dd HH:mm:ss
+     // @param request HTTP 请求对象
+     // @return R 响应对象，包含操作结果和分页后的商品库存数据
+
+    @RequestMapping("/list")
+    public R list(@RequestParam Map<String, Object> params, ShangpinkucunEntity shangpinkucun,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date dengjiriqistart,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date dengjiriqiend,
+                  HttpServletRequest request) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<ShangpinkucunEntity> ew = new EntityWrapper<ShangpinkucunEntity>();
+        // 如果登记日期开始时间不为空，添加大于等于该时间的查询条件
+        if (dengjiriqistart != null)
+            ew.ge("dengjiriqi", dengjiriqistart);
+        // 如果登记日期结束时间不为空，添加小于等于该时间的查询条件
+        if (dengjiriqiend != null)
+            ew.le("dengjiriqi", dengjiriqiend);
+        // 调用商品库存服务类的 queryPage 方法进行分页查询，MPUtil 用于处理排序和条件查询
+        PageUtils page = shangpinkucunService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, shangpinkucun), params), params));
+        // 返回成功响应，并将分页数据放入响应结果中
+        return R.ok().put("data", page);
+    }
+
+
+     //列表
+     // 该方法用于获取满足特定条件的商品库存信息列表
+     //@param shangpinkucun 商品库存实体，用于构建查询条件
+     //@return R 响应对象，包含操作结果和查询到的商品库存信息列表数据
+
+    @RequestMapping("/lists")
+    public R list(ShangpinkucunEntity shangpinkucun) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<ShangpinkucunEntity> ew = new EntityWrapper<ShangpinkucunEntity>();
+        // 设置查询条件，使所有字段相等
+        ew.allEq(MPUtil.allEQMapPre(shangpinkucun, "shangpinkucun"));
+        // 调用商品库存服务类的 selectListView 方法获取列表数据
+        return R.ok().put("data", shangpinkucunService.selectListView(ew));
+    }
+
+
+     //查询
+     // 该方法用于根据商品库存实体的条件查询单个商品库存视图
+    // @param shangpinkucun 商品库存实体，用于构建查询条件
+    // @return R 响应对象，包含操作结果和查询到的商品库存视图数据
+
+    @RequestMapping("/query")
+    public R query(ShangpinkucunEntity shangpinkucun) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<ShangpinkucunEntity> ew = new EntityWrapper<ShangpinkucunEntity>();
+        // 设置查询条件，使所有字段相等
+        ew.allEq(MPUtil.allEQMapPre(shangpinkucun, "shangpinkucun"));
+        // 调用商品库存服务类的 selectView 方法获取商品库存视图
+        ShangpinkucunView shangpinkucunView = shangpinkucunService.selectView(ew);
+        // 返回成功响应，并将查询结果放入响应结果中
+        return R.ok("查询商品库存成功").put("data", shangpinkucunView);
+    }
+
+
+     //后端详情
+     // 该方法用于获取指定 ID 的商品库存详情（后端使用）
+     //@param id 商品库存记录的 ID
+     //@return R 响应对象，包含操作结果和指定 ID 的商品库存数据
+
+    @RequestMapping("/info/{id}")
+    public R info(@PathVariable("id") Long id) {
+        // 根据 ID 调用商品库存服务类的 selectById 方法获取商品库存实体
+        ShangpinkucunEntity shangpinkucun = shangpinkucunService.selectById(id);
+        // 返回成功响应，并将商品库存实体放入响应结果中
+        return R.ok().put("data", shangpinkucun);
+    }
+
+
+     // 前端详情
+    // 该方法用于获取指定 ID 的商品库存详情（前端使用）
+    //@param id 商品库存记录的 ID
+     //@return R 响应对象，包含操作结果和指定 ID 的商品库存数据
+
+    @RequestMapping("/detail/{id}")
+    public R detail(@PathVariable("id") Long id) {
+        // 根据 ID 调用商品库存服务类的 selectById 方法获取商品库存实体
+        ShangpinkucunEntity shangpinkucun = shangpinkucunService.selectById(id);
+        // 返回成功响应，并将商品库存实体放入响应结果中
+        return R.ok().put("data", shangpinkucun);
+    }
+
+
+     // 后端保存
+     // 该方法用于在后端保存新的商品库存记录
+     // @param shangpinkucun 要保存的商品库存实体
+     // @param request HTTP 请求对象
+     // @return R 响应对象，包含操作结果
+
+    @RequestMapping("/save")
+    public R save(@RequestBody ShangpinkucunEntity shangpinkucun, HttpServletRequest request) {
+        // 为商品库存实体设置一个唯一的 ID，由当前时间戳和随机数组成
+        shangpinkucun.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(shangpinkucun);
+        // 调用商品库存服务类的 insert 方法保存商品库存记录
+        shangpinkucunService.insert(shangpinkucun);
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 前端保存
+     //该方法用于在前端保存新的商品库存记录
+     // @param shangpinkucun 要保存的商品库存实体
+     // @param request HTTP 请求对象
+     // @return R 响应对象，包含操作结果
+
+    @RequestMapping("/add")
+    public R add(@RequestBody ShangpinkucunEntity shangpinkucun, HttpServletRequest request) {
+        // 为商品库存实体设置一个唯一的 ID，由当前时间戳和随机数组成
+        shangpinkucun.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(shangpinkucun);
+        // 调用商品库存服务类的 insert 方法保存商品库存记录
+        shangpinkucunService.insert(shangpinkucun);
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 修改
+     // 该方法用于修改已有的商品库存记录
+     // @param shangpinkucun 要修改的商品库存实体
+     //@param request HTTP 请求对象
+     // @return R 响应对象，包含操作结果
+
+    @RequestMapping("/update")
+    public R update(@RequestBody ShangpinkucunEntity shangpinkucun, HttpServletRequest request) {
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(shangpinkucun);
+        // 调用商品库存服务类的 updateById 方法根据 ID 更新商品库存记录
+        shangpinkucunService.updateById(shangpinkucun); // 全部更新
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 删除
+     //该方法用于批量删除指定 ID 的商品库存记录
+     //@param ids 要删除的商品库存记录的 ID 数组
+     // @return R 响应对象，包含操作结果
+
+    @RequestMapping("/delete")
+    public R delete(@RequestBody Long[] ids) {
+        // 调用商品库存服务类的 deleteBatchIds 方法批量删除商品库存记录
+        shangpinkucunService.deleteBatchIds(Arrays.asList(ids));
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 提醒接口
+     // 该方法用于根据指定列和时间范围统计满足条件的商品库存记录数量
+     //@param columnName 要统计的列名
+    //@param request HTTP 请求对象
+     // @param type 类型，1 表示数字，2 表示日期
+     // @param map 请求参数，包含提醒开始时间和结束时间等信息
+     // @return R 响应对象，包含操作结果和统计的数量
+
+    @RequestMapping("/remind/{columnName}/{type}")
+    public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
+                         @PathVariable("type") String type, @RequestParam Map<String, Object> map) {
+        // 将列名、类型等信息放入请求参数中
+        map.put("column", columnName);
+        map.put("type", type);
+
+        // 如果类型为日期（2），则进行日期相关的处理
+        if (type.equals("2")) {
+            // 创建日期格式化对象
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+            // 获取日历实例
+            Calendar c = Calendar.getInstance();
+            Date remindStartDate = null;
+            Date remindEndDate = null;
+            // 如果存在提醒开始时间参数，则进行计算和格式化
+            if (map.get("remindstart") != null) {
+                Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
+                c.setTime(new Date());
+                c.add(Calendar.DAY_OF_MONTH, remindStart);
+                remindStartDate = c.getTime();
+                map.put("remindstart", sdf.format(remindStartDate));
+            }
+            // 如果存在提醒结束时间参数，则进行计算和格式化
+            if (map.get("remindend") != null) {
+                Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
+                c.setTime(new Date());
+                c.add(Calendar.DAY_OF_MONTH, remindEnd);
+                remindEndDate = c.getTime();
+                map.put("remindend", sdf.format(remindEndDate));
+            }
+        }
+
+        // 创建一个包装器，用于构建 SQL 查询条件
+        Wrapper<ShangpinkucunEntity> wrapper = new EntityWrapper<ShangpinkucunEntity>();
+        // 根据提醒开始时间和结束时间设置查询条件
+        if (map.get("remindstart") != null) {
+            wrapper.ge(columnName, map.get("remindstart"));
+        }
+        if (map.get("remindend") != null) {
+            wrapper.le(columnName, map.get("remindend"));
+        }
+
+        // 调用商品库存服务类的 selectCount 方法统计满足条件的数量
+        int count = shangpinkucunService.selectCount(wrapper);
+        // 返回成功响应，并将统计数量放入响应结果中
+        return R.ok().put("count", count);
+    }
+}

src/main/java/com/controller/ShangpinleixingController.java

@@ -0,0 +1,282 @@
+package com.controller;
+
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Date;
+import java.util.List;
+import javax.servlet.http.HttpServletRequest;
+
+import com.utils.ValidatorUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.format.annotation.DateTimeFormat;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import com.baomidou.mybatisplus.mapper.EntityWrapper;
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.annotation.IgnoreAuth;
+
+import com.entity.ShangpinleixingEntity;
+import com.entity.view.ShangpinleixingView;
+
+import com.service.ShangpinleixingService;
+import com.service.TokenService;
+import com.utils.PageUtils;
+import com.utils.R;
+import com.utils.MD5Util;
+import com.utils.MPUtil;
+import com.utils.CommonUtil;
+
+
+ // 商品类型
+ //后端接口
+ // @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+@RestController
+@RequestMapping("/shangpinleixing")
+public class ShangpinleixingController {
+    // 自动注入商品类型服务类，用于处理商品类型相关的业务逻辑
+    @Autowired
+    private ShangpinleixingService shangpinleixingService;
+
+
+     //后端列表
+     //用于获取商品类型信息的分页列表，供后端使用
+     //@param params 请求参数，包含分页、排序等信息
+     //@param shangpinleixing 商品类型实体，用于构建查询条件
+     //@param request HTTP 请求对象
+     //@return R 通用响应对象，包含操作结果和分页数据
+
+    @RequestMapping("/page")
+    public R page(@RequestParam Map<String, Object> params, ShangpinleixingEntity shangpinleixing,
+                  HttpServletRequest request) {
+        // 创建实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<ShangpinleixingEntity> ew = new EntityWrapper<ShangpinleixingEntity>();
+        // 调用服务类的 queryPage 方法进行分页查询，MPUtil 用于处理排序和条件查询
+        PageUtils page = shangpinleixingService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, shangpinleixing), params), params));
+        // 返回成功响应，并将分页数据放入响应结果中
+        return R.ok().put("data", page);
+    }
+
+
+     // 前端列表
+     // 用于获取商品类型信息的分页列表，供前端使用
+     //@param params 请求参数，包含分页、排序等信息
+     //@param shangpinleixing 商品类型实体，用于构建查询条件
+    // @param request HTTP 请求对象
+     //@return R 通用响应对象，包含操作结果和分页数据
+
+    @RequestMapping("/list")
+    public R list(@RequestParam Map<String, Object> params, ShangpinleixingEntity shangpinleixing,
+                  HttpServletRequest request) {
+        // 创建实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<ShangpinleixingEntity> ew = new EntityWrapper<ShangpinleixingEntity>();
+        // 调用服务类的 queryPage 方法进行分页查询，MPUtil 用于处理排序和条件查询
+        PageUtils page = shangpinleixingService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, shangpinleixing), params), params));
+        // 返回成功响应，并将分页数据放入响应结果中
+        return R.ok().put("data", page);
+    }
+
+
+     // 列表
+     // 用于获取满足特定条件的商品类型信息列表
+     // @param shangpinleixing 商品类型实体，用于构建查询条件
+     // @return R 通用响应对象，包含操作结果和查询到的商品类型信息列表
+
+    @RequestMapping("/lists")
+    public R list(ShangpinleixingEntity shangpinleixing) {
+        // 创建实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<ShangpinleixingEntity> ew = new EntityWrapper<ShangpinleixingEntity>();
+        // 设置查询条件，使所有字段相等
+        ew.allEq(MPUtil.allEQMapPre(shangpinleixing, "shangpinleixing"));
+        // 调用服务类的 selectListView 方法获取列表数据
+        return R.ok().put("data", shangpinleixingService.selectListView(ew));
+    }
+
+
+     //查询
+     //用于根据商品类型实体的条件查询单个商品类型视图
+     //@param shangpinleixing 商品类型实体，用于构建查询条件
+     // @return R 通用响应对象，包含操作结果和查询到的商品类型视图
+
+    @RequestMapping("/query")
+    public R query(ShangpinleixingEntity shangpinleixing) {
+        // 创建实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<ShangpinleixingEntity> ew = new EntityWrapper<ShangpinleixingEntity>();
+        // 设置查询条件，使所有字段相等
+        ew.allEq(MPUtil.allEQMapPre(shangpinleixing, "shangpinleixing"));
+        // 调用服务类的 selectView 方法获取商品类型视图
+        ShangpinleixingView shangpinleixingView =  shangpinleixingService.selectView(ew);
+        // 返回成功响应，并将查询结果放入响应结果中
+        return R.ok("查询商品类型成功").put("data", shangpinleixingView);
+    }
+
+
+     //后端详情
+     //用于获取指定 ID 的商品类型详情，供后端使用
+     //@param id 商品类型记录的 ID
+     //@return R 通用响应对象，包含操作结果和指定 ID 的商品类型信息
+
+    @RequestMapping("/info/{id}")
+    public R info(@PathVariable("id") Long id) {
+        // 根据 ID 调用服务类的 selectById 方法获取商品类型实体
+        ShangpinleixingEntity shangpinleixing = shangpinleixingService.selectById(id);
+        // 返回成功响应，并将商品类型实体放入响应结果中
+        return R.ok().put("data", shangpinleixing);
+    }
+
+
+     // 前端详情
+     // 用于获取指定 ID 的商品类型详情，供前端使用
+     //@param id 商品类型记录的 ID
+     //@return R 通用响应对象，包含操作结果和指定 ID 的商品类型信息
+
+    @RequestMapping("/detail/{id}")
+    public R detail(@PathVariable("id") Long id) {
+        // 根据 ID 调用服务类的 selectById 方法获取商品类型实体
+        ShangpinleixingEntity shangpinleixing = shangpinleixingService.selectById(id);
+        // 返回成功响应，并将商品类型实体放入响应结果中
+        return R.ok().put("data", shangpinleixing);
+    }
+
+
+     //后端保存
+     // 用于在后端保存新的商品类型记录
+     // @param shangpinleixing 要保存的商品类型实体
+     // @param request HTTP 请求对象
+     // @return R 通用响应对象，包含操作结果
+
+    @RequestMapping("/save")
+    public R save(@RequestBody ShangpinleixingEntity shangpinleixing, HttpServletRequest request) {
+        // 为商品类型实体设置一个唯一的 ID，由当前时间戳和随机数组成
+        shangpinleixing.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(shangpinleixing);
+        // 调用服务类的 insert 方法保存商品类型记录
+        shangpinleixingService.insert(shangpinleixing);
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 前端保存
+     // 用于在前端保存新的商品类型记录
+     // @param shangpinleixing 要保存的商品类型实体
+     // @param request HTTP 请求对象
+     //@return R 通用响应对象，包含操作结果
+
+    @RequestMapping("/add")
+    public R add(@RequestBody ShangpinleixingEntity shangpinleixing, HttpServletRequest request) {
+        // 为商品类型实体设置一个唯一的 ID，由当前时间戳和随机数组成
+        shangpinleixing.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(shangpinleixing);
+        // 调用服务类的 insert 方法保存商品类型记录
+        shangpinleixingService.insert(shangpinleixing);
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 修改
+     // 用于修改已有的商品类型记录
+     // @param shangpinleixing 要修改的商品类型实体
+     // @param request HTTP 请求对象
+     // @return R 通用响应对象，包含操作结果
+
+    @RequestMapping("/update")
+    public R update(@RequestBody ShangpinleixingEntity shangpinleixing, HttpServletRequest request) {
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(shangpinleixing);
+        // 调用服务类的 updateById 方法根据 ID 更新商品类型记录
+        shangpinleixingService.updateById(shangpinleixing); // 全部更新
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     //删除
+    //用于批量删除指定 ID 的商品类型记录
+     //@param ids 要删除的商品类型记录的 ID 数组
+     // @return R 通用响应对象，包含操作结果
+
+    @RequestMapping("/delete")
+    public R delete(@RequestBody Long[] ids) {
+        // 调用服务类的 deleteBatchIds 方法批量删除商品类型记录
+        shangpinleixingService.deleteBatchIds(Arrays.asList(ids));
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 提醒接口
+     // 用于根据指定列和时间范围统计满足条件的商品类型记录数量
+     // @param columnName 要统计的列名
+     // @param request HTTP 请求对象
+     // @param type 类型，1 表示数字，2 表示日期
+    // @param map 请求参数，包含提醒开始时间和结束时间等信息
+     // @return R 通用响应对象，包含操作结果和统计的数量
+
+    @RequestMapping("/remind/{columnName}/{type}")
+    public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
+                         @PathVariable("type") String type, @RequestParam Map<String, Object> map) {
+        // 将列名和类型放入请求参数中
+        map.put("column", columnName);
+        map.put("type", type);
+
+        if (type.equals("2")) {
+            // 创建日期格式化对象
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+            // 获取日历实例
+            Calendar c = Calendar.getInstance();
+            Date remindStartDate = null;
+            Date remindEndDate = null;
+            if (map.get("remindstart") != null) {
+                // 解析提醒开始时间的偏移量
+                Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
+                c.setTime(new Date());
+                // 计算提醒开始日期
+                c.add(Calendar.DAY_OF_MONTH, remindStart);
+                remindStartDate = c.getTime();
+                // 将格式化后的提醒开始日期放入请求参数中
+                map.put("remindstart", sdf.format(remindStartDate));
+            }
+            if (map.get("remindend") != null) {
+                // 解析提醒结束时间的偏移量
+                Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
+                c.setTime(new Date());
+                // 计算提醒结束日期
+                c.add(Calendar.DAY_OF_MONTH, remindEnd);
+                remindEndDate = c.getTime();
+                // 将格式化后的提醒结束日期放入请求参数中
+                map.put("remindend", sdf.format(remindEndDate));
+            }
+        }
+
+        // 创建实体包装器，用于构建 SQL 查询条件
+        Wrapper<ShangpinleixingEntity> wrapper = new EntityWrapper<ShangpinleixingEntity>();
+        if (map.get("remindstart") != null) {
+            // 设置大于等于提醒开始日期的查询条件
+            wrapper.ge(columnName, map.get("remindstart"));
+        }
+        if (map.get("remindend") != null) {
+            // 设置小于等于提醒结束日期的查询条件
+            wrapper.le(columnName, map.get("remindend"));
+        }
+
+        // 调用服务类的 selectCount 方法统计满足条件的记录数量
+        int count = shangpinleixingService.selectCount(wrapper);
+        // 返回成功响应，并将统计数量放入响应结果中
+        return R.ok().put("count", count);
+    }
+}

src/main/java/com/controller/ShangpinrukuController.java

@@ -0,0 +1,312 @@
+package com.controller;
+
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Date;
+import java.util.List;
+import javax.servlet.http.HttpServletRequest;
+
+import com.utils.ValidatorUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.format.annotation.DateTimeFormat;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import com.baomidou.mybatisplus.mapper.EntityWrapper;
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.annotation.IgnoreAuth;
+
+import com.entity.ShangpinrukuEntity;
+import com.entity.view.ShangpinrukuView;
+
+import com.service.ShangpinrukuService;
+import com.service.TokenService;
+import com.utils.PageUtils;
+import com.utils.R;
+import com.utils.MD5Util;
+import com.utils.MPUtil;
+import com.utils.CommonUtil;
+
+
+ //商品入库
+ //后端接口
+ //@author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+@RestController
+@RequestMapping("/shangpinruku")
+public class ShangpinrukuController {
+    // 自动注入商品入库服务类的实例，用于处理商品入库相关业务逻辑
+    @Autowired
+    private ShangpinrukuService shangpinrukuService;
+
+
+     // 后端列表
+     // 该方法用于获取商品入库信息的分页列表（后端使用），支持根据商品入库实体和入库时间范围构建查询条件，
+     // 并且根据会话中的 tableName 和 username 信息添加额外的查询条件
+     // @param params 请求参数，包含分页、排序等信息
+     // @param shangpinruku 商品入库实体，用于构建查询条件
+     // @param rukushijianstart 入库时间开始时间，可选参数，格式为 yyyy-MM-dd HH:mm:ss
+     // @param rukushijianend 入库时间结束时间，可选参数，格式为 yyyy-MM-dd HH:mm:ss
+     // @param request HTTP 请求对象
+     // @return R 响应对象，包含操作结果和分页后的商品入库数据
+
+    @RequestMapping("/page")
+    public R page(@RequestParam Map<String, Object> params, ShangpinrukuEntity shangpinruku,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date rukushijianstart,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date rukushijianend,
+                  HttpServletRequest request) {
+        // 从会话中获取 tableName
+        String tableName = request.getSession().getAttribute("tableName").toString();
+        // 如果 tableName 是 "yuangong"，则设置商品入库实体的员工工号为会话中的 username
+        if (tableName.equals("yuangong")) {
+            shangpinruku.setYuangonggonghao((String) request.getSession().getAttribute("username"));
+        }
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<ShangpinrukuEntity> ew = new EntityWrapper<ShangpinrukuEntity>();
+        // 如果入库时间开始时间不为空，添加大于等于该时间的查询条件
+        if (rukushijianstart != null)
+            ew.ge("rukushijian", rukushijianstart);
+        // 如果入库时间结束时间不为空，添加小于等于该时间的查询条件
+        if (rukushijianend != null)
+            ew.le("rukushijian", rukushijianend);
+        // 调用商品入库服务类的 queryPage 方法进行分页查询，MPUtil 用于处理排序和条件查询
+        PageUtils page = shangpinrukuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, shangpinruku), params), params));
+        // 返回成功响应，并将分页数据放入响应结果中
+        return R.ok().put("data", page);
+    }
+
+
+     //前端列表
+     //该方法用于获取商品入库信息的分页列表（前端使用），支持根据商品入库实体和入库时间范围构建查询条件
+     // @param params 请求参数，包含分页、排序等信息
+     //@param shangpinruku 商品入库实体，用于构建查询条件
+     // @param rukushijianstart 入库时间开始时间，可选参数，格式为 yyyy-MM-dd HH:mm:ss
+     // @param rukushijianend 入库时间结束时间，可选参数，格式为 yyyy-MM-dd HH:mm:ss
+     // @param request HTTP 请求对象
+     // @return R 响应对象，包含操作结果和分页后的商品入库数据
+
+    @RequestMapping("/list")
+    public R list(@RequestParam Map<String, Object> params, ShangpinrukuEntity shangpinruku,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date rukushijianstart,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date rukushijianend,
+                  HttpServletRequest request) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<ShangpinrukuEntity> ew = new EntityWrapper<ShangpinrukuEntity>();
+        // 如果入库时间开始时间不为空，添加大于等于该时间的查询条件
+        if (rukushijianstart != null)
+            ew.ge("rukushijian", rukushijianstart);
+        // 如果入库时间结束时间不为空，添加小于等于该时间的查询条件
+        if (rukushijianend != null)
+            ew.le("rukushijian", rukushijianend);
+        // 调用商品入库服务类的 queryPage 方法进行分页查询，MPUtil 用于处理排序和条件查询
+        PageUtils page = shangpinrukuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, shangpinruku), params), params));
+        // 返回成功响应，并将分页数据放入响应结果中
+        return R.ok().put("data", page);
+    }
+
+
+     // 列表
+     // 该方法用于获取满足特定条件的商品入库信息列表
+     //@param shangpinruku 商品入库实体，用于构建查询条件
+     // @return R 响应对象，包含操作结果和查询到的商品入库信息列表数据
+
+    @RequestMapping("/lists")
+    public R list(ShangpinrukuEntity shangpinruku) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<ShangpinrukuEntity> ew = new EntityWrapper<ShangpinrukuEntity>();
+        // 设置查询条件，使所有字段相等
+        ew.allEq(MPUtil.allEQMapPre(shangpinruku, "shangpinruku"));
+        // 调用商品入库服务类的 selectListView 方法获取列表数据
+        return R.ok().put("data", shangpinrukuService.selectListView(ew));
+    }
+
+
+     //查询
+     // 该方法用于根据商品入库实体的条件查询单个商品入库视图
+     //@param shangpinruku 商品入库实体，用于构建查询条件
+     //@return R 响应对象，包含操作结果和查询到的商品入库视图数据
+
+    @RequestMapping("/query")
+    public R query(ShangpinrukuEntity shangpinruku) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<ShangpinrukuEntity> ew = new EntityWrapper<ShangpinrukuEntity>();
+        // 设置查询条件，使所有字段相等
+        ew.allEq(MPUtil.allEQMapPre(shangpinruku, "shangpinruku"));
+        // 调用商品入库服务类的 selectView 方法获取商品入库视图
+        ShangpinrukuView shangpinrukuView = shangpinrukuService.selectView(ew);
+        // 返回成功响应，并将查询结果放入响应结果中
+        return R.ok("查询商品入库成功").put("data", shangpinrukuView);
+    }
+
+
+     //后端详情
+     // 该方法用于获取指定 ID 的商品入库详情（后端使用）
+     //@param id 商品入库记录的 ID
+     // @return R 响应对象，包含操作结果和指定 ID 的商品入库数据
+
+    @RequestMapping("/info/{id}")
+    public R info(@PathVariable("id") Long id) {
+        // 根据 ID 调用商品入库服务类的 selectById 方法获取商品入库实体
+        ShangpinrukuEntity shangpinruku = shangpinrukuService.selectById(id);
+        // 返回成功响应，并将商品入库实体放入响应结果中
+        return R.ok().put("data", shangpinruku);
+    }
+
+
+      //前端详情
+     // 该方法用于获取指定 ID 的商品入库详情（前端使用）
+     // @param id 商品入库记录的 ID
+     //@return R 响应对象，包含操作结果和指定 ID 的商品入库数据
+
+    @RequestMapping("/detail/{id}")
+    public R detail(@PathVariable("id") Long id) {
+        // 根据 ID 调用商品入库服务类的 selectById 方法获取商品入库实体
+        ShangpinrukuEntity shangpinruku = shangpinrukuService.selectById(id);
+        // 返回成功响应，并将商品入库实体放入响应结果中
+        return R.ok().put("data", shangpinruku);
+    }
+
+
+     // 后端保存
+     // 该方法用于在后端保存新的商品入库记录
+     // @param shangpinruku 要保存的商品入库实体
+     // @param request HTTP 请求对象
+     //@return R 响应对象，包含操作结果
+
+    @RequestMapping("/save")
+    public R save(@RequestBody ShangpinrukuEntity shangpinruku, HttpServletRequest request) {
+        // 为商品入库实体设置一个唯一的 ID，由当前时间戳和随机数组成
+        shangpinruku.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(shangpinruku);
+        // 调用商品入库服务类的 insert 方法保存商品入库记录
+        shangpinrukuService.insert(shangpinruku);
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 前端保存
+     // 该方法用于在前端保存新的商品入库记录
+     // @param shangpinruku 要保存的商品入库实体
+     // @param request HTTP 请求对象
+     // @return R 响应对象，包含操作结果
+
+    @RequestMapping("/add")
+    public R add(@RequestBody ShangpinrukuEntity shangpinruku, HttpServletRequest request) {
+        // 为商品入库实体设置一个唯一的 ID，由当前时间戳和随机数组成
+        shangpinruku.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(shangpinruku);
+        // 调用商品入库服务类的 insert 方法保存商品入库记录
+        shangpinrukuService.insert(shangpinruku);
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 修改
+     // 该方法用于修改已有的商品入库记录
+     // @param shangpinruku 要修改的商品入库实体
+     // @param request HTTP 请求对象
+     // @return R 响应对象，包含操作结果
+
+    @RequestMapping("/update")
+    public R update(@RequestBody ShangpinrukuEntity shangpinruku, HttpServletRequest request) {
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(shangpinruku);
+        // 调用商品入库服务类的 updateById 方法根据 ID 更新商品入库记录
+        shangpinrukuService.updateById(shangpinruku); // 全部更新
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 删除
+     //该方法用于批量删除指定 ID 的商品入库记录
+     // @param ids 要删除的商品入库记录的 ID 数组
+    // @return R 响应对象，包含操作结果
+
+    @RequestMapping("/delete")
+    public R delete(@RequestBody Long[] ids) {
+        // 调用商品入库服务类的 deleteBatchIds 方法批量删除商品入库记录
+        shangpinrukuService.deleteBatchIds(Arrays.asList(ids));
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     //提醒接口
+     // 该方法用于根据指定列和时间范围统计满足条件的商品入库记录数量，
+     // 并且根据会话中的 tableName 和 username 信息添加额外的查询条件
+     // @param columnName 要统计的列名
+     //@param request HTTP 请求对象
+     // @param type 类型，1 表示数字，2 表示日期
+     // @param map 请求参数，包含提醒开始时间和结束时间等信息
+     // @return R 响应对象，包含操作结果和统计的数量
+    @RequestMapping("/remind/{columnName}/{type}")
+    public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
+                         @PathVariable("type") String type, @RequestParam Map<String, Object> map) {
+        // 将列名、类型等信息放入请求参数中
+        map.put("column", columnName);
+        map.put("type", type);
+
+        // 如果类型为日期（2），则进行日期相关的处理
+        if (type.equals("2")) {
+            // 创建日期格式化对象
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+            // 获取日历实例
+            Calendar c = Calendar.getInstance();
+            Date remindStartDate = null;
+            Date remindEndDate = null;
+            // 如果存在提醒开始时间参数，则进行计算和格式化
+            if (map.get("remindstart") != null) {
+                Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
+                c.setTime(new Date());
+                c.add(Calendar.DAY_OF_MONTH, remindStart);
+                remindStartDate = c.getTime();
+                map.put("remindstart", sdf.format(remindStartDate));
+            }
+            // 如果存在提醒结束时间参数，则进行计算和格式化
+            if (map.get("remindend") != null) {
+                Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
+                c.setTime(new Date());
+                c.add(Calendar.DAY_OF_MONTH, remindEnd);
+                remindEndDate = c.getTime();
+                map.put("remindend", sdf.format(remindEndDate));
+            }
+        }
+
+        // 创建一个包装器，用于构建 SQL 查询条件
+        Wrapper<ShangpinrukuEntity> wrapper = new EntityWrapper<ShangpinrukuEntity>();
+        // 根据提醒开始时间和结束时间设置查询条件
+        if (map.get("remindstart") != null) {
+            wrapper.ge(columnName, map.get("remindstart"));
+        }
+        if (map.get("remindend") != null) {
+            wrapper.le(columnName, map.get("remindend"));
+        }
+
+        // 从会话中获取 tableName
+        String tableName = request.getSession().getAttribute("tableName").toString();
+        // 如果 tableName 是 "yuangong"，则添加员工工号等于会话中 username 的查询条件
+        if (tableName.equals("yuangong")) {
+            wrapper.eq("yuangonggonghao", (String) request.getSession().getAttribute("username"));
+        }
+
+        // 调用商品入库服务类的 selectCount 方法统计满足条件的数量
+        int count = shangpinrukuService.selectCount(wrapper);
+        // 返回成功响应，并将统计数量放入响应结果中
+        return R.ok().put("count", count);
+    }
+}

src/main/java/com/controller/UserController.java

@@ -0,0 +1,250 @@
+
+package com.controller;
+
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.Map;
+
+import javax.servlet.http.HttpServletRequest;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+
+import com.annotation.IgnoreAuth;
+import com.baomidou.mybatisplus.mapper.EntityWrapper;
+import com.entity.TokenEntity;
+import com.entity.UserEntity;
+import com.service.TokenService;
+import com.service.UserService;
+import com.utils.CommonUtil;
+import com.utils.MD5Util;
+import com.utils.MPUtil;
+import com.utils.PageUtils;
+import com.utils.R;
+import com.utils.ValidatorUtils;
+
+
+// 登录相关
+
+@RequestMapping("users")
+@RestController
+public class UserController {
+
+	// 自动注入用户服务类，用于处理用户相关业务逻辑
+	@Autowired
+	private UserService userService;
+
+	// 自动注入令牌服务类，用于处理令牌相关业务逻辑
+	@Autowired
+	private TokenService tokenService;
+
+
+	// 登录
+	// 处理用户登录请求，验证用户名和密码，生成并返回令牌
+	 // @param username 用户名
+	 // @param password 密码
+	 // @param captcha 验证码（当前代码未使用）
+	 // @param request HTTP请求对象
+	 // @return R 响应对象，包含操作结果和令牌（如果登录成功）
+
+	@IgnoreAuth
+	@PostMapping(value = "/login")
+	public R login(String username, String password, String captcha, HttpServletRequest request) {
+		// 根据用户名查询用户实体
+		UserEntity user = userService.selectOne(new EntityWrapper<UserEntity>().eq("username", username));
+		// 如果用户不存在或密码不正确，返回错误响应
+		if (user == null || !user.getPassword().equals(password)) {
+			return R.error("账号或密码不正确");
+		}
+		// 生成令牌，参数包括用户ID、用户名、用户表名和用户角色
+		String token = tokenService.generateToken(user.getId(), username, "users", user.getRole());
+		// 返回成功响应，并将令牌放入响应结果中
+		return R.ok().put("token", token);
+	}
+
+
+	 //注册
+	 //处理用户注册请求，验证用户信息并插入数据库
+//@param user 用户实体，包含注册信息
+	 //@return R 响应对象，包含操作结果
+
+	@IgnoreAuth
+	@PostMapping(value = "/register")
+	public R register(@RequestBody UserEntity user) {
+		// 注释掉的验证实体方法，可用于验证实体数据的合法性
+//    	ValidatorUtils.validateEntity(user);
+		// 检查用户名是否已存在
+		if (userService.selectOne(new EntityWrapper<UserEntity>().eq("username", user.getUsername())) != null) {
+			return R.error("用户已存在");
+		}
+		// 插入用户信息到数据库
+		userService.insert(user);
+		// 返回成功响应
+		return R.ok();
+	}
+
+
+	 // 退出
+	 //处理用户退出请求，使当前会话失效
+	 //@param request HTTP请求对象
+	 //@return R 响应对象，包含操作结果
+
+	@GetMapping(value = "logout")
+	public R logout(HttpServletRequest request) {
+		// 使会话失效
+		request.getSession().invalidate();
+		// 返回成功响应
+		return R.ok("退出成功");
+	}
+
+
+// 处理用户密码重置请求，将用户密码重置为默认值
+	 //@param username 用户名
+	 // @param request HTTP请求对象
+	 // @return R 响应对象，包含操作结果
+
+	@IgnoreAuth
+	@RequestMapping(value = "/resetPass")
+	public R resetPass(String username, HttpServletRequest request) {
+		// 根据用户名查询用户实体
+		UserEntity user = userService.selectOne(new EntityWrapper<UserEntity>().eq("username", username));
+		// 如果用户不存在，返回错误响应
+		if (user == null) {
+			return R.error("账号不存在");
+		}
+		// 将用户密码设置为默认值 "123456"
+		user.setPassword("123456");
+		// 更新用户信息到数据库
+		userService.update(user, null);
+		// 返回成功响应，并提示密码已重置
+		return R.ok("密码已重置为：123456");
+	}
+
+
+	 //列表（分页）
+	 // 获取用户信息的分页列表
+	 // @param params 请求参数，包含分页、排序等信息
+	 // @param user 用户实体，用于构建查询条件
+	 // @return R 响应对象，包含操作结果和分页数据
+
+	@RequestMapping("/page")
+	public R page(@RequestParam Map<String, Object> params, UserEntity user) {
+		// 创建实体包装器，用于构建SQL查询条件
+		EntityWrapper<UserEntity> ew = new EntityWrapper<UserEntity>();
+		// 调用用户服务类的 queryPage 方法进行分页查询，MPUtil 用于处理排序和条件查询
+		PageUtils page = userService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allLike(ew, user), params), params));
+		// 返回成功响应，并将分页数据放入响应结果中
+		return R.ok().put("data", page);
+	}
+
+
+	 // 列表
+	 //获取满足特定条件的用户信息列表
+	 //@param user 用户实体，用于构建查询条件
+	 //@return R 响应对象，包含操作结果和查询到的用户信息列表
+
+	@RequestMapping("/list")
+	public R list(UserEntity user) {
+		// 创建实体包装器，用于构建 SQL 查询条件
+		EntityWrapper<UserEntity> ew = new EntityWrapper<UserEntity>();
+		// 设置查询条件，使所有字段相等
+		ew.allEq(MPUtil.allEQMapPre(user, "user"));
+		// 调用用户服务类的 selectListView 方法获取列表数据
+		return R.ok().put("data", userService.selectListView(ew));
+	}
+
+
+	 //信息
+	 // 获取指定ID的用户信息
+	 // @param id 用户ID
+	 //@return R 响应对象，包含操作结果和用户信息
+
+	@RequestMapping("/info/{id}")
+	public R info(@PathVariable("id") String id) {
+		// 根据ID查询用户实体
+		UserEntity user = userService.selectById(id);
+		// 返回成功响应，并将用户信息放入响应结果中
+		return R.ok().put("data", user);
+	}
+
+
+	 //获取用户的session用户信息
+	 //从会话中获取用户ID并查询对应的用户信息
+	 //@param request HTTP请求对象
+	 // @return R 响应对象，包含操作结果和用户信息
+
+	@RequestMapping("/session")
+	public R getCurrUser(HttpServletRequest request) {
+		// 从会话中获取用户ID
+		Long id = (Long) request.getSession().getAttribute("userId");
+		// 根据ID查询用户实体
+		UserEntity user = userService.selectById(id);
+		// 返回成功响应，并将用户信息放入响应结果中
+		return R.ok().put("data", user);
+	}
+
+
+	 //保存
+	// 保存新用户信息，检查用户名是否已存在
+	 //@param user 用户实体，包含要保存的信息
+	 // @return R 响应对象，包含操作结果
+
+	@PostMapping("/save")
+	public R save(@RequestBody UserEntity user) {
+		// 注释掉的验证实体方法，可用于验证实体数据的合法性
+//    	ValidatorUtils.validateEntity(user);
+		// 检查用户名是否已存在
+		if (userService.selectOne(new EntityWrapper<UserEntity>().eq("username", user.getUsername())) != null) {
+			return R.error("用户已存在");
+		}
+		// 插入用户信息到数据库
+		userService.insert(user);
+		// 返回成功响应
+		return R.ok();
+	}
+
+
+	// 修改
+	// 修改用户信息，检查用户名是否已被其他用户使用
+	 //@param user 用户实体，包含要修改的信息
+	 //@return R 响应对象，包含操作结果
+
+	@RequestMapping("/update")
+	public R update(@RequestBody UserEntity user) {
+		// 注释掉的验证实体方法，可用于验证实体数据的合法性
+//        ValidatorUtils.validateEntity(user);
+		// 根据用户名查询用户实体
+		UserEntity u = userService.selectOne(new EntityWrapper<UserEntity>().eq("username", user.getUsername()));
+		// 如果用户名已存在且不是当前用户，返回错误响应
+		if (u != null && u.getId() != user.getId() && u.getUsername().equals(user.getUsername())) {
+			return R.error("用户名已存在。");
+		}
+		// 根据用户ID更新用户信息到数据库
+		userService.updateById(user); // 全部更新
+		// 返回成功响应
+		return R.ok();
+	}
+
+
+	 // 删除
+	 // 批量删除用户信息
+	 // @param ids 要删除的用户ID数组
+	 //@return R 响应对象，包含操作结果
+
+	@RequestMapping("/delete")
+	public R delete(@RequestBody Long[] ids) {
+		// 调用用户服务类的 deleteBatchIds 方法批量删除用户信息
+		userService.deleteBatchIds(Arrays.asList(ids));
+		// 返回成功响应
+		return R.ok();
+	}
+}

src/main/java/com/controller/YuangongController.java

@@ -0,0 +1,398 @@
+package com.controller;
+
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Date;
+import java.util.List;
+import javax.servlet.http.HttpServletRequest;
+
+import com.utils.ValidatorUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.format.annotation.DateTimeFormat;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import com.baomidou.mybatisplus.mapper.EntityWrapper;
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.annotation.IgnoreAuth;
+
+import com.entity.YuangongEntity;
+import com.entity.view.YuangongView;
+
+import com.service.YuangongService;
+import com.service.TokenService;
+import com.utils.PageUtils;
+import com.utils.R;
+import com.utils.MD5Util;
+import com.utils.MPUtil;
+import com.utils.CommonUtil;
+
+
+ // 员工
+ // 后端接口
+ // @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+@RestController
+@RequestMapping("/yuangong")
+public class YuangongController {
+	// 自动注入员工服务类，用于处理员工相关业务逻辑
+	@Autowired
+	private YuangongService yuangongService;
+	// 自动注入令牌服务类，用于生成和管理令牌
+	@Autowired
+	private TokenService tokenService;
+
+
+	 // 登录
+	 // 处理员工登录请求
+	 //@param username 员工工号，用于查询对应的员工信息
+	 //@param password 密码，用于验证员工身份
+	 // @param captcha 验证码（当前未使用）
+	 // @param request HttpServletRequest对象，用于获取请求相关信息
+	 // @return R类型响应对象，包含操作结果信息。如果登录成功，返回带有令牌的成功响应；否则返回错误响应
+
+	@IgnoreAuth
+	@RequestMapping(value = "/login")
+	public R login(String username, String password, String captcha, HttpServletRequest request) {
+		// 根据员工工号查询员工实体
+		YuangongEntity user = yuangongService.selectOne(new EntityWrapper<YuangongEntity>().eq("yuangonggonghao", username));
+		// 检查员工是否存在且密码是否正确
+		if (user == null || !user.getMima().equals(password)) {
+			return R.error("账号或密码不正确");
+		}
+		// 生成令牌，参数包括员工ID、员工工号、用户类型（这里是"yuangong"）和角色（这里是"员工"）
+		String token = tokenService.generateToken(user.getId(), username, "yuangong", "员工");
+		// 返回成功响应并附带生成的令牌
+		return R.ok().put("token", token);
+	}
+
+
+	 // 注册
+	// 处理员工注册请求
+	 // @param yuangong 包含员工注册信息的YuangongEntity对象
+	 // @return R类型响应对象，包含操作结果信息。如果注册成功，返回成功响应；若员工工号已存在，返回错误响应
+
+	@IgnoreAuth
+	@RequestMapping("/register")
+	public R register(@RequestBody YuangongEntity yuangong) {
+		// （注释掉的）验证员工实体的合法性
+		//ValidatorUtils.validateEntity(yuangong);
+		// 检查员工工号是否已被注册
+		YuangongEntity user = yuangongService.selectOne(new EntityWrapper<YuangongEntity>().eq("yuangonggonghao", yuangong.getYuangonggonghao()));
+		if (user != null) {
+			return R.error("注册用户已存在");
+		}
+		// 生成一个以当前时间戳为ID的员工ID
+		Long uId = new Date().getTime();
+		yuangong.setId(uId);
+		// 将员工信息插入数据库
+		yuangongService.insert(yuangong);
+		// 返回注册成功的响应
+		return R.ok();
+	}
+
+
+	 //退出
+	 //处理员工退出请求
+	 // @param request HttpServletRequest对象，用于使会话失效
+	 // @return R类型响应对象，返回退出成功的信息
+
+	@RequestMapping("/logout")
+	public R logout(HttpServletRequest request) {
+		// 使当前会话失效
+		request.getSession().invalidate();
+		// 返回退出成功的响应
+		return R.ok("退出成功");
+	}
+
+
+	 //获取用户的session用户信息
+	 // 从会话中获取用户ID并查询对应的员工信息
+	 // @param request HttpServletRequest对象，用于获取会话中的用户ID
+	 //@return R类型响应对象，包含查询到的员工信息。如果获取成功，返回带有员工数据的成功响应
+
+	@RequestMapping("/session")
+	public R getCurrUser(HttpServletRequest request) {
+		// 从会话中获取用户ID
+		Long id = (Long) request.getSession().getAttribute("userId");
+		// 根据用户ID查询员工实体
+		YuangongEntity user = yuangongService.selectById(id);
+		// 返回包含员工信息的成功响应
+		return R.ok().put("data", user);
+	}
+
+
+	 // 密码重置
+	 // 处理员工密码重置请求
+	 //@param username 员工工号，用于查询对应的员工信息
+	 //@param request HttpServletRequest对象
+	 // @return R类型响应对象，包含操作结果信息。如果员工存在，重置密码并返回成功响应；否则返回错误响应
+
+	@IgnoreAuth
+	@RequestMapping(value = "/resetPass")
+	public R resetPass(String username, HttpServletRequest request) {
+		// 根据员工工号查询员工实体
+		YuangongEntity user = yuangongService.selectOne(new EntityWrapper<YuangongEntity>().eq("yuangonggonghao", username));
+		// 检查员工是否存在
+		if (user == null) {
+			return R.error("账号不存在");
+		}
+		// 将员工密码重置为默认值"123456"
+		user.setMima("123456");
+		// 更新员工信息（密码）到数据库
+		yuangongService.updateById(user);
+		// 返回密码重置成功的响应
+		return R.ok("密码已重置为：123456");
+	}
+
+
+	 // 后端列表
+	 // 获取员工信息的分页列表（后端使用）
+	 // @param params 包含分页、排序等参数的Map对象
+	 // @param yuangong 用于构建查询条件的员工实体
+	 //@param request HttpServletRequest对象
+	 // @return R类型响应对象，包含分页后的员工信息数据。如果查询成功，返回带有分页数据的成功响应
+
+	@RequestMapping("/page")
+	public R page(@RequestParam Map<String, Object> params, YuangongEntity yuangong,
+				  HttpServletRequest request) {
+		// 创建用于构建查询条件的EntityWrapper对象
+		EntityWrapper<YuangongEntity> ew = new EntityWrapper<YuangongEntity>();
+		// 调用员工服务类的queryPage方法进行分页查询，MPUtil用于处理查询条件和排序
+		PageUtils page = yuangongService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yuangong), params), params));
+		// 返回包含分页数据的成功响应
+		return R.ok().put("data", page);
+	}
+
+
+	 // 前端列表
+	 // 获取员工信息的分页列表（前端使用），逻辑与后端列表类似
+	 //@param params 包含分页、排序等参数的Map对象
+	 // @param yuangong 用于构建查询条件的员工实体
+	 // @param request HttpServletRequest对象
+	 // @return R类型响应对象，包含分页后的员工信息数据。如果查询成功，返回带有分页数据的成功响应
+
+	@RequestMapping("/list")
+	public R list(@RequestParam Map<String, Object> params, YuangongEntity yuangong,
+				  HttpServletRequest request) {
+		// 创建用于构建查询条件的EntityWrapper对象
+		EntityWrapper<YuangongEntity> ew = new EntityWrapper<YuangongEntity>();
+		// 调用员工服务类的queryPage方法进行分页查询，MPUtil用于处理查询条件和排序
+		PageUtils page = yuangongService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yuangong), params), params));
+		// 返回包含分页数据的成功响应
+		return R.ok().put("data", page);
+	}
+
+
+	 // 列表
+	 // 根据员工实体的条件获取员工信息列表
+	 // @param yuangong 用于构建查询条件的员工实体
+	 //@return R类型响应对象，包含查询到的员工信息列表。如果查询成功，返回带有员工信息列表的成功响应
+
+	@RequestMapping("/lists")
+	public R list(YuangongEntity yuangong) {
+		// 创建用于构建查询条件的EntityWrapper对象
+		EntityWrapper<YuangongEntity> ew = new EntityWrapper<YuangongEntity>();
+		// 设置查询条件为所有属性等于员工实体的对应属性
+		ew.allEq(MPUtil.allEQMapPre(yuangong, "yuangong"));
+		// 调用员工服务类的selectListView方法获取员工信息列表
+		return R.ok().put("data", yuangongService.selectListView(ew));
+	}
+
+
+	 // 查询
+	 // 根据员工实体的条件查询员工视图信息
+	 //@param yuangong 用于构建查询条件的员工实体
+	 //@return R类型响应对象，包含查询到的员工视图信息。如果查询成功，返回带有员工视图数据的成功响应
+
+	@RequestMapping("/query")
+	public R query(YuangongEntity yuangong) {
+		// 创建用于构建查询条件的EntityWrapper对象
+		EntityWrapper<YuangongEntity> ew = new EntityWrapper<YuangongEntity>();
+		// 设置查询条件为所有属性等于员工实体的对应属性
+		ew.allEq(MPUtil.allEQMapPre(yuangong, "yuangong"));
+		// 调用员工服务类的selectView方法获取员工视图
+		YuangongView yuangongView = yuangongService.selectView(ew);
+		// 返回包含员工视图信息的成功响应
+		return R.ok("查询员工成功").put("data", yuangongView);
+	}
+
+
+	 //后端详情
+	 // 获取指定ID的员工详情信息（后端使用）
+	 // @param id 员工记录的ID
+	 // @return R类型响应对象，包含指定ID的员工信息。如果查询成功，返回带有员工数据的成功响应
+
+	@RequestMapping("/info/{id}")
+	public R info(@PathVariable("id") Long id) {
+		// 根据ID查询员工实体
+		YuangongEntity yuangong = yuangongService.selectById(id);
+		// 返回包含员工信息的成功响应
+		return R.ok().put("data", yuangong);
+	}
+
+
+	 // 前端详情
+	 //获取指定ID的员工详情信息（前端使用），逻辑与后端详情类似
+	 //@param id 员工记录的ID
+	 //@return R类型响应对象，包含指定ID的员工信息。如果查询成功，返回带有员工数据的成功响应
+
+	@RequestMapping("/detail/{id}")
+	public R detail(@PathVariable("id") Long id) {
+		// 根据ID查询员工实体
+		YuangongEntity yuangong = yuangongService.selectById(id);
+		// 返回包含员工信息的成功响应
+		return R.ok().put("data", yuangong);
+	}
+
+
+	 // 后端保存
+	 //保存新的员工信息（后端使用）
+	 //@param yuangong 包含员工信息的实体对象
+	 // @param request HttpServletRequest对象
+	 // @return R类型响应对象，包含操作结果信息。如果员工工号不存在冲突，保存员工信息并返回成功响应；否则返回错误响应
+
+	@RequestMapping("/save")
+	public R save(@RequestBody YuangongEntity yuangong, HttpServletRequest request) {
+		// 生成一个唯一的ID（由当前时间戳和随机数组成，后又改为仅当前时间戳）
+		yuangong.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+		// （注释掉的）验证员工实体的合法性
+		//ValidatorUtils.validateEntity(yuangong);
+		// 检查员工工号是否已存在
+		YuangongEntity user = yuangongService.selectOne(new EntityWrapper<YuangongEntity>().eq("yuangonggonghao", yuangong.getYuangonggonghao()));
+		if (user != null) {
+			return R.error("用户已存在");
+		}
+		// 重新设置ID为当前时间戳
+		yuangong.setId(new Date().getTime());
+		// 将员工信息插入数据库
+		yuangongService.insert(yuangong);
+		// 返回保存成功的响应
+		return R.ok();
+	}
+
+
+	 //前端保存
+	 // 保存新的员工信息（前端使用），逻辑与后端保存类似
+	//@param yuangong 包含员工信息的实体对象
+	 //@param request HttpServletRequest对象
+	 //@return R类型响应对象，包含操作结果信息。如果员工工号不存在冲突，保存员工信息并返回成功响应；否则返回错误响应
+
+	@RequestMapping("/add")
+	public R add(@RequestBody YuangongEntity yuangong, HttpServletRequest request) {
+		// 生成一个唯一的ID（由当前时间戳和随机数组成，后又改为仅当前时间戳）
+		yuangong.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+		// （注释掉的）验证员工实体的合法性
+		//ValidatorUtils.validateEntity(yuangong);
+		// 检查员工工号是否已存在
+		YuangongEntity user = yuangongService.selectOne(new EntityWrapper<YuangongEntity>().eq("yuangonggonghao", yuangong.getYuangonggonghao()));
+		if (user != null) {
+			return R.error("用户已存在");
+		}
+		// 重新设置ID为当前时间戳
+		yuangong.setId(new Date().getTime());
+		// 将员工信息插入数据库
+		yuangongService.insert(yuangong);
+		// 返回保存成功的响应
+		return R.ok();
+	}
+
+
+	 //修改
+	 // 修改员工信息
+	 // @param yuangong 包含修改后员工信息的实体对象
+	 //@param request HttpServletRequest对象
+	 //@return R类型响应对象，包含操作结果信息。如果修改成功，返回成功响应
+
+	@RequestMapping("/update")
+	public R update(@RequestBody YuangongEntity yuangong, HttpServletRequest request) {
+		// （注释掉的）验证员工实体的合法性
+		//ValidatorUtils.validateEntity(yuangong);
+		// 根据员工ID更新员工信息到数据库
+		yuangongService.updateById(yuangong);
+		// 返回修改成功的响应
+		return R.ok();
+	}
+
+
+	 // 删除
+	 // 批量删除员工信息
+	 // @param ids 要删除的员工记录的ID数组
+	 // @return R类型响应对象，包含操作结果信息。如果删除成功，返回成功响应
+
+	@RequestMapping("/delete")
+	public R delete(@RequestBody Long[] ids) {
+		// 调用员工服务类的deleteBatchIds方法批量删除员工信息
+		yuangongService.deleteBatchIds(Arrays.asList(ids));
+		// 返回删除成功的响应
+		return R.ok();
+	}
+
+
+	 // 提醒接口
+	 // 根据指定列和时间范围统计满足条件的员工记录数量
+	 //@param columnName 要统计的列名
+	 // @param request HttpServletRequest对象
+	// @param type 类型（例如"2"表示日期类型）
+	 // @param map 包含提醒开始时间、结束时间等参数的Map对象
+	 // @return R类型响应对象，包含统计的数量信息。如果统计成功，返回带有数量的成功响应
+
+	@RequestMapping("/remind/{columnName}/{type}")
+	public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
+						 @PathVariable("type") String type, @RequestParam Map<String, Object> map) {
+		// 将列名和类型信息放入参数Map中
+		map.put("column", columnName);
+		map.put("type", type);
+
+		// 如果类型是日期类型（"2"），处理日期相关逻辑
+		if (type.equals("2")) {
+			// 创建日期格式化对象
+			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+			// 获取日历实例
+			Calendar c = Calendar.getInstance();
+			Date remindStartDate = null;
+			Date remindEndDate = null;
+			// 如果存在提醒开始时间参数，计算并格式化开始日期
+			if (map.get("remindstart") != null) {
+				Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
+				c.setTime(new Date());
+				c.add(Calendar.DAY_OF_MONTH, remindStart);
+				remindStartDate = c.getTime();
+				map.put("remindstart", sdf.format(remindStartDate));
+			}
+			// 如果存在提醒结束时间参数，计算并格式化结束日期
+			if (map.get("remindend") != null) {
+				Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
+				c.setTime(new Date());
+				c.add(Calendar.DAY_OF_MONTH,remindEnd);
+				remindEndDate = c.getTime();
+				map.put("remindend", sdf.format(remindEndDate));
+			}
+		}
+
+		Wrapper<YuangongEntity> wrapper = new EntityWrapper<YuangongEntity>();
+		if(map.get("remindstart")!=null) {
+			wrapper.ge(columnName, map.get("remindstart"));
+		}
+		if(map.get("remindend")!=null) {
+			wrapper.le(columnName, map.get("remindend"));
+		}
+
+
+		int count = yuangongService.selectCount(wrapper);
+		return R.ok().put("count", count);
+	}
+
+
+
+}

src/main/java/com/controller/YuangongbaoxiaoController.java

@@ -0,0 +1,321 @@
+package com.controller;
+
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Date;
+import java.util.List;
+import javax.servlet.http.HttpServletRequest;
+
+import com.utils.ValidatorUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.format.annotation.DateTimeFormat;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import com.baomidou.mybatisplus.mapper.EntityWrapper;
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.annotation.IgnoreAuth;
+
+import com.entity.YuangongbaoxiaoEntity;
+import com.entity.view.YuangongbaoxiaoView;
+
+import com.service.YuangongbaoxiaoService;
+import com.service.TokenService;
+import com.utils.PageUtils;
+import com.utils.R;
+import com.utils.MD5Util;
+import com.utils.MPUtil;
+import com.utils.CommonUtil;
+
+
+ // 员工报销
+ // 后端接口
+ // @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+@RestController
+@RequestMapping("/yuangongbaoxiao")
+public class YuangongbaoxiaoController {
+    // 自动注入员工报销服务类的实例，用于处理员工报销相关业务逻辑
+    @Autowired
+    private YuangongbaoxiaoService yuangongbaoxiaoService;
+
+
+     // 后端列表
+     //该方法用于获取员工报销信息的分页列表（后端使用），支持根据员工报销实体和申请日期范围构建查询条件，
+     //并且根据会话中的 tableName 和 username 信息添加额外的查询条件
+     // @param params 请求参数，包含分页、排序等信息
+     // @param yuangongbaoxiao 员工报销实体，用于构建查询条件
+     //@param shenqingriqistart 申请日期开始时间，可选参数，格式为 yyyy-MM-dd
+     // @param shenqingriqiend 申请日期结束时间，可选参数，格式为 yyyy-MM-dd
+    //@param request HTTP 请求对象
+     // @return R 响应对象，包含操作结果和分页后的员工报销数据
+
+    @RequestMapping("/page")
+    public R page(@RequestParam Map<String, Object> params, YuangongbaoxiaoEntity yuangongbaoxiao,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date shenqingriqistart,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date shenqingriqiend,
+                  HttpServletRequest request) {
+        // 从会话中获取 tableName
+        String tableName = request.getSession().getAttribute("tableName").toString();
+        // 如果 tableName 是 "yuangong"，则设置员工报销实体的员工工号为会话中的 username
+        if (tableName.equals("yuangong")) {
+            yuangongbaoxiao.setYuangonggonghao((String) request.getSession().getAttribute("username"));
+        }
+        // 如果 tableName 是 "yuangongguanli"，则设置员工报销实体的管理工号为会话中的 username
+        if (tableName.equals("yuangongguanli")) {
+            yuangongbaoxiao.setGuanligonghao((String) request.getSession().getAttribute("username"));
+        }
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<YuangongbaoxiaoEntity> ew = new EntityWrapper<YuangongbaoxiaoEntity>();
+        // 如果申请日期开始时间不为空，添加大于等于该时间的查询条件
+        if (shenqingriqistart != null)
+            ew.ge("shenqingriqi", shenqingriqistart);
+        // 如果申请日期结束时间不为空，添加小于等于该时间的查询条件
+        if (shenqingriqiend != null)
+            ew.le("shenqingriqi", shenqingriqiend);
+        // 调用员工报销服务类的 queryPage 方法进行分页查询，MPUtil 用于处理排序和条件查询
+        PageUtils page = yuangongbaoxiaoService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yuangongbaoxiao), params), params));
+        // 返回成功响应，并将分页数据放入响应结果中
+        return R.ok().put("data", page);
+    }
+
+
+     // 前端列表
+     // 该方法用于获取员工报销信息的分页列表（前端使用），支持根据员工报销实体和申请日期范围构建查询条件
+     // @param params 请求参数，包含分页、排序等信息
+    // @param yuangongbaoxiao 员工报销实体，用于构建查询条件
+     // @param shenqingriqistart 申请日期开始时间，可选参数，格式为 yyyy-MM-dd
+     // @param shenqingriqiend 申请日期结束时间，可选参数，格式为 yyyy-MM-dd
+     // @param request HTTP 请求对象
+     // @return R 响应对象，包含操作结果和分页后的员工报销数据
+
+    @RequestMapping("/list")
+    public R list(@RequestParam Map<String, Object> params, YuangongbaoxiaoEntity yuangongbaoxiao,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date shenqingriqistart,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date shenqingriqiend,
+                  HttpServletRequest request) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<YuangongbaoxiaoEntity> ew = new EntityWrapper<YuangongbaoxiaoEntity>();
+        // 如果申请日期开始时间不为空，添加大于等于该时间的查询条件
+        if (shenqingriqistart != null)
+            ew.ge("shenqingriqi", shenqingriqistart);
+        // 如果申请日期结束时间不为空，添加小于等于该时间的查询条件
+        if (shenqingriqiend != null)
+            ew.le("shenqingriqi", shenqingriqiend);
+        // 调用员工报销服务类的 queryPage 方法进行分页查询，MPUtil 用于处理排序和条件查询
+        PageUtils page = yuangongbaoxiaoService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yuangongbaoxiao), params), params));
+        // 返回成功响应，并将分页数据放入响应结果中
+        return R.ok().put("data", page);
+    }
+
+
+     //列表
+     // 该方法用于获取满足特定条件的员工报销信息列表
+     //@param yuangongbaoxiao 员工报销实体，用于构建查询条件
+     // @return R 响应对象，包含操作结果和查询到的员工报销信息列表数据
+
+    @RequestMapping("/lists")
+    public R list(YuangongbaoxiaoEntity yuangongbaoxiao) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<YuangongbaoxiaoEntity> ew = new EntityWrapper<YuangongbaoxiaoEntity>();
+        // 设置查询条件，使所有字段相等
+        ew.allEq(MPUtil.allEQMapPre(yuangongbaoxiao, "yuangongbaoxiao"));
+        // 调用员工报销服务类的 selectListView 方法获取列表数据
+        return R.ok().put("data", yuangongbaoxiaoService.selectListView(ew));
+    }
+
+
+     // 查询
+     //该方法用于根据员工报销实体的条件查询单个员工报销视图
+     //@param yuangongbaoxiao 员工报销实体，用于构建查询条件
+     //@return R 响应对象，包含操作结果和查询到的员工报销视图数据
+
+    @RequestMapping("/query")
+    public R query(YuangongbaoxiaoEntity yuangongbaoxiao) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<YuangongbaoxiaoEntity> ew = new EntityWrapper<YuangongbaoxiaoEntity>();
+        // 设置查询条件，使所有字段相等
+        ew.allEq(MPUtil.allEQMapPre(yuangongbaoxiao, "yuangongbaoxiao"));
+        // 调用员工报销服务类的 selectView 方法获取员工报销视图
+        YuangongbaoxiaoView yuangongbaoxiaoView = yuangongbaoxiaoService.selectView(ew);
+        // 返回成功响应，并将查询结果放入响应结果中
+        return R.ok("查询员工报销成功").put("data", yuangongbaoxiaoView);
+    }
+
+
+     //后端详情
+     //该方法用于获取指定 ID 的员工报销详情（后端使用）
+     //@param id 员工报销记录的 ID
+     //@return R 响应对象，包含操作结果和指定 ID 的员工报销数据
+
+    @RequestMapping("/info/{id}")
+    public R info(@PathVariable("id") Long id) {
+        // 根据 ID 调用员工报销服务类的 selectById 方法获取员工报销实体
+        YuangongbaoxiaoEntity yuangongbaoxiao = yuangongbaoxiaoService.selectById(id);
+        // 返回成功响应，并将员工报销实体放入响应结果中
+        return R.ok().put("data", yuangongbaoxiao);
+    }
+
+
+     // 前端详情
+     //该方法用于获取指定 ID 的员工报销详情（前端使用）
+     //@param id 员工报销记录的 ID
+     // @return R 响应对象，包含操作结果和指定 ID 的员工报销数据
+
+    @RequestMapping("/detail/{id}")
+    public R detail(@PathVariable("id") Long id) {
+        // 根据 ID 调用员工报销服务类的 selectById 方法获取员工报销实体
+        YuangongbaoxiaoEntity yuangongbaoxiao = yuangongbaoxiaoService.selectById(id);
+        // 返回成功响应，并将员工报销实体放入响应结果中
+        return R.ok().put("data", yuangongbaoxiao);
+    }
+
+
+     //后端保存
+     //该方法用于在后端保存新的员工报销记录
+     //@param yuangongbaoxiao 要保存的员工报销实体
+     //@param request HTTP 请求对象
+    // @return R 响应对象，包含操作结果
+
+    @RequestMapping("/save")
+    public R save(@RequestBody YuangongbaoxiaoEntity yuangongbaoxiao, HttpServletRequest request) {
+        // 为员工报销实体设置一个唯一的 ID，由当前时间戳和随机数组成
+        yuangongbaoxiao.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(yuangongbaoxiao);
+        // 调用员工报销服务类的 insert 方法保存员工报销记录
+        yuangongbaoxiaoService.insert(yuangongbaoxiao);
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     //前端保存
+     //该方法用于在前端保存新的员工报销记录
+     //@param yuangongbaoxiao 要保存的员工报销实体
+     // @param request HTTP 请求对象
+     //@return R 响应对象，包含操作结果
+
+    @RequestMapping("/add")
+    public R add(@RequestBody YuangongbaoxiaoEntity yuangongbaoxiao, HttpServletRequest request) {
+        // 为员工报销实体设置一个唯一的 ID，由当前时间戳和随机数组成
+        yuangongbaoxiao.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(yuangongbaoxiao);
+        // 调用员工报销服务类的 insert 方法保存员工报销记录
+        yuangongbaoxiaoService.insert(yuangongbaoxiao);
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     //修改
+     // 该方法用于修改已有的员工报销记录
+    //@param yuangongbaoxiao 要修改的员工报销实体
+     // @param request HTTP 请求对象
+     //@return R 响应对象，包含操作结果
+
+    @RequestMapping("/update")
+    public R update(@RequestBody YuangongbaoxiaoEntity yuangongbaoxiao, HttpServletRequest request) {
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(yuangongbaoxiao);
+        // 调用员工报销服务类的 updateById 方法根据 ID 更新员工报销记录
+        yuangongbaoxiaoService.updateById(yuangongbaoxiao); // 全部更新
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     //删除
+     // 该方法用于批量删除指定 ID 的员工报销记录
+    //@param ids 要删除的员工报销记录的 ID 数组
+     //@return R 响应对象，包含操作结果
+
+    @RequestMapping("/delete")
+    public R delete(@RequestBody Long[] ids) {
+        // 调用员工报销服务类的 deleteBatchIds 方法批量删除员工报销记录
+        yuangongbaoxiaoService.deleteBatchIds(Arrays.asList(ids));
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     //提醒接口
+     //该方法用于根据指定列和时间范围统计满足条件的员工报销记录数量，
+    // 并且根据会话中的 tableName 和 username 信息添加额外的查询条件
+     //@param columnName 要统计的列名
+     //@param request HTTP 请求对象
+     //@param type 类型，1 表示数字，2 表示日期
+    // @param map 请求参数，包含提醒开始时间和结束时间等信息
+     // @return R 响应对象，包含操作结果和统计的数量
+
+    @RequestMapping("/remind/{columnName}/{type}")
+    public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
+                         @PathVariable("type") String type, @RequestParam Map<String, Object> map) {
+        // 将列名、类型等信息放入请求参数中
+        map.put("column", columnName);
+        map.put("type", type);
+
+        // 如果类型为日期（2），则进行日期相关的处理
+        if (type.equals("2")) {
+            // 创建日期格式化对象
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+            // 获取日历实例
+            Calendar c = Calendar.getInstance();
+            Date remindStartDate = null;
+            Date remindEndDate = null;
+            // 如果存在提醒开始时间参数，则进行计算和格式化
+            if (map.get("remindstart") != null) {
+                Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
+                c.setTime(new Date());
+                c.add(Calendar.DAY_OF_MONTH, remindStart);
+                remindStartDate = c.getTime();
+                map.put("remindstart", sdf.format(remindStartDate));
+            }
+            // 如果存在提醒结束时间参数，则进行计算和格式化
+            if (map.get("remindend") != null) {
+                Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
+                c.setTime(new Date());
+                c.add(Calendar.DAY_OF_MONTH, remindEnd);
+                remindEndDate = c.getTime();
+                map.put("remindend", sdf.format(remindEndDate));
+            }
+        }
+
+        // 创建一个包装器，用于构建 SQL 查询条件
+        Wrapper<YuangongbaoxiaoEntity> wrapper = new EntityWrapper<YuangongbaoxiaoEntity>();
+        // 根据提醒开始时间和结束时间设置查询条件
+        if (map.get("remindstart") != null) {
+            wrapper.ge(columnName, map.get("remindstart"));
+        }
+        if (map.get("remindend") != null) {
+            wrapper.le(columnName, map.get("remindend"));
+        }
+
+        // 从会话中获取 tableName
+        String tableName = request.getSession().getAttribute("tableName").toString();
+        // 如果 tableName 是 "yuangong"，则添加员工工号等于会话中 username 的查询条件
+        if (tableName.equals("yuangong")) {
+            wrapper.eq("yuangonggonghao", (String) request.getSession().getAttribute("username"));
+        }
+        // 如果 tableName 是 "yuangongguanli"，则添加管理工号等于会话中 username 的查询条件
+        if (tableName.equals("yuangongguanli")) {
+            wrapper.eq("guanligonghao", (String) request.getSession().getAttribute("username"));
+        }
+
+        // 调用员工报销服务类的 selectCount 方法统计满足条件的数量
+        int count = yuangongbaoxiaoService.selectCount(wrapper);
+        // 返回成功响应，并将统计数量放入响应结果中
+        return R.ok().put("count", count);
+    }
+}

src/main/java/com/controller/YuangongjiaokuanController.java

@@ -0,0 +1,320 @@
+package com.controller;
+
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Date;
+import java.util.List;
+import javax.servlet.http.HttpServletRequest;
+
+import com.utils.ValidatorUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.format.annotation.DateTimeFormat;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import com.baomidou.mybatisplus.mapper.EntityWrapper;
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.annotation.IgnoreAuth;
+
+import com.entity.YuangongjiaokuanEntity;
+import com.entity.view.YuangongjiaokuanView;
+
+import com.service.YuangongjiaokuanService;
+import com.service.TokenService;
+import com.utils.PageUtils;
+import com.utils.R;
+import com.utils.MD5Util;
+import com.utils.MPUtil;
+import com.utils.CommonUtil;
+
+
+// 员工缴款
+// 后端接口
+// @author
+ // @email
+// @date 2021-04-24 15:19:31
+
+@RestController
+@RequestMapping("/yuangongjiaokuan")
+public class YuangongjiaokuanController {
+    // 自动注入员工缴款服务类，用于处理员工缴款相关的业务逻辑
+    @Autowired
+    private YuangongjiaokuanService yuangongjiaokuanService;
+
+
+    // 后端列表
+     // 获取员工缴款信息的分页列表（后端使用）
+     // @param params 包含分页、排序等参数的Map对象
+     //@param yuangongjiaokuan 用于构建查询条件的员工缴款实体
+     // @param jiaokuanriqistart 缴款日期的起始时间，可选参数
+     // @param jiaokuanriqiend 缴款日期的结束时间，可选参数
+    // @param request HttpServletRequest对象，用于获取会话信息
+     //@return R类型响应对象，包含分页后的员工缴款信息数据。如果查询成功，返回带有分页数据的成功响应
+
+    @RequestMapping("/page")
+    public R page(@RequestParam Map<String, Object> params, YuangongjiaokuanEntity yuangongjiaokuan,
+                  @RequestParam(required = false) @DateTimeFormat(pattern="yyyy-MM-dd") Date jiaokuanriqistart,
+                  @RequestParam(required = false) @DateTimeFormat(pattern="yyyy-MM-dd") Date jiaokuanriqiend,
+                  HttpServletRequest request) {
+        // 从会话中获取表名
+        String tableName = request.getSession().getAttribute("tableName").toString();
+        // 如果当前用户是员工，设置查询条件为该员工的工号
+        if (tableName.equals("yuangong")) {
+            yuangongjiaokuan.setYuangonggonghao((String)request.getSession().getAttribute("username"));
+        }
+        // 如果当前用户是员工管理，设置查询条件为该管理员的工号
+        if (tableName.equals("yuangongguanli")) {
+            yuangongjiaokuan.setGuanligonghao((String)request.getSession().getAttribute("username"));
+        }
+        // 创建用于构建查询条件的EntityWrapper对象
+        EntityWrapper<YuangongjiaokuanEntity> ew = new EntityWrapper<YuangongjiaokuanEntity>();
+        // 如果指定了缴款日期的起始时间，添加大于等于该时间的查询条件
+        if (jiaokuanriqistart != null) {
+            ew.ge("jiaokuanriqi", jiaokuanriqistart);
+        }
+        // 如果指定了缴款日期的结束时间，添加小于等于该时间的查询条件
+        if (jiaokuanriqiend != null) {
+            ew.le("jiaokuanriqi", jiaokuanriqiend);
+        }
+        // 调用员工缴款服务类的queryPage方法进行分页查询，MPUtil用于处理查询条件和排序
+        PageUtils page = yuangongjiaokuanService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yuangongjiaokuan), params), params));
+        // 返回包含分页数据的成功响应
+        return R.ok().put("data", page);
+    }
+
+
+     //前端列表
+     //获取员工缴款信息的分页列表（前端使用）
+     //@param params 包含分页、排序等参数的Map对象
+     // @param yuangongjiaokuan 用于构建查询条件的员工缴款实体
+     // @param jiaokuanriqistart 缴款日期的起始时间，可选参数
+     // @param jiaokuanriqiend 缴款日期的结束时间，可选参数
+    //@param request HttpServletRequest对象
+   // @return R类型响应对象，包含分页后的员工缴款信息数据。如果查询成功，返回带有分页数据的成功响应
+
+    @RequestMapping("/list")
+    public R list(@RequestParam Map<String, Object> params, YuangongjiaokuanEntity yuangongjiaokuan,
+                  @RequestParam(required = false) @DateTimeFormat(pattern="yyyy-MM-dd") Date jiaokuanriqistart,
+                  @RequestParam(required = false) @DateTimeFormat(pattern="yyyy-MM-dd") Date jiaokuanriqiend,
+                  HttpServletRequest request) {
+        // 创建用于构建查询条件的EntityWrapper对象
+        EntityWrapper<YuangongjiaokuanEntity> ew = new EntityWrapper<YuangongjiaokuanEntity>();
+        // 如果指定了缴款日期的起始时间，添加大于等于该时间的查询条件
+        if (jiaokuanriqistart != null) {
+            ew.ge("jiaokuanriqi", jiaokuanriqistart);
+        }
+        // 如果指定了缴款日期的结束时间，添加小于等于该时间的查询条件
+        if (jiaokuanriqiend != null) {
+            ew.le("jiaokuanriqi", jiaokuanriqiend);
+        }
+        // 调用员工缴款服务类的queryPage方法进行分页查询，MPUtil用于处理查询条件和排序
+        PageUtils page = yuangongjiaokuanService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yuangongjiaokuan), params), params));
+        // 返回包含分页数据的成功响应
+        return R.ok().put("data", page);
+    }
+
+
+     //列表
+     // 根据员工缴款实体的条件获取员工缴款信息列表
+     //@param yuangongjiaokuan 用于构建查询条件的员工缴款实体
+     //@return R类型响应对象，包含查询到的员工缴款信息列表。如果查询成功，返回带有员工缴款信息列表的成功响应
+
+    @RequestMapping("/lists")
+    public R list(YuangongjiaokuanEntity yuangongjiaokuan) {
+        // 创建用于构建查询条件的EntityWrapper对象
+        EntityWrapper<YuangongjiaokuanEntity> ew = new EntityWrapper<YuangongjiaokuanEntity>();
+        // 设置查询条件为所有属性等于员工缴款实体的对应属性
+        ew.allEq(MPUtil.allEQMapPre(yuangongjiaokuan, "yuangongjiaokuan"));
+        // 调用员工缴款服务类的selectListView方法获取员工缴款信息列表
+        return R.ok().put("data", yuangongjiaokuanService.selectListView(ew));
+    }
+
+
+     // 查询
+     // 根据员工缴款实体的条件查询员工缴款视图信息
+     // @param yuangongjiaokuan 用于构建查询条件的员工缴款实体
+     //@return R类型响应对象，包含查询到的员工缴款视图信息。如果查询成功，返回带有员工缴款视图数据的成功响应
+
+    @RequestMapping("/query")
+    public R query(YuangongjiaokuanEntity yuangongjiaokuan) {
+        // 创建用于构建查询条件的EntityWrapper对象
+        EntityWrapper<YuangongjiaokuanEntity> ew = new EntityWrapper<YuangongjiaokuanEntity>();
+        // 设置查询条件为所有属性等于员工缴款实体的对应属性
+        ew.allEq(MPUtil.allEQMapPre(yuangongjiaokuan, "yuangongjiaokuan"));
+        // 调用员工缴款服务类的selectView方法获取员工缴款视图
+        YuangongjiaokuanView yuangongjiaokuanView = yuangongjiaokuanService.selectView(ew);
+        // 返回包含员工缴款视图信息的成功响应
+        return R.ok("查询员工缴款成功").put("data", yuangongjiaokuanView);
+    }
+
+
+     //后端详情
+     //获取指定ID的员工缴款详情信息（后端使用）
+     // @param id 员工缴款记录的ID
+     // @return R类型响应对象，包含指定ID的员工缴款信息。如果查询成功，返回带有员工缴款数据的成功响应
+
+    @RequestMapping("/info/{id}")
+    public R info(@PathVariable("id") Long id) {
+        // 根据ID查询员工缴款实体
+        YuangongjiaokuanEntity yuangongjiaokuan = yuangongjiaokuanService.selectById(id);
+        // 返回包含员工缴款信息的成功响应
+        return R.ok().put("data", yuangongjiaokuan);
+    }
+
+
+     //前端详情
+     //获取指定ID的员工缴款详情信息（前端使用）
+     //@param id 员工缴款记录的ID
+     // @return R类型响应对象，包含指定ID的员工缴款信息。如果查询成功，返回带有员工缴款数据的成功响应
+
+    @RequestMapping("/detail/{id}")
+    public R detail(@PathVariable("id") Long id) {
+        // 根据ID查询员工缴款实体
+        YuangongjiaokuanEntity yuangongjiaokuan = yuangongjiaokuanService.selectById(id);
+        // 返回包含员工缴款信息的成功响应
+        return R.ok().put("data", yuangongjiaokuan);
+    }
+
+
+     //后端保存
+     //保存新的员工缴款信息（后端使用）
+     // @param yuangongjiaokuan 包含员工缴款信息的实体对象
+     //@param request HttpServletRequest对象
+     // @return R类型响应对象，包含操作结果信息。如果保存成功，返回成功响应
+
+    @RequestMapping("/save")
+    public R save(@RequestBody YuangongjiaokuanEntity yuangongjiaokuan, HttpServletRequest request) {
+        // 生成一个唯一的ID，由当前时间戳和一个随机数组成
+        yuangongjiaokuan.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // （注释掉的）验证员工缴款实体的合法性
+        //ValidatorUtils.validateEntity(yuangongjiaokuan);
+        // 将员工缴款信息插入数据库
+        yuangongjiaokuanService.insert(yuangongjiaokuan);
+        // 返回保存成功的响应
+        return R.ok();
+    }
+
+
+     // 前端保存
+     // 保存新的员工缴款信息（前端使用）
+     // @param yuangongjiaokuan 包含员工缴款信息的实体对象
+     // @param request HttpServletRequest对象
+     //@return R类型响应对象，包含操作结果信息。如果保存成功，返回成功响应
+
+    @RequestMapping("/add")
+    public R add(@RequestBody YuangongjiaokuanEntity yuangongjiaokuan, HttpServletRequest request) {
+        // 生成一个唯一的ID，由当前时间戳和一个随机数组成
+        yuangongjiaokuan.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // （注释掉的）验证员工缴款实体的合法性
+        //ValidatorUtils.validateEntity(yuangongjiaokuan);
+        // 将员工缴款信息插入数据库
+        yuangongjiaokuanService.insert(yuangongjiaokuan);
+        // 返回保存成功的响应
+        return R.ok();
+    }
+
+
+     //修改
+     // 修改员工缴款信息
+     // @param yuangongjiaokuan 包含修改后员工缴款信息的实体对象
+     // @param request HttpServletRequest对象
+     //@return R类型响应对象，包含操作结果信息。如果修改成功，返回成功响应
+
+    @RequestMapping("/update")
+    public R update(@RequestBody YuangongjiaokuanEntity yuangongjiaokuan, HttpServletRequest request) {
+        // （注释掉的）验证员工缴款实体的合法性
+        //ValidatorUtils.validateEntity(yuangongjiaokuan);
+        // 根据员工缴款ID更新员工缴款信息到数据库
+        yuangongjiaokuanService.updateById(yuangongjiaokuan);
+        // 返回修改成功的响应
+        return R.ok();
+    }
+
+
+     // 删除
+     //批量删除员工缴款信息
+     //@param ids 要删除的员工缴款记录的ID数组
+     //@return R类型响应对象，包含操作结果信息。如果删除成功，返回成功响应
+
+    @RequestMapping("/delete")
+    public R delete(@RequestBody Long[] ids) {
+        // 调用员工缴款服务类的deleteBatchIds方法批量删除员工缴款信息
+        yuangongjiaokuanService.deleteBatchIds(Arrays.asList(ids));
+        // 返回删除成功的响应
+        return R.ok();
+    }
+
+
+     // 提醒接口
+     //根据指定列和时间范围统计满足条件的员工缴款记录数量
+     //@param columnName 要统计的列名
+     //@param request HttpServletRequest对象
+     // @param type 类型（例如"2"表示日期类型）
+     // @param map 包含提醒开始时间、结束时间等参数的Map对象
+     //@return R类型响应对象，包含统计的数量信息。如果统计成功，返回带有数量的成功响应
+
+    @RequestMapping("/remind/{columnName}/{type}")
+    public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
+                         @PathVariable("type") String type, @RequestParam Map<String, Object> map) {
+        // 将列名和类型信息放入参数Map中
+        map.put("column", columnName);
+        map.put("type", type);
+        // 如果类型是日期类型（"2"），处理日期相关逻辑
+        if (type.equals("2")) {
+            // 创建日期格式化对象
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+            // 获取日历实例
+            Calendar c = Calendar.getInstance();
+            Date remindStartDate = null;
+            Date remindEndDate = null;
+            // 如果存在提醒开始时间参数，计算并格式化开始日期
+            if (map.get("remindstart") != null) {
+                Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
+                c.setTime(new Date());
+                c.add(Calendar.DAY_OF_MONTH, remindStart);
+                remindStartDate = c.getTime();
+                map.put("remindstart", sdf.format(remindStartDate));
+            }
+            // 如果存在提醒结束时间参数，计算并格式化结束日期
+            if (map.get("remindend") != null) {
+                Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
+                c.setTime(new Date());
+                c.add(Calendar.DAY_OF_MONTH, remindEnd);
+                remindEndDate = c.getTime();
+                map.put("remindend", sdf.format(remindEndDate));
+            }
+        }
+        // 创建用于构建查询条件的Wrapper对象
+        Wrapper<YuangongjiaokuanEntity> wrapper = new EntityWrapper<YuangongjiaokuanEntity>();
+        // 如果存在提醒开始时间，添加大于等于该时间的查询条件
+        if (map.get("remindstart") != null) {
+            wrapper.ge(columnName, map.get("remindstart"));
+        }
+        // 如果存在提醒结束时间，添加小于等于该时间的查询条件
+        if (map.get("remindend") != null) {
+            wrapper.le(columnName, map.get("remindend"));
+        }
+        // 从会话中获取表名
+        String tableName = request.getSession().getAttribute("tableName").toString();
+        // 如果当前用户是员工，添加员工工号的查询条件
+        if (tableName.equals("yuangong")) {
+            wrapper.eq("yuangonggonghao", (String)request.getSession().getAttribute("username"));
+        }
+        // 如果当前用户是员工管理，添加管理员工号的查询条件
+        if (tableName.equals("yuangongguanli")) {
+            wrapper.eq("guanligonghao", (String)request.getSession().getAttribute("username"));
+        }
+        // 调用员工缴款服务类的selectCount方法统计满足条件的记录数量
+        int count = yuangongjiaokuanService.selectCount(wrapper);
+        // 返回包含统计数量的成功响应
+        return R.ok().put("count", count);
+    }
+}

src/main/java/com/controller/YuangongxinchouController.java

@@ -0,0 +1,320 @@
+package com.controller;
+
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Date;
+import java.util.List;
+import javax.servlet.http.HttpServletRequest;
+
+import com.utils.ValidatorUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.format.annotation.DateTimeFormat;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import com.baomidou.mybatisplus.mapper.EntityWrapper;
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.annotation.IgnoreAuth;
+
+import com.entity.YuangongxinchouEntity;
+import com.entity.view.YuangongxinchouView;
+
+import com.service.YuangongxinchouService;
+import com.service.TokenService;
+import com.utils.PageUtils;
+import com.utils.R;
+import com.utils.MD5Util;
+import com.utils.MPUtil;
+import com.utils.CommonUtil;
+
+
+ // 员工薪酬
+ //后端接口
+ // @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+@RestController
+@RequestMapping("/yuangongxinchou")
+public class YuangongxinchouController {
+    // 自动注入员工薪酬服务类，用于处理员工薪酬相关的业务逻辑
+    @Autowired
+    private YuangongxinchouService yuangongxinchouService;
+
+
+     //后端列表
+     //该方法用于获取员工薪酬信息的分页列表，供后端使用。
+     //@param params 包含分页、排序等查询参数的Map对象
+     // @param yuangongxinchou 用于构建查询条件的员工薪酬实体对象
+     // @param riqistart 日期范围的起始日期，可选参数
+     // @param riqiend 日期范围的结束日期，可选参数
+     // @param request HttpServletRequest对象，用于获取会话信息
+     // @return R类型的响应对象，包含分页后的员工薪酬信息数据
+
+    @RequestMapping("/page")
+    public R page(@RequestParam Map<String, Object> params, YuangongxinchouEntity yuangongxinchou,
+                  @RequestParam(required = false) @DateTimeFormat(pattern="yyyy-MM-dd") Date riqistart,
+                  @RequestParam(required = false) @DateTimeFormat(pattern="yyyy-MM-dd") Date riqiend,
+                  HttpServletRequest request) {
+        // 从会话中获取当前用户所属的表名
+        String tableName = request.getSession().getAttribute("tableName").toString();
+        // 如果当前用户是员工，将员工工号设置到查询条件中
+        if (tableName.equals("yuangong")) {
+            yuangongxinchou.setYuangonggonghao((String)request.getSession().getAttribute("username"));
+        }
+        // 如果当前用户是员工管理，将管理员工号设置到查询条件中
+        if (tableName.equals("yuangongguanli")) {
+            yuangongxinchou.setGuanligonghao((String)request.getSession().getAttribute("username"));
+        }
+        // 创建EntityWrapper对象，用于构建SQL查询条件
+        EntityWrapper<YuangongxinchouEntity> ew = new EntityWrapper<YuangongxinchouEntity>();
+        // 如果传入了起始日期，添加大于等于该日期的查询条件
+        if (riqistart != null) {
+            ew.ge("riqi", riqistart);
+        }
+        // 如果传入了结束日期，添加小于等于该日期的查询条件
+        if (riqiend != null) {
+            ew.le("riqi", riqiend);
+        }
+        // 调用服务层的queryPage方法进行分页查询，MPUtil用于处理排序和范围查询
+        PageUtils page = yuangongxinchouService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yuangongxinchou), params), params));
+        // 返回包含分页数据的成功响应
+        return R.ok().put("data", page);
+    }
+
+
+     // 前端列表
+     //该方法用于获取员工薪酬信息的分页列表，供前端使用。
+     // @param params 包含分页、排序等查询参数的Map对象
+     // @param yuangongxinchou 用于构建查询条件的员工薪酬实体对象
+     // @param riqistart 日期范围的起始日期，可选参数
+     // @param riqiend 日期范围的结束日期，可选参数
+     // @param request HttpServletRequest对象
+     // @return R类型的响应对象，包含分页后的员工薪酬信息数据
+
+    @RequestMapping("/list")
+    public R list(@RequestParam Map<String, Object> params, YuangongxinchouEntity yuangongxinchou,
+                  @RequestParam(required = false) @DateTimeFormat(pattern="yyyy-MM-dd") Date riqistart,
+                  @RequestParam(required = false) @DateTimeFormat(pattern="yyyy-MM-dd") Date riqiend,
+                  HttpServletRequest request) {
+        // 创建EntityWrapper对象，用于构建SQL查询条件
+        EntityWrapper<YuangongxinchouEntity> ew = new EntityWrapper<YuangongxinchouEntity>();
+        // 如果传入了起始日期，添加大于等于该日期的查询条件
+        if (riqistart != null) {
+            ew.ge("riqi", riqistart);
+        }
+        // 如果传入了结束日期，添加小于等于该日期的查询条件
+        if (riqiend != null) {
+            ew.le("riqi", riqiend);
+        }
+        // 调用服务层的queryPage方法进行分页查询，MPUtil用于处理排序和范围查询
+        PageUtils page = yuangongxinchouService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yuangongxinchou), params), params));
+        // 返回包含分页数据的成功响应
+        return R.ok().put("data", page);
+    }
+
+
+     //列表
+     // 根据员工薪酬实体对象构建的条件，获取员工薪酬信息列表。
+     // @param yuangongxinchou 用于构建查询条件的员工薪酬实体对象
+     // @return R类型的响应对象，包含查询到的员工薪酬信息列表
+
+    @RequestMapping("/lists")
+    public R list(YuangongxinchouEntity yuangongxinchou) {
+        // 创建EntityWrapper对象，用于构建SQL查询条件
+        EntityWrapper<YuangongxinchouEntity> ew = new EntityWrapper<YuangongxinchouEntity>();
+        // 设置查询条件为实体对象中所有属性值相等
+        ew.allEq(MPUtil.allEQMapPre(yuangongxinchou, "yuangongxinchou"));
+        // 调用服务层的selectListView方法查询员工薪酬信息列表
+        return R.ok().put("data", yuangongxinchouService.selectListView(ew));
+    }
+
+
+     // 查询
+     // 根据员工薪酬实体对象构建的条件，查询员工薪酬视图信息。
+     //@param yuangongxinchou 用于构建查询条件的员工薪酬实体对象
+     // @return R类型的响应对象，包含查询到的员工薪酬视图信息
+
+    @RequestMapping("/query")
+    public R query(YuangongxinchouEntity yuangongxinchou) {
+        // 创建EntityWrapper对象，用于构建SQL查询条件
+        EntityWrapper<YuangongxinchouEntity> ew = new EntityWrapper<YuangongxinchouEntity>();
+        // 设置查询条件为实体对象中所有属性值相等
+        ew.allEq(MPUtil.allEQMapPre(yuangongxinchou, "yuangongxinchou"));
+        // 调用服务层的selectView方法查询员工薪酬视图信息
+        YuangongxinchouView yuangongxinchouView = yuangongxinchouService.selectView(ew);
+        // 返回包含查询结果的成功响应
+        return R.ok("查询员工薪酬成功").put("data", yuangongxinchouView);
+    }
+
+
+     //后端详情
+     // 根据员工薪酬记录的ID，获取该记录的详细信息，供后端使用。
+     // @param id 员工薪酬记录的ID
+     //@return R类型的响应对象，包含查询到的员工薪酬详细信息
+
+    @RequestMapping("/info/{id}")
+    public R info(@PathVariable("id") Long id) {
+        // 调用服务层的selectById方法根据ID查询员工薪酬实体对象
+        YuangongxinchouEntity yuangongxinchou = yuangongxinchouService.selectById(id);
+        // 返回包含详细信息的成功响应
+        return R.ok().put("data", yuangongxinchou);
+    }
+
+
+     //前端详情
+     //根据员工薪酬记录的ID，获取该记录的详细信息，供前端使用。
+     //@param id 员工薪酬记录的ID
+     //@return R类型的响应对象，包含查询到的员工薪酬详细信息
+
+    @RequestMapping("/detail/{id}")
+    public R detail(@PathVariable("id") Long id) {
+        // 调用服务层的selectById方法根据ID查询员工薪酬实体对象
+        YuangongxinchouEntity yuangongxinchou = yuangongxinchouService.selectById(id);
+        // 返回包含详细信息的成功响应
+        return R.ok().put("data", yuangongxinchou);
+    }
+
+
+     // 后端保存
+     // 保存新的员工薪酬信息，供后端使用。
+     //@param yuangongxinchou 包含员工薪酬信息的实体对象
+     //@param request HttpServletRequest对象
+     //@return R类型的响应对象，包含保存操作的结果信息
+
+    @RequestMapping("/save")
+    public R save(@RequestBody YuangongxinchouEntity yuangongxinchou, HttpServletRequest request) {
+        // 为员工薪酬记录生成一个唯一的ID，由当前时间戳和一个随机数组成
+        yuangongxinchou.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // （注释掉的）验证实体对象的合法性
+        //ValidatorUtils.validateEntity(yuangongxinchou);
+        // 调用服务层的insert方法将员工薪酬信息插入数据库
+        yuangongxinchouService.insert(yuangongxinchou);
+        // 返回保存成功的响应
+        return R.ok();
+    }
+
+
+     // 前端保存
+     //保存新的员工薪酬信息，供前端使用。
+    // @param yuangongxinchou 包含员工薪酬信息的实体对象
+     //@param request HttpServletRequest对象
+     // @return R类型的响应对象，包含保存操作的结果信息
+
+    @RequestMapping("/add")
+    public R add(@RequestBody YuangongxinchouEntity yuangongxinchou, HttpServletRequest request) {
+        // 为员工薪酬记录生成一个唯一的ID，由当前时间戳和一个随机数组成
+        yuangongxinchou.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // （注释掉的）验证实体对象的合法性
+        //ValidatorUtils.validateEntity(yuangongxinchou);
+        // 调用服务层的insert方法将员工薪酬信息插入数据库
+        yuangongxinchouService.insert(yuangongxinchou);
+        // 返回保存成功的响应
+        return R.ok();
+    }
+
+
+     //修改
+     // 修改已有的员工薪酬信息。
+     // @param yuangongxinchou 包含修改后员工薪酬信息的实体对象
+     // @param request HttpServletRequest对象
+     // @return R类型的响应对象，包含修改操作的结果信息
+
+    @RequestMapping("/update")
+    public R update(@RequestBody YuangongxinchouEntity yuangongxinchou, HttpServletRequest request) {
+        // （注释掉的）验证实体对象的合法性
+        //ValidatorUtils.validateEntity(yuangongxinchou);
+        // 调用服务层的updateById方法根据ID更新员工薪酬信息
+        yuangongxinchouService.updateById(yuangongxinchou);
+        // 返回修改成功的响应
+        return R.ok();
+    }
+
+
+     //删除
+     //批量删除员工薪酬信息。
+     // @param ids 要删除的员工薪酬记录的ID数组
+     // @return R类型的响应对象，包含删除操作的结果信息
+
+    @RequestMapping("/delete")
+    public R delete(@RequestBody Long[] ids) {
+        // 调用服务层的deleteBatchIds方法批量删除指定ID的员工薪酬记录
+        yuangongxinchouService.deleteBatchIds(Arrays.asList(ids));
+        // 返回删除成功的响应
+        return R.ok();
+    }
+
+
+     //提醒接口
+     // 根据指定的列名和日期范围，统计满足条件的员工薪酬记录数量。
+     // @param columnName 要统计的列名
+     // @param request HttpServletRequest对象
+     // @param type 日期范围类型，"2"表示需要处理日期范围
+     // @param map 包含提醒开始日期和结束日期等参数的Map对象
+     // @return R类型的响应对象，包含统计的记录数量信息
+
+    @RequestMapping("/remind/{columnName}/{type}")
+    public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
+                         @PathVariable("type") String type, @RequestParam Map<String, Object> map) {
+        // 将列名和类型信息放入参数Map中
+        map.put("column", columnName);
+        map.put("type", type);
+        // 如果类型为"2"，处理日期范围逻辑
+        if (type.equals("2")) {
+            // 创建日期格式化对象
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+            // 获取日历实例
+            Calendar c = Calendar.getInstance();
+            Date remindStartDate = null;
+            Date remindEndDate = null;
+            // 如果传入了提醒开始日期的偏移量，计算并格式化开始日期
+            if (map.get("remindstart") != null) {
+                Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
+                c.setTime(new Date());
+                c.add(Calendar.DAY_OF_MONTH, remindStart);
+                remindStartDate = c.getTime();
+                map.put("remindstart", sdf.format(remindStartDate));
+            }
+            // 如果传入了提醒结束日期的偏移量，计算并格式化结束日期
+            if (map.get("remindend") != null) {
+                Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
+                c.setTime(new Date());
+                c.add(Calendar.DAY_OF_MONTH, remindEnd);
+                remindEndDate = c.getTime();
+                map.put("remindend", sdf.format(remindEndDate));
+            }
+        }
+        // 创建Wrapper对象，用于构建SQL查询条件
+        Wrapper<YuangongxinchouEntity> wrapper = new EntityWrapper<YuangongxinchouEntity>();
+        // 如果传入了提醒开始日期，添加大于等于该日期的查询条件
+        if (map.get("remindstart") != null) {
+            wrapper.ge(columnName, map.get("remindstart"));
+        }
+        // 如果传入了提醒结束日期，添加小于等于该日期的查询条件
+        if (map.get("remindend") != null) {
+            wrapper.le(columnName, map.get("remindend"));
+        }
+        // 从会话中获取当前用户所属的表名
+        String tableName = request.getSession().getAttribute("tableName").toString();
+        // 如果当前用户是员工，添加员工工号的查询条件
+        if (tableName.equals("yuangong")) {
+            wrapper.eq("yuangonggonghao", (String)request.getSession().getAttribute("username"));
+        }
+        // 如果当前用户是员工管理，添加管理员工号的查询条件
+        if (tableName.equals("yuangongguanli")) {
+            wrapper.eq("guanligonghao", (String)request.getSession().getAttribute("username"));
+        }
+        // 调用服务层的selectCount方法统计满足条件的记录数量
+        int count = yuangongxinchouService.selectCount(wrapper);
+        // 返回包含统计数量的成功响应
+        return R.ok().put("count", count);
+    }
+}

src/main/java/com/dao/ChengbenjieyuDao.java

@@ -0,0 +1,61 @@
+package com.dao;
+
+import com.entity.ChengbenjieyuEntity;
+import com.baomidou.mybatisplus.mapper.BaseMapper;
+import java.util.List;
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.plugins.pagination.Pagination;
+import org.apache.ibatis.annotations.Param;
+import com.entity.vo.ChengbenjieyuVO;
+import com.entity.view.ChengbenjieyuView;
+
+
+ // 成本结余数据访问接口，继承自MyBatis-Plus的BaseMapper接口，用于对成本结余实体进行数据库操作。
+ // 除了BaseMapper提供的基本CRUD操作外，该接口还定义了一些自定义的查询方法。
+ // @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+public interface ChengbenjieyuDao extends BaseMapper<ChengbenjieyuEntity> {
+
+
+	 //根据查询条件包装器查询成本结余值对象（VO）列表。
+	 // 值对象（VO）通常是为了特定业务场景而封装的，可能包含实体类的部分属性或经过处理后的属性。
+	 //@param wrapper 查询条件包装器，用于筛选符合条件的成本结余数据。
+	// @param ("ew ")使用@Param注解指定参数名称为"ew"，方便在SQL映射文件中引用该参数。
+	// @return 符合条件的成本结余值对象（VO）列表。
+
+	List<ChengbenjieyuVO> selectListVO(@Param("ew") Wrapper<ChengbenjieyuEntity> wrapper);
+
+
+	 // 根据查询条件包装器查询单个成本结余值对象（VO）。
+	 //@param wrapper 查询条件包装器，用于精确筛选出一个成本结余数据。
+	 // @param ("ew") 使用@Param注解指定参数名称为"ew"，方便在SQL映射文件中引用该参数。
+	 // @return 符合条件的单个成本结余值对象（VO），若未找到则返回 null。
+	ChengbenjieyuVO selectVO(@Param("ew") Wrapper<ChengbenjieyuEntity> wrapper);
+
+
+	 // 根据查询条件包装器查询成本结余视图列表。
+	 // 视图（View）通常是对实体数据进行特定组装或处理后得到的，以满足特定的展示需求。
+	 // @param wrapper 查询条件包装器，用于筛选符合条件的成本结余视图数据。
+	 // @param ("ew") 使用@Param注解指定参数名称为"ew"，方便在SQL映射文件中引用该参数。
+	 // @return 符合条件的成本结余视图列表。
+	List<ChengbenjieyuView> selectListView(@Param("ew") Wrapper<ChengbenjieyuEntity> wrapper);
+
+
+	 // 根据分页信息和查询条件包装器查询成本结余视图列表，支持分页查询。
+	 // @param page 分页信息对象，包含当前页码、每页记录数等信息。
+	 //@param wrapper 查询条件包装器，用于筛选符合条件的成本结余视图数据。
+	 //@param ("ew") 使用@Param注解指定参数名称为"ew"，方便在SQL映射文件中引用该参数。
+	 //@return 符合条件的成本结余视图列表，按分页信息进行分页。
+
+	List<ChengbenjieyuView> selectListView(Pagination page, @Param("ew") Wrapper<ChengbenjieyuEntity> wrapper);
+
+
+	 // 根据查询条件包装器查询单个成本结余视图。
+	 // @param wrapper 查询条件包装器，用于精确筛选出一个成本结余视图数据。
+	 //@param ("ew") 使用@Param注解指定参数名称为"ew"，方便在SQL映射文件中引用该参数。
+	 // @return 符合条件的单个成本结余视图，若未找到则返回 null。
+
+	ChengbenjieyuView selectView(@Param("ew") Wrapper<ChengbenjieyuEntity> wrapper);
+}

src/main/java/com/dao/CommonDao.java

@@ -0,0 +1,65 @@
+package com.dao;
+
+import java.util.List;
+import java.util.Map;
+
+
+ //通用接口，定义了一系列通用的数据访问方法，
+ //这些方法可用于执行多种不同类型的数据库操作，
+ //适用于各种业务场景中通用的数据查询、处理和统计等需求。
+
+public interface CommonDao {
+
+
+	 // 根据传入的参数获取选项列表。
+	 // @param params 包含查询条件的参数Map，用于筛选符合条件的选项。
+	 // @return 包含符合条件选项的字符串列表。
+
+	List<String> getOption(Map<String, Object> params);
+
+
+	 // 根据传入的参数获取与选项相关的详细信息。
+	// @param params 包含查询条件的参数Map，用于定位特定的选项及其相关信息。
+	 // @return 包含选项相关详细信息的Map，键为信息的名称，值为对应的信息内容。
+
+	Map<String, Object> getFollowByOption(Map<String, Object> params);
+
+	 // 根据传入的参数获取另一种与选项相关的信息列表。
+	 // @param params 包含查询条件的参数Map，用于筛选出符合条件的信息。
+	 // @return 包含符合条件信息的字符串列表。
+
+	List<String> getFollowByOption2(Map<String, Object> params);
+
+
+	// 执行某种数据处理操作，可能是更新、删除或其他自定义操作。
+	// @param params 包含操作所需参数的Map，具体操作由实现类根据参数内容决定。
+
+	void sh(Map<String, Object> params);
+
+
+	 //统计提醒的数量。
+	 //@param params 包含统计条件的参数Map，用于筛选出符合条件的提醒记录。
+	//@return 符合条件的提醒记录数量。
+
+	int remindCount(Map<String, Object> params);
+
+
+	 // 根据传入的参数进行数据计算并返回计算结果。
+	 //@param params 包含计算所需数据和条件的参数Map，具体计算逻辑由实现类实现。
+	 //@return 包含计算结果的Map，键为计算结果的名称，值为对应的计算结果。
+
+	Map<String, Object> selectCal(Map<String, Object> params);
+
+
+	 // 根据传入的参数进行分组查询，并返回分组结果。
+	 // @param params 包含分组查询条件的参数Map，用于指定分组依据和筛选条件。
+	 // @return 包含分组结果的Map列表，每个Map表示一组数据及其相关统计信息。
+
+	List<Map<String, Object>> selectGroup(Map<String, Object> params);
+
+	 // 根据传入的参数查询特定的值，并返回查询结果。
+	 // @param params 包含查询条件的参数Map，用于筛选出符合条件的数据记录。
+	 // @return 包含查询结果的Map列表，每个Map表示一条符合条件的数据记录。
+
+	List<Map<String, Object>> selectValue(Map<String, Object> params);
+}

src/main/java/com/dao/ConfigDao.java

@@ -0,0 +1,19 @@
+package com.dao;
+
+import com.baomidou.mybatisplus.mapper.BaseMapper;
+import com.entity.ConfigEntity;
+
+
+ //配置数据访问接口，继承自MyBatis-Plus的BaseMapper接口，
+ // 用于对配置实体（ConfigEntity）进行数据库操作。
+ // 借助BaseMapper，该接口自动具备了对ConfigEntity实体的基本CRUD（创建、读取、更新、删除）操作能力，
+ // 例如插入、查询、更新和删除ConfigEntity对象对应的数据库记录。
+ // 如果后续需要对配置数据进行更复杂的数据库操作，可以在此接口中添加自定义的方法。
+//@author
+// @email
+ // @date
+
+public interface ConfigDao extends BaseMapper<ConfigEntity> {
+    // 目前该接口仅继承BaseMapper的功能，未添加额外的自定义方法。
+    // 如果有特殊的数据库操作需求，可在此处添加对应的方法声明。
+}

src/main/java/com/dao/JizhangpingzhengDao.java

@@ -0,0 +1,60 @@
+package com.dao;
+
+import com.entity.JizhangpingzhengEntity;
+import com.baomidou.mybatisplus.mapper.BaseMapper;
+import java.util.List;
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.plugins.pagination.Pagination;
+
+import org.apache.ibatis.annotations.Param;
+import com.entity.vo.JizhangpingzhengVO;
+import com.entity.view.JizhangpingzhengView;
+
+
+ // 记账凭证
+ //此接口用于与数据库中记账凭证相关的数据进行交互，继承自 MyBatis-Plus 的 BaseMapper 接口，可使用其提供的基础 CRUD 操作。
+ // @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+public interface JizhangpingzhengDao extends BaseMapper<JizhangpingzhengEntity> {
+
+
+	 // 根据查询条件 wrapper 查询记账凭证值对象（VO）列表。
+	 // 值对象（VO）通常用于封装特定业务逻辑需要的数据，可能只包含实体类的部分字段或经过计算处理后的字段。
+	 // @param wrapper 用于构建查询条件的包装器，可通过该包装器设置各种查询条件，如等于、大于、小于等。
+	 // @return 满足查询条件的记账凭证值对象列表。
+
+	List<JizhangpingzhengVO> selectListVO(@Param("ew") Wrapper<JizhangpingzhengEntity> wrapper);
+
+
+	 // 根据查询条件 wrapper 查询单个记账凭证值对象（VO）。
+	 //@param wrapper 用于构建查询条件的包装器。
+	 // @return 满足查询条件的单个记账凭证值对象，如果没有匹配的记录则返回 null。
+
+	JizhangpingzhengVO selectVO(@Param("ew") Wrapper<JizhangpingzhengEntity> wrapper);
+
+
+	// 根据查询条件 wrapper 查询记账凭证视图对象列表。
+	 // 视图对象通常用于展示数据，可能会包含一些关联查询或格式化后的数据。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 满足查询条件的记账凭证视图对象列表。
+
+	List<JizhangpingzhengView> selectListView(@Param("ew") Wrapper<JizhangpingzhengEntity> wrapper);
+
+
+	 // 根据分页信息 page 和查询条件 wrapper 查询记账凭证视图对象列表。
+	 // 该方法支持分页查询，可用于处理大量数据。
+	 //@param page 分页对象，包含当前页码、每页显示记录数等信息。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 当前页满足查询条件的记账凭证视图对象列表。
+
+	List<JizhangpingzhengView> selectListView(Pagination page, @Param("ew") Wrapper<JizhangpingzhengEntity> wrapper);
+
+
+	// 根据查询条件 wrapper 查询单个记账凭证视图对象。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 满足查询条件的单个记账凭证视图对象，如果没有匹配的记录则返回 null。
+
+	JizhangpingzhengView selectView(@Param("ew") Wrapper<JizhangpingzhengEntity> wrapper);
+}

src/main/java/com/dao/RijizhangDao.java

@@ -0,0 +1,60 @@
+package com.dao;
+
+import com.entity.RijizhangEntity;
+import com.baomidou.mybatisplus.mapper.BaseMapper;
+import java.util.List;
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.plugins.pagination.Pagination;
+
+import org.apache.ibatis.annotations.Param;
+import com.entity.vo.RijizhangVO;
+import com.entity.view.RijizhangView;
+
+
+ // 日记账
+ // 该接口用于与数据库中日记账相关的数据进行交互，继承自 MyBatis-Plus 的 BaseMapper 接口，具备基本的增删改查功能。
+ //@author
+ //@email
+ //@date 2021-04-24 15:19:31
+
+public interface RijizhangDao extends BaseMapper<RijizhangEntity> {
+
+
+	 // 根据查询条件 wrapper 查询日记账值对象（VO）列表。
+	 //值对象（VO）通常用于封装特定业务逻辑需要的数据，可能只包含实体类的部分字段或经过计算处理后的字段。
+	 // @param wrapper 用于构建查询条件的包装器，可通过该包装器设置各种查询条件，如等于、大于、小于等。
+	 // @return 满足查询条件的日记账值对象列表。
+
+	List<RijizhangVO> selectListVO(@Param("ew") Wrapper<RijizhangEntity> wrapper);
+
+
+	 // 根据查询条件 wrapper 查询单个日记账值对象（VO）。
+//	 @param wrapper 用于构建查询条件的包装器。
+	 //@return 满足查询条件的单个日记账值对象，如果没有匹配的记录则返回 null。
+
+	RijizhangVO selectVO(@Param("ew") Wrapper<RijizhangEntity> wrapper);
+
+
+	 // 根据查询条件 wrapper 查询日记账视图对象列表。
+	 // 视图对象通常用于展示数据，可能会包含一些关联查询或格式化后的数据。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 //@return 满足查询条件的日记账视图对象列表。
+
+	List<RijizhangView> selectListView(@Param("ew") Wrapper<RijizhangEntity> wrapper);
+
+
+	 // 根据分页信息 page 和查询条件 wrapper 查询日记账视图对象列表。
+	 //该方法支持分页查询，可用于处理大量数据。
+	 // @param page 分页对象，包含当前页码、每页显示记录数等信息。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 //@return 当前页满足查询条件的日记账视图对象列表。
+
+	List<RijizhangView> selectListView(Pagination page, @Param("ew") Wrapper<RijizhangEntity> wrapper);
+
+
+	 // 根据查询条件 wrapper 查询单个日记账视图对象。
+	 //@param wrapper 用于构建查询条件的包装器。
+	 // @return 满足查询条件的单个日记账视图对象，如果没有匹配的记录则返回 null。
+
+	RijizhangView selectView(@Param("ew") Wrapper<RijizhangEntity> wrapper);
+}

src/main/java/com/dao/ShangpinchukuDao.java

@@ -0,0 +1,61 @@
+package com.dao;
+
+import com.entity.ShangpinchukuEntity;
+import com.baomidou.mybatisplus.mapper.BaseMapper;
+import java.util.List;
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.plugins.pagination.Pagination;
+
+import org.apache.ibatis.annotations.Param;
+import com.entity.vo.ShangpinchukuVO;
+import com.entity.view.ShangpinchukuView;
+
+
+ // 商品出库
+ // 该接口用于处理与商品出库相关的数据访问操作，继承自 MyBatis-Plus 的 BaseMapper 接口，
+ // 具备对商品出库实体类（ShangpinchukuEntity）的基本增删改查功能。
+ // @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+public interface ShangpinchukuDao extends BaseMapper<ShangpinchukuEntity> {
+
+
+	 // 根据传入的查询条件包装器（Wrapper），查询符合条件的商品出库值对象（VO）列表。
+	 // 值对象（VO）通常用于封装特定业务场景下需要展示或处理的数据，可能包含实体类的部分属性。
+	 //@param wrapper 用于构建查询条件的包装器，可设置各种条件（如等于、大于、小于等）来筛选数据。
+	 // @return 符合查询条件的商品出库值对象（ShangpinchukuVO）列表，如果没有符合条件的数据则返回空列表。
+
+	List<ShangpinchukuVO> selectListVO(@Param("ew") Wrapper<ShangpinchukuEntity> wrapper);
+
+
+	 // 根据传入的查询条件包装器（Wrapper），查询符合条件的单个商品出库值对象（VO）。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个商品出库值对象（ShangpinchukuVO），如果没有符合条件的数据则返回 null。
+
+	ShangpinchukuVO selectVO(@Param("ew") Wrapper<ShangpinchukuEntity> wrapper);
+
+
+	 // 根据传入的查询条件包装器（Wrapper），查询符合条件的商品出库视图对象（View）列表。
+	 // 视图对象（View）通常是对实体类数据进行了一定的处理或关联查询后得到的，用于满足特定的展示需求。
+	 //@param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的商品出库视图对象（ShangpinchukuView）列表，如果没有符合条件的数据则返回空列表。
+
+	List<ShangpinchukuView> selectListView(@Param("ew") Wrapper<ShangpinchukuEntity> wrapper);
+
+
+	 //根据传入的分页信息（Pagination）和查询条件包装器（Wrapper），查询符合条件的商品出库视图对象（View）列表。
+	 //此方法支持分页查询，适用于数据量较大的情况，可按页获取符合条件的数据。
+	 // @param page 分页信息对象，包含了当前页码、每页显示的记录数等信息。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 当前页符合查询条件的商品出库视图对象（ShangpinchukuView）列表，如果没有符合条件的数据则返回空列表。
+
+	List<ShangpinchukuView> selectListView(Pagination page, @Param("ew") Wrapper<ShangpinchukuEntity> wrapper);
+
+
+	 // 根据传入的查询条件包装器（Wrapper），查询符合条件的单个商品出库视图对象（View）。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个商品出库视图对象（ShangpinchukuView），如果没有符合条件的数据则返回 null。
+
+	ShangpinchukuView selectView(@Param("ew") Wrapper<ShangpinchukuEntity> wrapper);
+}

src/main/java/com/dao/ShangpinkucunDao.java

@@ -0,0 +1,61 @@
+package com.dao;
+
+import com.entity.ShangpinkucunEntity;
+import com.baomidou.mybatisplus.mapper.BaseMapper;
+import java.util.List;
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.plugins.pagination.Pagination;
+
+import org.apache.ibatis.annotations.Param;
+import com.entity.vo.ShangpinkucunVO;
+import com.entity.view.ShangpinkucunView;
+
+
+ // 商品库存
+ // 该接口用于处理与商品库存相关的数据访问操作，继承自 MyBatis-Plus 的 BaseMapper 接口，
+ // 拥有对商品库存实体类（ShangpinkucunEntity）的基本增删改查能力。
+ // @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+public interface ShangpinkucunDao extends BaseMapper<ShangpinkucunEntity> {
+
+
+	 // 根据传入的查询条件包装器（Wrapper），查询符合条件的商品库存值对象（VO）列表。
+	 // 值对象（VO）一般用于封装特定业务场景下所需的数据，可能包含实体类的部分属性。
+	 //@param wrapper 用于构建查询条件的包装器，可以设置各种条件（如等于、大于、小于等）来筛选数据。
+	 // @return 符合查询条件的商品库存值对象（ShangpinkucunVO）列表，若没有符合条件的数据则返回空列表。
+
+	List<ShangpinkucunVO> selectListVO(@Param("ew") Wrapper<ShangpinkucunEntity> wrapper);
+
+
+	 // 根据传入的查询条件包装器（Wrapper），查询符合条件的单个商品库存值对象（VO）。
+	 //@param wrapper 用于构建查询条件的包装器。
+	 //@return 符合查询条件的单个商品库存值对象（ShangpinkucunVO），若没有符合条件的数据则返回 null。
+
+	ShangpinkucunVO selectVO(@Param("ew") Wrapper<ShangpinkucunEntity> wrapper);
+
+
+	 //根据传入的查询条件包装器（Wrapper），查询符合条件的商品库存视图对象（View）列表。
+	 //视图对象（View）通常是对实体类数据进行了一定处理或关联查询后得到的，以满足特定的展示需求。
+	 //@param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的商品库存视图对象（ShangpinkucunView）列表，若没有符合条件的数据则返回空列表。
+
+	List<ShangpinkucunView> selectListView(@Param("ew") Wrapper<ShangpinkucunEntity> wrapper);
+
+
+	 //根据传入的分页信息（Pagination）和查询条件包装器（Wrapper），查询符合条件的商品库存视图对象（View）列表。
+	 //此方法支持分页查询，适用于数据量较大的情况，可按页获取符合条件的数据。
+	 // @param page 分页信息对象，包含当前页码、每页显示的记录数等信息。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 当前页符合查询条件的商品库存视图对象（ShangpinkucunView）列表，若没有符合条件的数据则返回空列表。
+
+	List<ShangpinkucunView> selectListView(Pagination page, @Param("ew") Wrapper<ShangpinkucunEntity> wrapper);
+
+
+	 // 根据传入的查询条件包装器（Wrapper），查询符合条件的单个商品库存视图对象（View）。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个商品库存视图对象（ShangpinkucunView），若没有符合条件的数据则返回 null。
+
+	ShangpinkucunView selectView(@Param("ew") Wrapper<ShangpinkucunEntity> wrapper);
+}

src/main/java/com/dao/ShangpinleixingDao.java

@@ -0,0 +1,60 @@
+package com.dao;
+
+import com.entity.ShangpinleixingEntity;
+import com.baomidou.mybatisplus.mapper.BaseMapper;
+import java.util.List;
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.plugins.pagination.Pagination;
+
+import org.apache.ibatis.annotations.Param;
+import com.entity.vo.ShangpinleixingVO;
+import com.entity.view.ShangpinleixingView;
+
+
+ // 商品类型
+ // 此接口用于与数据库中商品类型相关的数据进行交互，继承自 MyBatis-Plus 的 BaseMapper 接口，具备基本的增删改查功能。
+ //@author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+public interface ShangpinleixingDao extends BaseMapper<ShangpinleixingEntity> {
+
+
+	 //根据指定的查询条件，查询商品类型值对象（VO）列表。
+	 //值对象（VO）通常用于封装特定业务场景下需要的数据，可能是实体类部分字段的组合或经过处理后的数据。
+	 // @param wrapper 用于构建查询条件的包装器，可设置如等于、大于、小于等条件。
+	 // @return 符合查询条件的商品类型值对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<ShangpinleixingVO> selectListVO(@Param("ew") Wrapper<ShangpinleixingEntity> wrapper);
+
+
+	 // 根据指定的查询条件，查询单个商品类型值对象（VO）。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个商品类型值对象，如果没有符合条件的数据则返回 null。
+
+	ShangpinleixingVO selectVO(@Param("ew") Wrapper<ShangpinleixingEntity> wrapper);
+
+
+	 // 根据指定的查询条件，查询商品类型视图对象列表。
+	 // 视图对象通常用于展示数据，可能包含关联查询或格式化后的数据。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的商品类型视图对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<ShangpinleixingView> selectListView(@Param("ew") Wrapper<ShangpinleixingEntity> wrapper);
+
+
+	 //根据分页信息和查询条件，查询商品类型视图对象列表。
+	 // 该方法支持分页查询，适用于处理大量数据。
+	 // @param page 分页对象，包含当前页码、每页显示记录数等信息。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 当前页符合查询条件的商品类型视图对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<ShangpinleixingView> selectListView(Pagination page, @Param("ew") Wrapper<ShangpinleixingEntity> wrapper);
+
+
+	 // 根据指定的查询条件，查询单个商品类型视图对象。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个商品类型视图对象，如果没有符合条件的数据则返回 null。
+
+	ShangpinleixingView selectView(@Param("ew") Wrapper<ShangpinleixingEntity> wrapper);
+}

src/main/java/com/dao/ShangpinrukuDao.java

@@ -0,0 +1,61 @@
+package com.dao;
+
+import com.entity.ShangpinrukuEntity;
+import com.baomidou.mybatisplus.mapper.BaseMapper;
+import java.util.List;
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.plugins.pagination.Pagination;
+
+import org.apache.ibatis.annotations.Param;
+import com.entity.vo.ShangpinrukuVO;
+import com.entity.view.ShangpinrukuView;
+
+
+ //商品入库
+ //该接口主要负责与数据库中商品入库相关数据进行交互，继承自 MyBatis-Plus 的 BaseMapper 接口，
+ //可使用其提供的基本增删改查操作方法来处理商品入库实体（ShangpinrukuEntity）。
+// @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+public interface ShangpinrukuDao extends BaseMapper<ShangpinrukuEntity> {
+
+
+	 //根据传入的查询条件包装器（Wrapper），查询符合条件的商品入库值对象（VO）列表。
+	 //值对象（VO）通常用于封装特定业务场景下需要的数据，可能只包含实体类的部分字段或经过计算处理后的数据。
+	 //@param wrapper 用于构建查询条件的包装器，可设置各种条件（如等于、大于、小于等）来筛选数据。
+	 //@return 符合查询条件的商品入库值对象（ShangpinrukuVO）列表，如果没有符合条件的数据则返回空列表。
+
+	List<ShangpinrukuVO> selectListVO(@Param("ew") Wrapper<ShangpinrukuEntity> wrapper);
+
+
+	 // 根据传入的查询条件包装器（Wrapper），查询符合条件的单个商品入库值对象（VO）。
+	// @param wrapper 用于构建查询条件的包装器。
+	 //@return 符合查询条件的单个商品入库值对象（ShangpinrukuVO），如果没有符合条件的数据则返回 null。
+
+	ShangpinrukuVO selectVO(@Param("ew") Wrapper<ShangpinrukuEntity> wrapper);
+
+
+	 //根据传入的查询条件包装器（Wrapper），查询符合条件的商品入库视图对象（View）列表。
+	 //视图对象（View）通常用于展示数据，可能会包含一些关联查询或格式化后的数据，以满足前端展示的需求。
+	 //@param wrapper 用于构建查询条件的包装器。
+	 //@return 符合查询条件的商品入库视图对象（ShangpinrukuView）列表，如果没有符合条件的数据则返回空列表。
+
+	List<ShangpinrukuView> selectListView(@Param("ew") Wrapper<ShangpinrukuEntity> wrapper);
+
+
+	// 根据传入的分页信息（Pagination）和查询条件包装器（Wrapper），查询符合条件的商品入库视图对象（View）列表。
+	 // 此方法支持分页查询，适用于处理大量数据，可按页获取符合条件的数据。
+	 //@param page 分页对象，包含当前页码、每页显示记录数等信息。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 //@return 当前页符合查询条件的商品入库视图对象（ShangpinrukuView）列表，如果没有符合条件的数据则返回空列表。
+
+	List<ShangpinrukuView> selectListView(Pagination page, @Param("ew") Wrapper<ShangpinrukuEntity> wrapper);
+
+
+	 // 根据传入的查询条件包装器（Wrapper），查询符合条件的单个商品入库视图对象（View）。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个商品入库视图对象（ShangpinrukuView），如果没有符合条件的数据则返回 null。
+
+	ShangpinrukuView selectView(@Param("ew") Wrapper<ShangpinrukuEntity> wrapper);
+}

src/main/java/com/dao/TokenDao.java

@@ -0,0 +1,37 @@
+
+package com.dao;
+
+import java.util.List;
+
+import org.apache.ibatis.annotations.Param;
+
+import com.baomidou.mybatisplus.mapper.BaseMapper;
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.plugins.pagination.Pagination;
+import com.entity.TokenEntity;
+
+
+ // token
+ // 该接口用于与数据库中的 token 数据进行交互，继承自 MyBatis-Plus 的 BaseMapper 接口，
+ // 可以使用 BaseMapper 提供的基本增删改查操作方法对 TokenEntity 进行操作。
+
+public interface TokenDao extends BaseMapper<TokenEntity> {
+
+
+	 //根据传入的查询条件包装器（Wrapper），查询符合条件的 Token 实体列表。
+	 // 此方法用于获取满足特定条件的所有 Token 数据。
+	// @param wrapper 用于构建查询条件的包装器，可通过该包装器设置各种查询条件，如等于、大于、小于等。
+	 // @return 符合查询条件的 Token 实体列表，如果没有符合条件的数据则返回空列表。
+
+	List<TokenEntity> selectListView(@Param("ew") Wrapper<TokenEntity> wrapper);
+
+
+	 // 根据传入的分页信息（Pagination）和查询条件包装器（Wrapper），查询符合条件的 Token 实体列表。
+	 // 此方法支持分页查询，适用于处理大量数据，可按页获取符合条件的 Token 数据。
+	 //@param page 分页对象，包含当前页码、每页显示记录数等信息。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 当前页符合查询条件的 Token 实体列表，如果没有符合条件的数据则返回空列表。
+
+	List<TokenEntity> selectListView(Pagination page, @Param("ew") Wrapper<TokenEntity> wrapper);
+
+}

src/main/java/com/dao/UserDao.java

@@ -0,0 +1,34 @@
+package com.dao;
+
+import java.util.List;
+
+import org.apache.ibatis.annotations.Param;
+
+import com.baomidou.mybatisplus.mapper.BaseMapper;
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.plugins.pagination.Pagination;
+import com.entity.UserEntity;
+
+
+ // 用户
+ // 该接口主要用于与数据库中的用户表进行交互，继承自 MyBatis-Plus 的 BaseMapper 接口，
+ //具备对 UserEntity 实体对象的基本增删改查功能。
+
+public interface UserDao extends BaseMapper<UserEntity> {
+
+
+	 //根据传入的查询条件包装器 wrapper 查询用户实体列表。
+	 // @param wrapper 用于构建查询条件的包装器，可设置如等于、大于、小于等各种查询条件。
+	 // @return 符合查询条件的用户实体列表，若没有符合条件的记录则返回空列表。
+
+	List<UserEntity> selectListView(@Param("ew") Wrapper<UserEntity> wrapper);
+
+
+	 // 根据传入的分页信息 page 和查询条件包装器 wrapper 进行分页查询用户实体列表。
+	 //@param page 分页对象，包含当前页码、每页显示的记录数等分页信息。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 当前页符合查询条件的用户实体列表，若没有符合条件的记录则返回空列表。
+
+	List<UserEntity> selectListView(Pagination page, @Param("ew") Wrapper<UserEntity> wrapper);
+
+}

src/main/java/com/dao/YuangongDao.java

@@ -0,0 +1,61 @@
+package com.dao;
+
+import com.entity.YuangongEntity;
+import com.baomidou.mybatisplus.mapper.BaseMapper;
+import java.util.List;
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.plugins.pagination.Pagination;
+
+import org.apache.ibatis.annotations.Param;
+import com.entity.vo.YuangongVO;
+import com.entity.view.YuangongView;
+
+
+ // 员工
+ // 该接口用于与数据库中员工相关的数据进行交互，继承自 MyBatis-Plus 的 BaseMapper 接口，
+ //具备对员工实体（YuangongEntity）的基本增删改查功能。
+ //@author
+ // @email
+ //@date 2021-04-24 15:19:31
+
+public interface YuangongDao extends BaseMapper<YuangongEntity> {
+
+
+	 // 根据查询条件 wrapper 查询员工值对象（VO）列表。
+	 // 值对象（VO）通常用于封装特定业务场景下需要展示或处理的数据，可能只包含实体类的部分字段。
+	 // @param wrapper 用于构建查询条件的包装器，可设置各种条件（如等于、大于、小于等）来筛选数据。
+	 //@return 符合查询条件的员工值对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<YuangongVO> selectListVO(@Param("ew") Wrapper<YuangongEntity> wrapper);
+
+
+	 // 根据查询条件 wrapper 查询单个员工值对象（VO）。
+	// @param wrapper 用于构建查询条件的包装器。
+	// @return 符合查询条件的单个员工值对象，如果没有符合条件的数据则返回 null。
+
+	YuangongVO selectVO(@Param("ew") Wrapper<YuangongEntity> wrapper);
+
+
+	// 根据查询条件 wrapper 查询员工视图对象列表。
+	 // 视图对象通常用于展示数据，可能包含一些关联查询或格式化后的数据。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的员工视图对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<YuangongView> selectListView(@Param("ew") Wrapper<YuangongEntity> wrapper);
+
+
+	 //根据分页信息 page 和查询条件 wrapper 查询员工视图对象列表。
+	 //该方法支持分页查询，适用于处理大量数据。
+	//@param page 分页对象，包含当前页码、每页显示记录数等信息。
+	// @param wrapper 用于构建查询条件的包装器。
+	 // @return 当前页符合查询条件的员工视图对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<YuangongView> selectListView(Pagination page, @Param("ew") Wrapper<YuangongEntity> wrapper);
+
+
+	 // 根据查询条件 wrapper 查询单个员工视图对象。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个员工视图对象，如果没有符合条件的数据则返回 null。
+
+	YuangongView selectView(@Param("ew") Wrapper<YuangongEntity> wrapper);
+}

src/main/java/com/dao/YuangongbaoxiaoDao.java

@@ -0,0 +1,61 @@
+package com.dao;
+
+import com.entity.YuangongbaoxiaoEntity;
+import com.baomidou.mybatisplus.mapper.BaseMapper;
+import java.util.List;
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.plugins.pagination.Pagination;
+
+import org.apache.ibatis.annotations.Param;
+import com.entity.vo.YuangongbaoxiaoVO;
+import com.entity.view.YuangongbaoxiaoView;
+
+
+ // 员工报销
+ //该接口用于与数据库中员工报销相关的数据进行交互，继承自 MyBatis-Plus 的 BaseMapper 接口，
+ //可使用 BaseMapper 提供的基本增删改查功能来操作 YuangongbaoxiaoEntity 实体。
+ // @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+public interface YuangongbaoxiaoDao extends BaseMapper<YuangongbaoxiaoEntity> {
+
+
+	// 根据传入的查询条件包装器 wrapper，查询符合条件的员工报销值对象（VO）列表。
+	 // 值对象（VO）通常用于封装特定业务场景下需要展示或处理的数据，可能是实体类部分字段的组合。
+	 // @param wrapper 用于构建查询条件的包装器，可设置如等于、大于、小于等条件来筛选数据。
+	 // @return 符合查询条件的员工报销值对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<YuangongbaoxiaoVO> selectListVO(@Param("ew") Wrapper<YuangongbaoxiaoEntity> wrapper);
+
+
+	// 根据传入的查询条件包装器 wrapper，查询符合条件的单个员工报销值对象（VO）。
+	//@param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个员工报销值对象，如果没有符合条件的数据则返回 null。
+
+	YuangongbaoxiaoVO selectVO(@Param("ew") Wrapper<YuangongbaoxiaoEntity> wrapper);
+
+
+	// 根据传入的查询条件包装器 wrapper，查询符合条件的员工报销视图对象列表。
+	 //视图对象通常用于展示数据，可能包含关联查询或格式化后的数据。
+	//@param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的员工报销视图对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<YuangongbaoxiaoView> selectListView(@Param("ew") Wrapper<YuangongbaoxiaoEntity> wrapper);
+
+
+	 //根据传入的分页信息 page 和查询条件包装器 wrapper，分页查询符合条件的员工报销视图对象列表。
+	 //此方法支持分页查询，适用于处理大量数据。
+	// @param page 分页对象，包含当前页码、每页显示记录数等信息。
+	 // @param wrapper 用于构建查询条件的包装器。
+	// @return 当前页符合查询条件的员工报销视图对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<YuangongbaoxiaoView> selectListView(Pagination page, @Param("ew") Wrapper<YuangongbaoxiaoEntity> wrapper);
+
+
+	//根据传入的查询条件包装器 wrapper，查询符合条件的单个员工报销视图对象。
+	//@param wrapper 用于构建查询条件的包装器。
+	// @return 符合查询条件的单个员工报销视图对象，如果没有符合条件的数据则返回 null。
+
+	YuangongbaoxiaoView selectView(@Param("ew") Wrapper<YuangongbaoxiaoEntity> wrapper);
+}

src/main/java/com/dao/YuangongjiaokuanDao.java

@@ -0,0 +1,61 @@
+package com.dao;
+
+import com.entity.YuangongjiaokuanEntity;
+import com.baomidou.mybatisplus.mapper.BaseMapper;
+import java.util.List;
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.plugins.pagination.Pagination;
+
+import org.apache.ibatis.annotations.Param;
+import com.entity.vo.YuangongjiaokuanVO;
+import com.entity.view.YuangongjiaokuanView;
+
+
+ // 员工缴款
+ // 该接口主要用于与数据库中员工缴款相关的数据进行交互，继承自 MyBatis-Plus 的 BaseMapper 接口，
+ // 能够对 YuangongjiaokuanEntity 实体对象进行基本的增删改查操作。
+ // @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+public interface YuangongjiaokuanDao extends BaseMapper<YuangongjiaokuanEntity> {
+
+
+	 // 根据传入的查询条件包装器 wrapper，查询符合条件的员工缴款值对象（VO）列表。
+	 // 值对象（VO）一般用于封装特定业务场景下需要的数据，可能只包含实体类的部分字段。
+	 // @param wrapper 用于构建查询条件的包装器，可设置各种条件（如等于、大于、小于等）来筛选数据。
+	 // @return 符合查询条件的员工缴款值对象列表，若没有符合条件的数据则返回空列表。
+
+	List<YuangongjiaokuanVO> selectListVO(@Param("ew") Wrapper<YuangongjiaokuanEntity> wrapper);
+
+
+	 //根据传入的查询条件包装器 wrapper，查询符合条件的单个员工缴款值对象（VO）。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个员工缴款值对象，若没有符合条件的数据则返回 null。
+
+	YuangongjiaokuanVO selectVO(@Param("ew") Wrapper<YuangongjiaokuanEntity> wrapper);
+
+
+	 // 根据传入的查询条件包装器 wrapper，查询符合条件的员工缴款视图对象列表。
+	 // 视图对象通常用于展示数据，可能包含关联查询或格式化后的数据。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的员工缴款视图对象列表，若没有符合条件的数据则返回空列表。
+
+	List<YuangongjiaokuanView> selectListView(@Param("ew") Wrapper<YuangongjiaokuanEntity> wrapper);
+
+
+	 // 根据传入的分页信息 page 和查询条件包装器 wrapper，分页查询符合条件的员工缴款视图对象列表。
+	 // 该方法支持分页查询，适用于处理大量数据。
+	 // @param page 分页对象，包含当前页码、每页显示记录数等信息。
+	 //@param wrapper 用于构建查询条件的包装器。
+	// @return 当前页符合查询条件的员工缴款视图对象列表，若没有符合条件的数据则返回空列表。
+
+	List<YuangongjiaokuanView> selectListView(Pagination page, @Param("ew") Wrapper<YuangongjiaokuanEntity> wrapper);
+
+
+	 // 根据传入的查询条件包装器 wrapper，查询符合条件的单个员工缴款视图对象。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个员工缴款视图对象，若没有符合条件的数据则返回 null。
+
+	YuangongjiaokuanView selectView(@Param("ew") Wrapper<YuangongjiaokuanEntity> wrapper);
+}

src/main/java/com/dao/YuangongxinchouDao.java

@@ -0,0 +1,61 @@
+package com.dao;
+
+import com.entity.YuangongxinchouEntity;
+import com.baomidou.mybatisplus.mapper.BaseMapper;
+import java.util.List;
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.plugins.pagination.Pagination;
+
+import org.apache.ibatis.annotations.Param;
+import com.entity.vo.YuangongxinchouVO;
+import com.entity.view.YuangongxinchouView;
+
+
+ // 员工薪酬
+ // 该接口用于与数据库中员工薪酬相关的数据进行交互，继承自 MyBatis-Plus 的 BaseMapper 接口，
+ //具备对员工薪酬实体（YuangongxinchouEntity）的基本增删改查功能。
+ // @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+public interface YuangongxinchouDao extends BaseMapper<YuangongxinchouEntity> {
+
+
+	 // 根据指定的查询条件 wrapper，查询员工薪酬值对象（VO）列表。
+	 // 值对象（VO）通常用于封装特定业务场景下需要展示或处理的数据，可能只包含实体类的部分字段。
+	 // @param wrapper 用于构建查询条件的包装器，可设置如等于、大于、小于等条件。
+	 // @return 符合查询条件的员工薪酬值对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<YuangongxinchouVO> selectListVO(@Param("ew") Wrapper<YuangongxinchouEntity> wrapper);
+
+
+	 // 根据指定的查询条件 wrapper，查询单个员工薪酬值对象（VO）。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个员工薪酬值对象，如果没有符合条件的数据则返回 null。
+
+	YuangongxinchouVO selectVO(@Param("ew") Wrapper<YuangongxinchouEntity> wrapper);
+
+
+	 // 根据指定的查询条件 wrapper，查询员工薪酬视图对象列表。
+	 // 视图对象通常用于展示数据，可能包含关联查询或格式化后的数据。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的员工薪酬视图对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<YuangongxinchouView> selectListView(@Param("ew") Wrapper<YuangongxinchouEntity> wrapper);
+
+
+	 // 根据分页信息 page 和查询条件 wrapper，分页查询员工薪酬视图对象列表。
+	 //该方法支持分页查询，适用于处理大量数据。
+	 // @param page 分页对象，包含当前页码、每页显示记录数等信息。
+	//@param wrapper 用于构建查询条件的包装器。
+	 // @return 当前页符合查询条件的员工薪酬视图对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<YuangongxinchouView> selectListView(Pagination page, @Param("ew") Wrapper<YuangongxinchouEntity> wrapper);
+
+
+	// 根据指定的查询条件 wrapper，查询单个员工薪酬视图对象。
+	// @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个员工薪酬视图对象，如果没有符合条件的数据则返回 null。
+
+	YuangongxinchouView selectView(@Param("ew") Wrapper<YuangongxinchouEntity> wrapper);
+}

src/main/java/com/entity/ChengbenjieyuEntity.java

@@ -0,0 +1,179 @@
+package com.entity;
+
+import com.baomidou.mybatisplus.annotations.TableId;
+import com.baomidou.mybatisplus.annotations.TableName;
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import java.lang.reflect.InvocationTargetException;
+
+import java.io.Serializable;
+import java.util.Date;
+import java.util.List;
+
+import org.springframework.format.annotation.DateTimeFormat;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import org.apache.commons.beanutils.BeanUtils;
+import com.baomidou.mybatisplus.annotations.TableField;
+import com.baomidou.mybatisplus.enums.FieldFill;
+import com.baomidou.mybatisplus.enums.IdType;
+
+
+// 成本结余
+ // 数据库通用操作实体类（普通增删改查）
+//@author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+@TableName("chengbenjieyu")
+public class ChengbenjieyuEntity<T> implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+
+	public ChengbenjieyuEntity() {
+		
+	}
+	
+	public ChengbenjieyuEntity(T t) {
+		try {
+			BeanUtils.copyProperties(this, t);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+	}
+	
+	// 主键id
+
+	@TableId
+	private Long id;
+
+	// 成本名称
+
+	private String chengbenmingcheng;
+	
+	//收入项目
+
+					
+	private String shouruxiangmu;
+	
+	// 收入金额
+
+					
+	private Integer shourujine;
+	
+	// 支出项目
+
+					
+	private String zhichuxiangmu;
+	
+	//支出金额
+
+					
+	private Integer zhichujine;
+	
+	//结余金额
+
+					
+	private String jieyujine;
+	
+	// 日期
+
+				
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd")
+	@DateTimeFormat 		
+	private Date riqi;
+	
+	
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat
+	private Date addtime;
+
+	public Date getAddtime() {
+		return addtime;
+	}
+	public void setAddtime(Date addtime) {
+		this.addtime = addtime;
+	}
+
+	public Long getId() {
+		return id;
+	}
+
+	public void setId(Long id) {
+		this.id = id;
+	}
+	// 设置：成本名称
+
+	public void setChengbenmingcheng(String chengbenmingcheng) {
+		this.chengbenmingcheng = chengbenmingcheng;
+	}
+	// 获取：成本名称
+
+	public String getChengbenmingcheng() {
+		return chengbenmingcheng;
+	}
+	// 设置：收入项目
+
+	public void setShouruxiangmu(String shouruxiangmu) {
+		this.shouruxiangmu = shouruxiangmu;
+	}
+	// 获取：收入项目
+
+	public String getShouruxiangmu() {
+		return shouruxiangmu;
+	}
+	// 设置：收入金额
+
+	public void setShourujine(Integer shourujine) {
+		this.shourujine = shourujine;
+	}
+	// 获取：收入金额
+
+	public Integer getShourujine() {
+		return shourujine;
+	}
+	// 设置：支出项目
+
+	public void setZhichuxiangmu(String zhichuxiangmu) {
+		this.zhichuxiangmu = zhichuxiangmu;
+	}
+	// 获取：支出项目
+
+	public String getZhichuxiangmu() {
+		return zhichuxiangmu;
+	}
+	// 设置：支出金额
+
+	public void setZhichujine(Integer zhichujine) {
+		this.zhichujine = zhichujine;
+	}
+	// 获取：支出金额
+
+	public Integer getZhichujine() {
+		return zhichujine;
+	}
+	// 设置：结余金额
+
+	public void setJieyujine(String jieyujine) {
+		this.jieyujine = jieyujine;
+	}
+	// 获取：结余金额
+
+	public String getJieyujine() {
+		return jieyujine;
+	}
+	// 设置：日期
+
+	public void setRiqi(Date riqi) {
+		this.riqi = riqi;
+	}
+	// 获取：日期
+
+	public Date getRiqi() {
+		return riqi;
+	}
+
+}

src/main/java/com/entity/ConfigEntity.java

@@ -0,0 +1,50 @@
+package com.entity;
+
+import java.io.Serializable;
+
+import com.baomidou.mybatisplus.annotations.TableId;
+import com.baomidou.mybatisplus.annotations.TableName;
+import com.baomidou.mybatisplus.enums.IdType;
+
+// 类说明 :
+
+@TableName("config")
+public class ConfigEntity implements Serializable{
+private static final long serialVersionUID = 1L;
+	
+	@TableId(type = IdType.AUTO)
+	private Long id;
+	
+	// key
+
+	private String name;
+	
+	// value
+
+	private String value;
+
+	public Long getId() {
+		return id;
+	}
+
+	public void setId(Long id) {
+		this.id = id;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	public String getValue() {
+		return value;
+	}
+
+	public void setValue(String value) {
+		this.value = value;
+	}
+	
+}

src/main/java/com/entity/EIException.java

@@ -0,0 +1,91 @@
+package com.entity;
+
+// 自定义异常
+// 该类继承自 RuntimeException，属于非受检异常，在使用时不需要显式捕获或抛出。
+ // 用于在特定业务场景下抛出带有自定义错误信息和错误码的异常。
+
+public class EIException extends RuntimeException {
+	// 序列化版本号，用于在反序列化时验证类的版本一致性
+	private static final long serialVersionUID = 1L;
+
+	// 异常信息，用于描述异常的具体情况
+	private String msg;
+	// 异常码，默认为 500，表示服务器内部错误
+	private int code = 500;
+
+	// 构造函数，接收异常信息作为参数
+	// @param msg 异常信息
+
+	public EIException(String msg) {
+		// 调用父类 RuntimeException 的构造函数，传入异常信息
+		super(msg);
+		// 将传入的异常信息赋值给当前对象的 msg 属性
+		this.msg = msg;
+	}
+
+	// 构造函数，接收异常信息和 Throwable 对象作为参数
+	// @param msg 异常信息
+	// @param e 异常的原因，即导致此异常抛出的另一个异常
+
+	public EIException(String msg, Throwable e) {
+		// 调用父类 RuntimeException 的构造函数，传入异常信息和异常原因
+		super(msg, e);
+		// 将传入的异常信息赋值给当前对象的 msg 属性
+		this.msg = msg;
+	}
+
+	// 构造函数，接收异常信息和异常码作为参数
+	//@param msg 异常信息
+	// @param code 异常码
+
+	public EIException(String msg, int code) {
+		// 调用父类 RuntimeException 的构造函数，传入异常信息
+		super(msg);
+		// 将传入的异常信息赋值给当前对象的 msg 属性
+		this.msg = msg;
+		// 将传入的异常码赋值给当前对象的 code 属性
+		this.code = code;
+	}
+
+	//构造函数，接收异常信息、异常码和 Throwable 对象作为参数
+	 // @param msg 异常信息
+	 //@param code 异常码
+	 // @param e 异常的原因，即导致此异常抛出的另一个异常
+
+	public EIException(String msg, int code, Throwable e) {
+		// 调用父类 RuntimeException 的构造函数，传入异常信息和异常原因
+		super(msg, e);
+		// 将传入的异常信息赋值给当前对象的 msg 属性
+		this.msg = msg;
+		// 将传入的异常码赋值给当前对象的 code 属性
+		this.code = code;
+	}
+
+	// 获取异常信息的方法
+	 // @return 异常信息
+
+	public String getMsg() {
+		return msg;
+	}
+
+	// 设置异常信息的方法
+	// @param msg 要设置的异常信息
+
+	public void setMsg(String msg) {
+		this.msg = msg;
+	}
+
+	//获取异常码的方法
+	 //@return 异常码
+
+	public int getCode() {
+		return code;
+	}
+
+	// 设置异常码的方法
+	// @param code 要设置的异常码
+
+	public void setCode(int code) {
+		this.code = code;
+	}
+}

src/main/java/com/entity/JizhangpingzhengEntity.java

@@ -0,0 +1,179 @@
+package com.entity;
+
+import com.baomidou.mybatisplus.annotations.TableId;
+import com.baomidou.mybatisplus.annotations.TableName;
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import java.lang.reflect.InvocationTargetException;
+
+import java.io.Serializable;
+import java.util.Date;
+import java.util.List;
+
+import org.springframework.format.annotation.DateTimeFormat;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import org.apache.commons.beanutils.BeanUtils;
+import com.baomidou.mybatisplus.annotations.TableField;
+import com.baomidou.mybatisplus.enums.FieldFill;
+import com.baomidou.mybatisplus.enums.IdType;
+
+
+// 记账凭证
+ // 数据库通用操作实体类（普通增删改查）
+ // @author
+// @email
+// @date 2021-04-24 15:19:31
+
+@TableName("jizhangpingzheng")
+public class JizhangpingzhengEntity<T> implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+
+	public JizhangpingzhengEntity() {
+		
+	}
+	
+	public JizhangpingzhengEntity(T t) {
+		try {
+			BeanUtils.copyProperties(this, t);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+	}
+	
+	// 主键id
+
+	@TableId
+	private Long id;
+	//凭证编号
+
+					
+	private String pingzhengbianhao;
+	
+	// 凭证名称
+
+					
+	private String pingzhengmingcheng;
+	
+	// 类型
+
+					
+	private String leixing;
+	
+	//凭证内容
+
+					
+	private String pingzhengneirong;
+	
+	// 登记日期
+
+
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 		
+	private Date dengjiriqi;
+	
+	// 附件
+
+					
+	private String fujian;
+	
+	// 备注
+
+					
+	private String beizhu;
+	
+	
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat
+	private Date addtime;
+
+	public Date getAddtime() {
+		return addtime;
+	}
+	public void setAddtime(Date addtime) {
+		this.addtime = addtime;
+	}
+
+	public Long getId() {
+		return id;
+	}
+
+	public void setId(Long id) {
+		this.id = id;
+	}
+	// 设置：凭证编号
+
+	public void setPingzhengbianhao(String pingzhengbianhao) {
+		this.pingzhengbianhao = pingzhengbianhao;
+	}
+	// 获取：凭证编号
+
+	public String getPingzhengbianhao() {
+		return pingzhengbianhao;
+	}
+	//设置：凭证名称
+
+	public void setPingzhengmingcheng(String pingzhengmingcheng) {
+		this.pingzhengmingcheng = pingzhengmingcheng;
+	}
+	// 获取：凭证名称
+
+	public String getPingzhengmingcheng() {
+		return pingzhengmingcheng;
+	}
+	//设置：类型
+
+	public void setLeixing(String leixing) {
+		this.leixing = leixing;
+	}
+	// 获取：类型
+
+	public String getLeixing() {
+		return leixing;
+	}
+	// 设置：凭证内容
+
+	public void setPingzhengneirong(String pingzhengneirong) {
+		this.pingzhengneirong = pingzhengneirong;
+	}
+	// 获取：凭证内容
+
+	public String getPingzhengneirong() {
+		return pingzhengneirong;
+	}
+	// 设置：登记日期
+
+	public void setDengjiriqi(Date dengjiriqi) {
+		this.dengjiriqi = dengjiriqi;
+	}
+	// 获取：登记日期
+
+	public Date getDengjiriqi() {
+		return dengjiriqi;
+	}
+	// 设置：附件
+
+	public void setFujian(String fujian) {
+		this.fujian = fujian;
+	}
+	//获取：附件
+
+	public String getFujian() {
+		return fujian;
+	}
+	// 设置：备注
+
+	public void setBeizhu(String beizhu) {
+		this.beizhu = beizhu;
+	}
+	// 获取：备注
+
+	public String getBeizhu() {
+		return beizhu;
+	}
+
+}

src/main/java/com/entity/RijizhangEntity.java

@@ -0,0 +1,193 @@
+package com.entity;
+
+import com.baomidou.mybatisplus.annotations.TableId;
+import com.baomidou.mybatisplus.annotations.TableName;
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import java.lang.reflect.InvocationTargetException;
+
+import java.io.Serializable;
+import java.util.Date;
+import java.util.List;
+
+import org.springframework.format.annotation.DateTimeFormat;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import org.apache.commons.beanutils.BeanUtils;
+import com.baomidou.mybatisplus.annotations.TableField;
+import com.baomidou.mybatisplus.enums.FieldFill;
+import com.baomidou.mybatisplus.enums.IdType;
+
+
+//日记账
+ // 数据库通用操作实体类（普通增删改查）
+ // @author
+// @email
+// @date 2021-04-24 15:19:31
+
+@TableName("rijizhang")
+public class RijizhangEntity<T> implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+
+	public RijizhangEntity() {
+		
+	}
+	
+	public RijizhangEntity(T t) {
+		try {
+			BeanUtils.copyProperties(this, t);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+	}
+	
+	// 主键id
+
+	@TableId
+	private Long id;
+	// 序号
+
+	private String xuhao;
+	
+	// 日期
+
+				
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd")
+	@DateTimeFormat 		
+	private Date riqi;
+	
+	// 摘要
+
+					
+	private String zhaiyao;
+	
+	// 收入
+
+					
+	private Integer shouru;
+	
+	// 支出
+
+					
+	private Integer zhichu;
+	
+	//金额
+
+					
+	private String jine;
+	
+	// 管理工号
+
+					
+	private String guanligonghao;
+	
+	//管理姓名
+
+					
+	private String guanlixingming;
+	
+	
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat
+	private Date addtime;
+
+	public Date getAddtime() {
+		return addtime;
+	}
+	public void setAddtime(Date addtime) {
+		this.addtime = addtime;
+	}
+
+	public Long getId() {
+		return id;
+	}
+
+	public void setId(Long id) {
+		this.id = id;
+	}
+	// 设置：序号
+
+	public void setXuhao(String xuhao) {
+		this.xuhao = xuhao;
+	}
+	// 获取：序号
+
+	public String getXuhao() {
+		return xuhao;
+	}
+	//设置：日期
+
+	public void setRiqi(Date riqi) {
+		this.riqi = riqi;
+	}
+	//获取：日期
+
+	public Date getRiqi() {
+		return riqi;
+	}
+	// 设置：摘要
+
+	public void setZhaiyao(String zhaiyao) {
+		this.zhaiyao = zhaiyao;
+	}
+	//获取：摘要
+
+	public String getZhaiyao() {
+		return zhaiyao;
+	}
+	//设置：收入
+
+	public void setShouru(Integer shouru) {
+		this.shouru = shouru;
+	}
+	//获取：收入
+
+	public Integer getShouru() {
+		return shouru;
+	}
+	//设置：支出
+
+	public void setZhichu(Integer zhichu) {
+		this.zhichu = zhichu;
+	}
+	// 获取：支出
+
+	public Integer getZhichu() {
+		return zhichu;
+	}
+	// 设置：金额
+
+	public void setJine(String jine) {
+		this.jine = jine;
+	}
+	// 获取：金额
+
+	public String getJine() {
+		return jine;
+	}
+	// 设置：管理工号
+
+	public void setGuanligonghao(String guanligonghao) {
+		this.guanligonghao = guanligonghao;
+	}
+	// 获取：管理工号
+
+	public String getGuanligonghao() {
+		return guanligonghao;
+	}
+	// 设置：管理姓名
+
+	public void setGuanlixingming(String guanlixingming) {
+		this.guanlixingming = guanlixingming;
+	}
+	// 获取：管理姓名
+
+	public String getGuanlixingming() {
+		return guanlixingming;
+	}
+
+}

src/main/java/com/entity/ShangpinchukuEntity.java

@@ -0,0 +1,224 @@
+package com.entity;
+
+import com.baomidou.mybatisplus.annotations.TableId;
+import com.baomidou.mybatisplus.annotations.TableName;
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import java.lang.reflect.InvocationTargetException;
+
+import java.io.Serializable;
+import java.util.Date;
+import java.util.List;
+
+import org.springframework.format.annotation.DateTimeFormat;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import org.apache.commons.beanutils.BeanUtils;
+import com.baomidou.mybatisplus.annotations.TableField;
+import com.baomidou.mybatisplus.enums.FieldFill;
+import com.baomidou.mybatisplus.enums.IdType;
+
+
+//商品出库
+ //数据库通用操作实体类（普通增删改查）
+ //@author
+ //@email
+ //@date 2021-04-24 15:19:31
+
+@TableName("shangpinchuku")
+public class ShangpinchukuEntity<T> implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+
+	public ShangpinchukuEntity() {
+		
+	}
+	
+	public ShangpinchukuEntity(T t) {
+		try {
+			BeanUtils.copyProperties(this, t);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+	}
+	
+	//主键id
+
+	@TableId
+	private Long id;
+	// 商品名称
+
+					
+	private String shangpinmingcheng;
+	
+	//商品类型
+
+					
+	private String shangpinleixing;
+	
+	//客户姓名
+
+					
+	private String kehuxingming;
+	
+	// 商品数量
+
+					
+	private Integer shangpinshuliang;
+	
+	//出库时间
+
+				
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 		
+	private Date chukushijian;
+	
+	// 备注
+
+					
+	private String beizhu;
+	
+	// 员工工号
+
+					
+	private String yuangonggonghao;
+	
+	// 员工姓名
+
+					
+	private String yuangongxingming;
+	
+	// 是否审核
+
+					
+	private String sfsh;
+	
+	// 审核回复
+
+					
+	private String shhf;
+	
+	
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat
+	private Date addtime;
+
+	public Date getAddtime() {
+		return addtime;
+	}
+	public void setAddtime(Date addtime) {
+		this.addtime = addtime;
+	}
+
+	public Long getId() {
+		return id;
+	}
+
+	public void setId(Long id) {
+		this.id = id;
+	}
+	// 设置：商品名称
+
+	public void setShangpinmingcheng(String shangpinmingcheng) {
+		this.shangpinmingcheng = shangpinmingcheng;
+	}
+	//获取：商品名称
+
+	public String getShangpinmingcheng() {
+		return shangpinmingcheng;
+	}
+	// 设置：商品类型
+
+	public void setShangpinleixing(String shangpinleixing) {
+		this.shangpinleixing = shangpinleixing;
+	}
+	//获取：商品类型
+
+	public String getShangpinleixing() {
+		return shangpinleixing;
+	}
+	// 设置：客户姓名
+
+	public void setKehuxingming(String kehuxingming) {
+		this.kehuxingming = kehuxingming;
+	}
+	// 获取：客户姓名
+
+	public String getKehuxingming() {
+		return kehuxingming;
+	}
+	// 设置：商品数量
+
+	public void setShangpinshuliang(Integer shangpinshuliang) {
+		this.shangpinshuliang = shangpinshuliang;
+	}
+	//获取：商品数量
+
+	public Integer getShangpinshuliang() {
+		return shangpinshuliang;
+	}
+	// 设置：出库时间
+
+	public void setChukushijian(Date chukushijian) {
+		this.chukushijian = chukushijian;
+	}
+	// 获取：出库时间
+
+	public Date getChukushijian() {
+		return chukushijian;
+	}
+	// 设置：备注
+
+	public void setBeizhu(String beizhu) {
+		this.beizhu = beizhu;
+	}
+	// 获取：备注
+
+	public String getBeizhu() {
+		return beizhu;
+	}
+	// 设置：员工工号
+
+	public void setYuangonggonghao(String yuangonggonghao) {
+		this.yuangonggonghao = yuangonggonghao;
+	}
+	//获取：员工工号
+
+	public String getYuangonggonghao() {
+		return yuangonggonghao;
+	}
+	// 设置：员工姓名
+
+	public void setYuangongxingming(String yuangongxingming) {
+		this.yuangongxingming = yuangongxingming;
+	}
+	// 获取：员工姓名
+
+	public String getYuangongxingming() {
+		return yuangongxingming;
+	}
+	// 设置：是否审核
+
+	public void setSfsh(String sfsh) {
+		this.sfsh = sfsh;
+	}
+	// 获取：是否审核
+
+	public String getSfsh() {
+		return sfsh;
+	}
+	// 设置：审核回复
+
+	public void setShhf(String shhf) {
+		this.shhf = shhf;
+	}
+	//获取：审核回复
+
+	public String getShhf() {
+		return shhf;
+	}
+
+}

src/main/java/com/entity/ShangpinkucunEntity.java

@@ -0,0 +1,179 @@
+package com.entity;
+
+import com.baomidou.mybatisplus.annotations.TableId;
+import com.baomidou.mybatisplus.annotations.TableName;
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import java.lang.reflect.InvocationTargetException;
+
+import java.io.Serializable;
+import java.util.Date;
+import java.util.List;
+
+import org.springframework.format.annotation.DateTimeFormat;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import org.apache.commons.beanutils.BeanUtils;
+import com.baomidou.mybatisplus.annotations.TableField;
+import com.baomidou.mybatisplus.enums.FieldFill;
+import com.baomidou.mybatisplus.enums.IdType;
+
+
+// 商品库存
+ // 数据库通用操作实体类（普通增删改查）
+ // @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+@TableName("shangpinkucun")
+public class ShangpinkucunEntity<T> implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+
+	public ShangpinkucunEntity() {
+		
+	}
+	
+	public ShangpinkucunEntity(T t) {
+		try {
+			BeanUtils.copyProperties(this, t);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+	}
+	
+	// 主键id
+
+	@TableId
+	private Long id;
+	// 商品名称
+
+					
+	private String shangpinmingcheng;
+	
+	//商品类型
+
+					
+	private String shangpinleixing;
+	
+	// 商品数量
+
+					
+	private Integer shangpinshuliang;
+	
+	// 商品详情
+
+					
+	private String shangpinxiangqing;
+	
+	//存放位置
+
+					
+	private String cunfangweizhi;
+	
+	// 是否完好
+
+					
+	private String shifouwanhao;
+	
+	// 登记日期
+
+				
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 		
+	private Date dengjiriqi;
+	
+	
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat
+	private Date addtime;
+
+	public Date getAddtime() {
+		return addtime;
+	}
+	public void setAddtime(Date addtime) {
+		this.addtime = addtime;
+	}
+
+	public Long getId() {
+		return id;
+	}
+
+	public void setId(Long id) {
+		this.id = id;
+	}
+	// 设置：商品名称
+
+	public void setShangpinmingcheng(String shangpinmingcheng) {
+		this.shangpinmingcheng = shangpinmingcheng;
+	}
+	//获取：商品名称
+
+	public String getShangpinmingcheng() {
+		return shangpinmingcheng;
+	}
+	// 设置：商品类型
+
+	public void setShangpinleixing(String shangpinleixing) {
+		this.shangpinleixing = shangpinleixing;
+	}
+	// 获取：商品类型
+
+	public String getShangpinleixing() {
+		return shangpinleixing;
+	}
+	//设置：商品数量
+
+	public void setShangpinshuliang(Integer shangpinshuliang) {
+		this.shangpinshuliang = shangpinshuliang;
+	}
+	//获取：商品数量
+
+	public Integer getShangpinshuliang() {
+		return shangpinshuliang;
+	}
+	// 设置：商品详情
+
+	public void setShangpinxiangqing(String shangpinxiangqing) {
+		this.shangpinxiangqing = shangpinxiangqing;
+	}
+	// 获取：商品详情
+
+	public String getShangpinxiangqing() {
+		return shangpinxiangqing;
+	}
+	//设置：存放位置
+
+	public void setCunfangweizhi(String cunfangweizhi) {
+		this.cunfangweizhi = cunfangweizhi;
+	}
+	// 获取：存放位置
+
+	public String getCunfangweizhi() {
+		return cunfangweizhi;
+	}
+	//设置：是否完好
+
+	public void setShifouwanhao(String shifouwanhao) {
+		this.shifouwanhao = shifouwanhao;
+	}
+	//获取：是否完好
+
+	public String getShifouwanhao() {
+		return shifouwanhao;
+	}
+	// 设置：登记日期
+
+	public void setDengjiriqi(Date dengjiriqi) {
+		this.dengjiriqi = dengjiriqi;
+	}
+	// 获取：登记日期
+
+	public Date getDengjiriqi() {
+		return dengjiriqi;
+	}
+
+}

src/main/java/com/entity/ShangpinleixingEntity.java

@@ -0,0 +1,112 @@
+package com.entity;
+
+// 导入 MyBatis-Plus 的 TableId 注解，用于指定主键
+import com.baomidou.mybatisplus.annotations.TableId;
+// 导入 MyBatis-Plus 的 TableName 注解，用于指定实体类对应的数据库表名
+import com.baomidou.mybatisplus.annotations.TableName;
+// 导入验证注解，用于验证字符串不为空字符串
+import javax.validation.constraints.NotBlank;
+// 导入验证注解，用于验证集合或数组不为空
+import javax.validation.constraints.NotEmpty;
+// 导入验证注解，用于验证对象不为 null
+import javax.validation.constraints.NotNull;
+// 导入 Jackson 的 JsonIgnoreProperties 注解，用于在序列化和反序列化时忽略某些属性
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+// 导入反射调用可能抛出的异常类
+import java.lang.reflect.InvocationTargetException;
+// 导入 Serializable 接口，使该类的对象可以进行序列化和反序列化
+import java.io.Serializable;
+// 导入 Date 类，用于处理日期和时间
+import java.util.Date;
+// 导入 List 接口，用于表示一组对象
+import java.util.List;
+// 导入 Spring 的 DateTimeFormat 注解，用于指定日期的输入格式
+import org.springframework.format.annotation.DateTimeFormat;
+// 导入 Jackson 的 JsonFormat 注解，用于指定日期在 JSON 中的输出格式
+import com.fasterxml.jackson.annotation.JsonFormat;
+// 导入 Apache Commons BeanUtils 工具类，用于对象属性的复制
+import org.apache.commons.beanutils.BeanUtils;
+// 导入 MyBatis-Plus 的 TableField 注解，用于指定字段的填充策略等
+import com.baomidou.mybatisplus.annotations.TableField;
+// 导入 MyBatis-Plus 的 FieldFill 枚举，用于指定字段的填充时机
+import com.baomidou.mybatisplus.enums.FieldFill;
+// 导入 MyBatis-Plus 的 IdType 枚举，用于指定主键的生成类型
+import com.baomidou.mybatisplus.enums.IdType;
+
+// 商品类型
+//数据库通用操作实体类（普通增删改查）
+// @author
+// @email
+// @date 2021-04-24 15:19:31
+
+// 使用 TableName 注解指定该实体类对应的数据库表名为 "shangpinleixing"
+@TableName("shangpinleixing")
+// 定义一个泛型实体类，实现 Serializable 接口
+public class ShangpinleixingEntity<T> implements Serializable {
+	// 定义序列化版本号，用于在反序列化时验证类的版本一致性
+	private static final long serialVersionUID = 1L;
+
+	// 无参构造函数，用于创建一个空的 ShangpinleixingEntity 对象
+	public ShangpinleixingEntity() {
+	}
+
+	// 有参构造函数，接受一个泛型对象 t，将其属性复制到当前对象
+	public ShangpinleixingEntity(T t) {
+		try {
+			// 使用 BeanUtils 的 copyProperties 方法将传入对象 t 的属性复制到当前对象
+			BeanUtils.copyProperties(this, t);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			// 如果在属性复制过程中出现非法访问异常或反射调用目标方法异常，打印异常堆栈信息
+			// 在实际项目中，建议使用日志记录异常信息，而不是简单打印
+			e.printStackTrace();
+		}
+	}
+
+	// 主键id
+
+	// 使用 TableId 注解指定该字段为主键
+	@TableId
+	private Long id;
+
+	// 类型
+
+	private String leixing;
+
+	// 使用 JsonFormat 注解指定日期在 JSON 中的输出格式
+	@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
+	// 使用 DateTimeFormat 注解指定日期的输入格式
+	@DateTimeFormat
+	private Date addtime;
+
+	// 获取添加时间的方法
+	public Date getAddtime() {
+		return addtime;
+	}
+
+	// 设置添加时间的方法
+	public void setAddtime(Date addtime) {
+		this.addtime = addtime;
+	}
+
+	// 获取主键 id 的方法
+	public Long getId() {
+		return id;
+	}
+
+	// 设置主键 id 的方法
+	public void setId(Long id) {
+		this.id = id;
+	}
+
+	// 设置：类型
+
+	public void setLeixing(String leixing) {
+		this.leixing = leixing;
+	}
+
+	// 获取：类型
+
+	public String getLeixing() {
+		return leixing;
+	}
+}

src/main/java/com/entity/ShangpinrukuEntity.java

@@ -0,0 +1,239 @@
+package com.entity;
+
+import com.baomidou.mybatisplus.annotations.TableId;
+import com.baomidou.mybatisplus.annotations.TableName;
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import java.lang.reflect.InvocationTargetException;
+
+import java.io.Serializable;
+import java.util.Date;
+import java.util.List;
+
+import org.springframework.format.annotation.DateTimeFormat;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import org.apache.commons.beanutils.BeanUtils;
+import com.baomidou.mybatisplus.annotations.TableField;
+import com.baomidou.mybatisplus.enums.FieldFill;
+import com.baomidou.mybatisplus.enums.IdType;
+
+
+// 商品入库
+ //数据库通用操作实体类（普通增删改查）
+// @author
+// @email
+// @date 2021-04-24 15:19:31
+
+@TableName("shangpinruku")
+public class ShangpinrukuEntity<T> implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+
+	public ShangpinrukuEntity() {
+		
+	}
+	
+	public ShangpinrukuEntity(T t) {
+		try {
+			BeanUtils.copyProperties(this, t);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+	}
+	
+	// 主键id
+
+	@TableId
+	private Long id;
+	//商品名称
+
+					
+	private String shangpinmingcheng;
+	
+	// 商品类型
+
+					
+	private String shangpinleixing;
+	
+	// 供应商姓名
+
+					
+	private String gongyingshangxingming;
+	
+	// 商品数量
+
+					
+	private Integer shangpinshuliang;
+	
+	// 入库时间
+
+				
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 		
+	private Date rukushijian;
+	
+	// 是否完好
+
+					
+	private String shifouwanhao;
+	
+	// 备注
+
+					
+	private String beizhu;
+	
+	// 员工工号
+
+					
+	private String yuangonggonghao;
+	
+	// 员工姓名
+
+					
+	private String yuangongxingming;
+	
+	// 是否审核
+
+					
+	private String sfsh;
+	
+	// 审核回复
+
+					
+	private String shhf;
+	
+	
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat
+	private Date addtime;
+
+	public Date getAddtime() {
+		return addtime;
+	}
+	public void setAddtime(Date addtime) {
+		this.addtime = addtime;
+	}
+
+	public Long getId() {
+		return id;
+	}
+
+	public void setId(Long id) {
+		this.id = id;
+	}
+	//设置：商品名称
+
+	public void setShangpinmingcheng(String shangpinmingcheng) {
+		this.shangpinmingcheng = shangpinmingcheng;
+	}
+	// 获取：商品名称
+
+	public String getShangpinmingcheng() {
+		return shangpinmingcheng;
+	}
+	//设置：商品类型
+
+	public void setShangpinleixing(String shangpinleixing) {
+		this.shangpinleixing = shangpinleixing;
+	}
+	// 获取：商品类型
+
+	public String getShangpinleixing() {
+		return shangpinleixing;
+	}
+	// 设置：供应商姓名
+
+	public void setGongyingshangxingming(String gongyingshangxingming) {
+		this.gongyingshangxingming = gongyingshangxingming;
+	}
+	// 获取：供应商姓名
+
+	public String getGongyingshangxingming() {
+		return gongyingshangxingming;
+	}
+	// 设置：商品数量
+
+	public void setShangpinshuliang(Integer shangpinshuliang) {
+		this.shangpinshuliang = shangpinshuliang;
+	}
+	// 获取：商品数量
+
+	public Integer getShangpinshuliang() {
+		return shangpinshuliang;
+	}
+	//设置：入库时间
+
+	public void setRukushijian(Date rukushijian) {
+		this.rukushijian = rukushijian;
+	}
+	// 获取：入库时间
+
+	public Date getRukushijian() {
+		return rukushijian;
+	}
+	// 设置：是否完好
+
+	public void setShifouwanhao(String shifouwanhao) {
+		this.shifouwanhao = shifouwanhao;
+	}
+	// 获取：是否完好
+
+	public String getShifouwanhao() {
+		return shifouwanhao;
+	}
+	// 设置：备注
+
+	public void setBeizhu(String beizhu) {
+		this.beizhu = beizhu;
+	}
+	// 获取：备注
+
+	public String getBeizhu() {
+		return beizhu;
+	}
+	// 设置：员工工号
+
+	public void setYuangonggonghao(String yuangonggonghao) {
+		this.yuangonggonghao = yuangonggonghao;
+	}
+	//获取：员工工号
+
+	public String getYuangonggonghao() {
+		return yuangonggonghao;
+	}
+	//设置：员工姓名
+
+	public void setYuangongxingming(String yuangongxingming) {
+		this.yuangongxingming = yuangongxingming;
+	}
+	// 获取：员工姓名
+
+	public String getYuangongxingming() {
+		return yuangongxingming;
+	}
+	// 设置：是否审核
+
+	public void setSfsh(String sfsh) {
+		this.sfsh = sfsh;
+	}
+	// 获取：是否审核
+
+	public String getSfsh() {
+		return sfsh;
+	}
+	// 设置：审核回复
+
+	public void setShhf(String shhf) {
+		this.shhf = shhf;
+	}
+	// 获取：审核回复
+
+	public String getShhf() {
+		return shhf;
+	}
+
+}

src/main/java/com/entity/TokenEntity.java

@@ -0,0 +1,158 @@
+package com.entity;
+
+// 导入 Serializable 接口，实现该接口的类的对象可进行序列化和反序列化操作
+import java.io.Serializable;
+// 导入 Date 类，用于处理日期和时间
+import java.util.Date;
+
+// 导入 MyBatis-Plus 的 TableId 注解，用于指定主键
+import com.baomidou.mybatisplus.annotations.TableId;
+// 导入 MyBatis-Plus 的 TableName 注解，用于指定实体类对应的数据库表名
+import com.baomidou.mybatisplus.annotations.TableName;
+// 导入 MyBatis-Plus 的 IdType 枚举，用于指定主键的生成类型
+import com.baomidou.mybatisplus.enums.IdType;
+
+// token表
+ // 该类作为 token 表的实体类，用于映射数据库中 token 表的字段和操作
+
+// 使用 TableName 注解指定该实体类对应的数据库表名为 "token"
+@TableName("token")
+public class TokenEntity implements Serializable {
+	// 定义序列化版本号，用于在反序列化时验证类的版本一致性
+	private static final long serialVersionUID = 1L;
+
+	// 使用 TableId 注解指定该字段为主键，且主键生成类型为自动递增
+	@TableId(type = IdType.AUTO)
+	private Long id;
+
+	// 用户id
+
+	private Long userid;
+
+	// 用户名
+
+	private String username;
+
+	//表名
+
+	private String tablename;
+
+	// 角色
+
+	private String role;
+
+	// token
+
+	private String token;
+
+	// 过期时间
+
+	private Date expiratedtime;
+
+	// 新增时间
+
+	private Date addtime;
+
+	// 获取主键 ID 的方法
+	public Long getId() {
+		return id;
+	}
+
+	// 设置主键 ID 的方法
+	public void setId(Long id) {
+		this.id = id;
+	}
+
+	// 获取用户 ID 的方法
+	public Long getUserid() {
+		return userid;
+	}
+
+	// 设置用户 ID 的方法
+	public void setUserid(Long userid) {
+		this.userid = userid;
+	}
+
+	// 获取用户角色的方法
+	public String getRole() {
+		return role;
+	}
+
+	// 设置用户角色的方法
+	public void setRole(String role) {
+		this.role = role;
+	}
+
+	// 获取 token 的方法
+	public String getToken() {
+		return token;
+	}
+
+	// 获取表名的方法
+	public String getTablename() {
+		return tablename;
+	}
+
+	// 设置表名的方法
+	public void setTablename(String tablename) {
+		this.tablename = tablename;
+	}
+
+	// 设置 token 的方法
+	public void setToken(String token) {
+		this.token = token;
+	}
+
+	// 获取 token 过期时间的方法
+	public Date getExpiratedtime() {
+		return expiratedtime;
+	}
+
+	// 设置 token 过期时间的方法
+	public void setExpiratedtime(Date expiratedtime) {
+		this.expiratedtime = expiratedtime;
+	}
+
+	// 获取新增时间的方法
+	public Date getAddtime() {
+		return addtime;
+	}
+
+	// 设置新增时间的方法
+	public void setAddtime(Date addtime) {
+		this.addtime = addtime;
+	}
+
+	// 获取用户名的方法
+	public String getUsername() {
+		return username;
+	}
+
+	// 设置用户名的方法
+	public void setUsername(String username) {
+		this.username = username;
+	}
+
+	//有参构造函数
+	// @param userid 用户 ID
+	 //@param username 用户名
+	//@param tablename 表名
+	// @param role 用户角色
+	//@param token token 值
+	// @param expiratedtime token 过期时间
+
+	public TokenEntity(Long userid, String username, String tablename, String role, String token, Date expiratedtime) {
+		super();
+		this.userid = userid;
+		this.username = username;
+		this.tablename = tablename;
+		this.role = role;
+		this.token = token;
+		this.expiratedtime = expiratedtime;
+	}
+
+	// 无参构造函数
+
+	public TokenEntity() {
+	}
+}

src/main/java/com/entity/UserEntity.java

@@ -0,0 +1,92 @@
+package com.entity;
+
+// 导入 Serializable 接口，实现该接口的类的对象可以进行序列化和反序列化操作
+import java.io.Serializable;
+// 导入 Date 类，用于表示日期和时间
+import java.util.Date;
+
+// 导入 MyBatis-Plus 的 TableId 注解，用于指定主键
+import com.baomidou.mybatisplus.annotations.TableId;
+// 导入 MyBatis-Plus 的 TableName 注解，用于指定实体类对应的数据库表名
+import com.baomidou.mybatisplus.annotations.TableName;
+// 导入 MyBatis-Plus 的 IdType 枚举，用于指定主键的生成类型
+import com.baomidou.mybatisplus.enums.IdType;
+
+// 用户
+ //该类是一个实体类，用于映射数据库中的用户信息表
+
+// 使用 TableName 注解指定该实体类对应的数据库表名为 "users"
+@TableName("users")
+public class UserEntity implements Serializable {
+	// 定义序列化版本号，用于在反序列化时验证类的版本一致性
+	private static final long serialVersionUID = 1L;
+
+	// 使用 TableId 注解指定该字段为主键，且主键生成类型为自动递增
+	@TableId(type = IdType.AUTO)
+	private Long id;
+
+	// 用户账号
+
+	private String username;
+
+	// 密码
+
+	private String password;
+
+	//用户类型
+
+	private String role;
+
+	// 用户信息添加时间
+	private Date addtime;
+
+	// 获取用户账号的方法
+	public String getUsername() {
+		return username;
+	}
+
+	// 设置用户账号的方法
+	public void setUsername(String username) {
+		this.username = username;
+	}
+
+	// 获取用户密码的方法
+	public String getPassword() {
+		return password;
+	}
+
+	// 设置用户密码的方法
+	public void setPassword(String password) {
+		this.password = password;
+	}
+
+	// 获取用户类型的方法
+	public String getRole() {
+		return role;
+	}
+
+	// 设置用户类型的方法
+	public void setRole(String role) {
+		this.role = role;
+	}
+
+	// 获取用户信息添加时间的方法
+	public Date getAddtime() {
+		return addtime;
+	}
+
+	// 设置用户信息添加时间的方法
+	public void setAddtime(Date addtime) {
+		this.addtime = addtime;
+	}
+
+	// 获取用户主键 ID 的方法
+	public Long getId() {
+		return id;
+	}
+
+	// 设置用户主键 ID 的方法
+	public void setId(Long id) {
+		this.id = id;
+	}
+}

src/main/java/com/entity/YuangongEntity.java

@@ -0,0 +1,192 @@
+package com.entity;
+
+import com.baomidou.mybatisplus.annotations.TableId;
+import com.baomidou.mybatisplus.annotations.TableName;
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import java.lang.reflect.InvocationTargetException;
+
+import java.io.Serializable;
+import java.util.Date;
+import java.util.List;
+
+import org.springframework.format.annotation.DateTimeFormat;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import org.apache.commons.beanutils.BeanUtils;
+import com.baomidou.mybatisplus.annotations.TableField;
+import com.baomidou.mybatisplus.enums.FieldFill;
+import com.baomidou.mybatisplus.enums.IdType;
+
+
+// 员工
+// 数据库通用操作实体类（普通增删改查）
+ // @author
+ // @email
+// @date 2021-04-24 15:19:31
+
+@TableName("yuangong")
+public class YuangongEntity<T> implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+
+	public YuangongEntity() {
+		
+	}
+	
+	public YuangongEntity(T t) {
+		try {
+			BeanUtils.copyProperties(this, t);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+	}
+	
+	//主键id
+
+	@TableId
+	private Long id;
+	//员工工号
+
+					
+	private String yuangonggonghao;
+	
+	// 密码
+
+					
+	private String mima;
+	
+	//员工姓名
+
+					
+	private String yuangongxingming;
+	
+	//性别
+
+					
+	private String xingbie;
+	
+	//部门
+
+					
+	private String bumen;
+	
+	// 手机
+
+					
+	private String shouji;
+	
+	//邮箱
+
+					
+	private String youxiang;
+	
+	//身份证
+
+					
+	private String shenfenzheng;
+	
+	
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat
+	private Date addtime;
+
+	public Date getAddtime() {
+		return addtime;
+	}
+	public void setAddtime(Date addtime) {
+		this.addtime = addtime;
+	}
+
+	public Long getId() {
+		return id;
+	}
+
+	public void setId(Long id) {
+		this.id = id;
+	}
+	//设置：员工工号
+
+	public void setYuangonggonghao(String yuangonggonghao) {
+		this.yuangonggonghao = yuangonggonghao;
+	}
+	// 获取：员工工号
+
+	public String getYuangonggonghao() {
+		return yuangonggonghao;
+	}
+	// 设置：密码
+
+	public void setMima(String mima) {
+		this.mima = mima;
+	}
+	//获取：密码
+
+	public String getMima() {
+		return mima;
+	}
+	// 设置：员工姓名
+
+	public void setYuangongxingming(String yuangongxingming) {
+		this.yuangongxingming = yuangongxingming;
+	}
+	// 获取：员工姓名
+
+	public String getYuangongxingming() {
+		return yuangongxingming;
+	}
+	//设置：性别
+
+	public void setXingbie(String xingbie) {
+		this.xingbie = xingbie;
+	}
+	// 获取：性别
+
+	public String getXingbie() {
+		return xingbie;
+	}
+	//设置：部门
+
+	public void setBumen(String bumen) {
+		this.bumen = bumen;
+	}
+	// 获取：部门
+
+	public String getBumen() {
+		return bumen;
+	}
+	// 设置：手机
+
+	public void setShouji(String shouji) {
+		this.shouji = shouji;
+	}
+	//获取：手机
+
+	public String getShouji() {
+		return shouji;
+	}
+	//设置：邮箱
+
+	public void setYouxiang(String youxiang) {
+		this.youxiang = youxiang;
+	}
+	// 获取：邮箱
+
+	public String getYouxiang() {
+		return youxiang;
+	}
+	// 设置：身份证
+
+	public void setShenfenzheng(String shenfenzheng) {
+		this.shenfenzheng = shenfenzheng;
+	}
+	// 获取：身份证
+
+	public String getShenfenzheng() {
+		return shenfenzheng;
+	}
+
+}

src/main/java/com/entity/YuangongbaoxiaoEntity.java

@@ -0,0 +1,208 @@
+package com.entity;
+
+import com.baomidou.mybatisplus.annotations.TableId;
+import com.baomidou.mybatisplus.annotations.TableName;
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import java.lang.reflect.InvocationTargetException;
+
+import java.io.Serializable;
+import java.util.Date;
+import java.util.List;
+
+import org.springframework.format.annotation.DateTimeFormat;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import org.apache.commons.beanutils.BeanUtils;
+import com.baomidou.mybatisplus.annotations.TableField;
+import com.baomidou.mybatisplus.enums.FieldFill;
+import com.baomidou.mybatisplus.enums.IdType;
+
+
+//员工报销
+// 数据库通用操作实体类（普通增删改查）
+//@author
+ // @email
+// @date 2021-04-24 15:19:31
+
+@TableName("yuangongbaoxiao")
+public class YuangongbaoxiaoEntity<T> implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+
+	public YuangongbaoxiaoEntity() {
+		
+	}
+	
+	public YuangongbaoxiaoEntity(T t) {
+		try {
+			BeanUtils.copyProperties(this, t);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+	}
+	
+	// 主键id
+
+	@TableId
+	private Long id;
+	//员工工号
+
+					
+	private String yuangonggonghao;
+	
+	//员工姓名
+
+					
+	private String yuangongxingming;
+	
+	// 报销项目
+
+					
+	private String baoxiaoxiangmu;
+	
+	// 报销金额
+
+	private Integer baoxiaojine;
+	
+	// 申请日期
+
+				
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd")
+	@DateTimeFormat 		
+	private Date shenqingriqi;
+	
+	// 备注
+
+					
+	private String beizhu;
+	
+	// 管理工号
+
+					
+	private String guanligonghao;
+	
+	// 管理姓名
+
+					
+	private String guanlixingming;
+	
+	// 是否支付
+
+					
+	private String ispay;
+	
+	
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat
+	private Date addtime;
+
+	public Date getAddtime() {
+		return addtime;
+	}
+	public void setAddtime(Date addtime) {
+		this.addtime = addtime;
+	}
+
+	public Long getId() {
+		return id;
+	}
+
+	public void setId(Long id) {
+		this.id = id;
+	}
+	// 设置：员工工号
+
+	public void setYuangonggonghao(String yuangonggonghao) {
+		this.yuangonggonghao = yuangonggonghao;
+	}
+	//获取：员工工号
+
+	public String getYuangonggonghao() {
+		return yuangonggonghao;
+	}
+	//设置：员工姓名
+
+	public void setYuangongxingming(String yuangongxingming) {
+		this.yuangongxingming = yuangongxingming;
+	}
+	// 获取：员工姓名
+
+	public String getYuangongxingming() {
+		return yuangongxingming;
+	}
+	// 设置：报销项目
+
+	public void setBaoxiaoxiangmu(String baoxiaoxiangmu) {
+		this.baoxiaoxiangmu = baoxiaoxiangmu;
+	}
+	// 获取：报销项目
+
+	public String getBaoxiaoxiangmu() {
+		return baoxiaoxiangmu;
+	}
+	// 设置：报销金额
+
+	public void setBaoxiaojine(Integer baoxiaojine) {
+		this.baoxiaojine = baoxiaojine;
+	}
+	//获取：报销金额
+
+	public Integer getBaoxiaojine() {
+		return baoxiaojine;
+	}
+	// 设置：申请日期
+
+	public void setShenqingriqi(Date shenqingriqi) {
+		this.shenqingriqi = shenqingriqi;
+	}
+	//获取：申请日期
+
+	public Date getShenqingriqi() {
+		return shenqingriqi;
+	}
+	// 设置：备注
+
+	public void setBeizhu(String beizhu) {
+		this.beizhu = beizhu;
+	}
+	// 获取：备注
+
+	public String getBeizhu() {
+		return beizhu;
+	}
+	// 设置：管理工号
+
+	public void setGuanligonghao(String guanligonghao) {
+		this.guanligonghao = guanligonghao;
+	}
+	//获取：管理工号
+
+	public String getGuanligonghao() {
+		return guanligonghao;
+	}
+	// 设置：管理姓名
+
+	public void setGuanlixingming(String guanlixingming) {
+		this.guanlixingming = guanlixingming;
+	}
+	// 获取：管理姓名
+
+	public String getGuanlixingming() {
+		return guanlixingming;
+	}
+	//设置：是否支付
+
+	public void setIspay(String ispay) {
+		this.ispay = ispay;
+	}
+	//获取：是否支付
+
+	public String getIspay() {
+		return ispay;
+	}
+
+}

src/main/java/com/entity/YuangongjiaokuanEntity.java

@@ -0,0 +1,239 @@
+package com.entity;
+
+import com.baomidou.mybatisplus.annotations.TableId;
+import com.baomidou.mybatisplus.annotations.TableName;
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import java.lang.reflect.InvocationTargetException;
+
+import java.io.Serializable;
+import java.util.Date;
+import java.util.List;
+
+import org.springframework.format.annotation.DateTimeFormat;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import org.apache.commons.beanutils.BeanUtils;
+import com.baomidou.mybatisplus.annotations.TableField;
+import com.baomidou.mybatisplus.enums.FieldFill;
+import com.baomidou.mybatisplus.enums.IdType;
+
+
+// 员工缴款
+ // 数据库通用操作实体类（普通增删改查）
+ // @author
+ // @email
+// @date 2021-04-24 15:19:31
+
+@TableName("yuangongjiaokuan")
+public class YuangongjiaokuanEntity<T> implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+
+	public YuangongjiaokuanEntity() {
+		
+	}
+	
+	public YuangongjiaokuanEntity(T t) {
+		try {
+			BeanUtils.copyProperties(this, t);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+	}
+	
+	// 主键id
+
+	@TableId
+	private Long id;
+	// 员工工号
+
+					
+	private String yuangonggonghao;
+	
+	// 员工姓名
+
+					
+	private String yuangongxingming;
+	
+	// 缴费名称
+
+					
+	private String jiaofeimingcheng;
+	
+	// 缴款金额
+
+					
+	private Integer jiaokuanjine;
+	
+	// 缴款日期
+
+				
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd")
+	@DateTimeFormat 		
+	private Date jiaokuanriqi;
+	
+	//备注
+
+					
+	private String beizhu;
+	
+	// 管理工号
+
+					
+	private String guanligonghao;
+	
+	// 管理姓名
+
+					
+	private String guanlixingming;
+	
+	// 是否审核
+
+					
+	private String sfsh;
+	
+	// 审核回复
+
+					
+	private String shhf;
+	
+	//是否支付
+
+					
+	private String ispay;
+	
+	
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat
+	private Date addtime;
+
+	public Date getAddtime() {
+		return addtime;
+	}
+	public void setAddtime(Date addtime) {
+		this.addtime = addtime;
+	}
+
+	public Long getId() {
+		return id;
+	}
+
+	public void setId(Long id) {
+		this.id = id;
+	}
+	// 设置：员工工号
+
+	public void setYuangonggonghao(String yuangonggonghao) {
+		this.yuangonggonghao = yuangonggonghao;
+	}
+	// 获取：员工工号
+
+	public String getYuangonggonghao() {
+		return yuangonggonghao;
+	}
+	//设置：员工姓名
+
+	public void setYuangongxingming(String yuangongxingming) {
+		this.yuangongxingming = yuangongxingming;
+	}
+	//获取：员工姓名
+
+	public String getYuangongxingming() {
+		return yuangongxingming;
+	}
+	// 设置：缴费名称
+
+	public void setJiaofeimingcheng(String jiaofeimingcheng) {
+		this.jiaofeimingcheng = jiaofeimingcheng;
+	}
+	//获取：缴费名称
+
+	public String getJiaofeimingcheng() {
+		return jiaofeimingcheng;
+	}
+	//设置：缴款金额
+
+	public void setJiaokuanjine(Integer jiaokuanjine) {
+		this.jiaokuanjine = jiaokuanjine;
+	}
+	// 获取：缴款金额
+
+	public Integer getJiaokuanjine() {
+		return jiaokuanjine;
+	}
+	// 设置：缴款日期
+
+	public void setJiaokuanriqi(Date jiaokuanriqi) {
+		this.jiaokuanriqi = jiaokuanriqi;
+	}
+	//获取：缴款日期
+
+	public Date getJiaokuanriqi() {
+		return jiaokuanriqi;
+	}
+	//设置：备注
+
+	public void setBeizhu(String beizhu) {
+		this.beizhu = beizhu;
+	}
+	//获取：备注
+
+	public String getBeizhu() {
+		return beizhu;
+	}
+	//设置：管理工号
+
+	public void setGuanligonghao(String guanligonghao) {
+		this.guanligonghao = guanligonghao;
+	}
+	//获取：管理工号
+
+	public String getGuanligonghao() {
+		return guanligonghao;
+	}
+	// 设置：管理姓名
+
+	public void setGuanlixingming(String guanlixingming) {
+		this.guanlixingming = guanlixingming;
+	}
+	//获取：管理姓名
+
+	public String getGuanlixingming() {
+		return guanlixingming;
+	}
+	// 设置：是否审核
+
+	public void setSfsh(String sfsh) {
+		this.sfsh = sfsh;
+	}
+	// 获取：是否审核
+
+	public String getSfsh() {
+		return sfsh;
+	}
+	//设置：审核回复
+
+	public void setShhf(String shhf) {
+		this.shhf = shhf;
+	}
+	//获取：审核回复
+
+	public String getShhf() {
+		return shhf;
+	}
+	//设置：是否支付
+
+	public void setIspay(String ispay) {
+		this.ispay = ispay;
+	}
+	// 获取：是否支付
+
+	public String getIspay() {
+		return ispay;
+	}
+
+}

src/main/java/com/entity/YuangongxinchouEntity.java

@@ -0,0 +1,254 @@
+package com.entity;
+
+import com.baomidou.mybatisplus.annotations.TableId;
+import com.baomidou.mybatisplus.annotations.TableName;
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import java.lang.reflect.InvocationTargetException;
+
+import java.io.Serializable;
+import java.util.Date;
+import java.util.List;
+
+import org.springframework.format.annotation.DateTimeFormat;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import org.apache.commons.beanutils.BeanUtils;
+import com.baomidou.mybatisplus.annotations.TableField;
+import com.baomidou.mybatisplus.enums.FieldFill;
+import com.baomidou.mybatisplus.enums.IdType;
+
+
+//员工薪酬
+// 数据库通用操作实体类（普通增删改查）
+//@author
+ //@email
+ //@date 2021-04-24 15:19:31
+
+@TableName("yuangongxinchou")
+public class YuangongxinchouEntity<T> implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+
+	public YuangongxinchouEntity() {
+		
+	}
+	
+	public YuangongxinchouEntity(T t) {
+		try {
+			BeanUtils.copyProperties(this, t);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+	}
+	
+	// 主键id
+
+	@TableId
+	private Long id;
+	// 员工工号
+
+					
+	private String yuangonggonghao;
+	
+	//员工姓名
+
+					
+	private String yuangongxingming;
+	
+	// 基本工资
+
+					
+	private Integer jibengongzi;
+	
+	// 全勤奖励
+
+					
+	private Integer quanqinjiangli;
+	
+	// 绩效奖励
+
+					
+	private Integer jixiaojiangli;
+	
+	// 社保补助
+
+					
+	private Integer shebaobuzhu;
+	
+	// 扣款金额
+
+					
+	private Integer koukuanjine;
+	
+	//扣款事项
+
+					
+	private String koukuanshixiang;
+	
+	// 实发工资
+
+					
+	private String shifagongzi;
+	
+	// 日期
+
+				
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd")
+	@DateTimeFormat 		
+	private Date riqi;
+	
+	// 管理工号
+
+					
+	private String guanligonghao;
+	
+	// 管理姓名
+
+					
+	private String guanlixingming;
+	
+	
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat
+	private Date addtime;
+
+	public Date getAddtime() {
+		return addtime;
+	}
+	public void setAddtime(Date addtime) {
+		this.addtime = addtime;
+	}
+
+	public Long getId() {
+		return id;
+	}
+
+	public void setId(Long id) {
+		this.id = id;
+	}
+	// 设置：员工工号
+
+	public void setYuangonggonghao(String yuangonggonghao) {
+		this.yuangonggonghao = yuangonggonghao;
+	}
+	//获取：员工工号
+
+	public String getYuangonggonghao() {
+		return yuangonggonghao;
+	}
+	// 设置：员工姓名
+
+	public void setYuangongxingming(String yuangongxingming) {
+		this.yuangongxingming = yuangongxingming;
+	}
+	// 获取：员工姓名
+
+	public String getYuangongxingming() {
+		return yuangongxingming;
+	}
+	// 设置：基本工资
+
+	public void setJibengongzi(Integer jibengongzi) {
+		this.jibengongzi = jibengongzi;
+	}
+	// 获取：基本工资
+
+	public Integer getJibengongzi() {
+		return jibengongzi;
+	}
+	// 设置：全勤奖励
+
+	public void setQuanqinjiangli(Integer quanqinjiangli) {
+		this.quanqinjiangli = quanqinjiangli;
+	}
+	//获取：全勤奖励
+
+	public Integer getQuanqinjiangli() {
+		return quanqinjiangli;
+	}
+	// 设置：绩效奖励
+
+	public void setJixiaojiangli(Integer jixiaojiangli) {
+		this.jixiaojiangli = jixiaojiangli;
+	}
+	//获取：绩效奖励
+
+	public Integer getJixiaojiangli() {
+		return jixiaojiangli;
+	}
+	// 设置：社保补助
+
+	public void setShebaobuzhu(Integer shebaobuzhu) {
+		this.shebaobuzhu = shebaobuzhu;
+	}
+	// 获取：社保补助
+
+	public Integer getShebaobuzhu() {
+		return shebaobuzhu;
+	}
+	//设置：扣款金额
+
+	public void setKoukuanjine(Integer koukuanjine) {
+		this.koukuanjine = koukuanjine;
+	}
+	// 获取：扣款金额
+
+	public Integer getKoukuanjine() {
+		return koukuanjine;
+	}
+	//设置：扣款事项
+
+	public void setKoukuanshixiang(String koukuanshixiang) {
+		this.koukuanshixiang = koukuanshixiang;
+	}
+	// 获取：扣款事项
+
+	public String getKoukuanshixiang() {
+		return koukuanshixiang;
+	}
+	// 设置：实发工资
+
+	public void setShifagongzi(String shifagongzi) {
+		this.shifagongzi = shifagongzi;
+	}
+	// 获取：实发工资
+
+	public String getShifagongzi() {
+		return shifagongzi;
+	}
+	//设置：日期
+
+	public void setRiqi(Date riqi) {
+		this.riqi = riqi;
+	}
+	// 获取：日期
+
+	public Date getRiqi() {
+		return riqi;
+	}
+	//设置：管理工号
+
+	public void setGuanligonghao(String guanligonghao) {
+		this.guanligonghao = guanligonghao;
+	}
+	// 获取：管理工号
+
+	public String getGuanligonghao() {
+		return guanligonghao;
+	}
+	// 设置：管理姓名
+
+	public void setGuanlixingming(String guanlixingming) {
+		this.guanlixingming = guanlixingming;
+	}
+	//获取：管理姓名
+
+	public String getGuanlixingming() {
+		return guanlixingming;
+	}
+
+}

src/main/java/com/entity/model/ChengbenjieyuModel.java

@@ -0,0 +1,159 @@
+package com.entity.model;
+
+import com.entity.ChengbenjieyuEntity;
+
+import com.baomidou.mybatisplus.annotations.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import java.util.Date;
+import org.springframework.format.annotation.DateTimeFormat;
+import java.io.Serializable;
+ 
+
+
+ // 成本结余
+ // 接收传参的实体类
+ //（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
+ // 取自ModelAndView 的model名称
+ // @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+public class ChengbenjieyuModel  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+
+	 //收入项目
+
+	
+	private String shouruxiangmu;
+		
+
+	 // 收入金额
+
+	
+	private Integer shourujine;
+		
+
+	 // 支出项目
+
+	
+	private String zhichuxiangmu;
+		
+
+	 //支出金额
+
+	
+	private Integer zhichujine;
+		
+
+	 // 结余金额
+
+	
+	private String jieyujine;
+		
+
+	 // 日期
+
+		
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 
+	private Date riqi;
+				
+	
+
+	// 设置：收入项目
+
+	 
+	public void setShouruxiangmu(String shouruxiangmu) {
+		this.shouruxiangmu = shouruxiangmu;
+	}
+	
+
+	 // 获取：收入项目
+
+	public String getShouruxiangmu() {
+		return shouruxiangmu;
+	}
+				
+	
+
+	 //设置：收入金额
+
+	 
+	public void setShourujine(Integer shourujine) {
+		this.shourujine = shourujine;
+	}
+	
+
+	 //获取：收入金额
+
+	public Integer getShourujine() {
+		return shourujine;
+	}
+				
+	
+
+	 //设置：支出项目
+
+	 
+	public void setZhichuxiangmu(String zhichuxiangmu) {
+		this.zhichuxiangmu = zhichuxiangmu;
+	}
+	
+
+	// 获取：支出项目
+
+	public String getZhichuxiangmu() {
+		return zhichuxiangmu;
+	}
+				
+	
+
+	 //设置：支出金额
+
+	 
+	public void setZhichujine(Integer zhichujine) {
+		this.zhichujine = zhichujine;
+	}
+	
+
+	// 获取：支出金额
+
+	public Integer getZhichujine() {
+		return zhichujine;
+	}
+				
+	
+
+	 // 设置：结余金额
+
+	 
+	public void setJieyujine(String jieyujine) {
+		this.jieyujine = jieyujine;
+	}
+	
+
+	//获取：结余金额
+
+	public String getJieyujine() {
+		return jieyujine;
+	}
+				
+	
+
+	 // 设置：日期
+
+	 
+	public void setRiqi(Date riqi) {
+		this.riqi = riqi;
+	}
+	
+
+	 // 获取：日期
+
+	public Date getRiqi() {
+		return riqi;
+	}
+			
+}

src/main/java/com/entity/model/JizhangpingzhengModel.java

@@ -0,0 +1,141 @@
+package com.entity.model;
+
+import com.entity.JizhangpingzhengEntity;
+
+import com.baomidou.mybatisplus.annotations.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import java.util.Date;
+import org.springframework.format.annotation.DateTimeFormat;
+import java.io.Serializable;
+ 
+
+
+ //记账凭证
+ // 接收传参的实体类
+ //（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
+ // 取自ModelAndView 的model名称
+ // @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+public class JizhangpingzhengModel  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	// 凭证名称
+
+	
+	private String pingzhengmingcheng;
+		
+	// 类型
+
+	
+	private String leixing;
+		
+	// 凭证内容
+
+	
+	private String pingzhengneirong;
+		
+	// 登记日期
+
+		
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 
+	private Date dengjiriqi;
+		
+	// 附件
+
+	
+	private String fujian;
+		
+	// 备注
+
+	
+	private String beizhu;
+				
+	
+	//设置：凭证名称
+
+	 
+	public void setPingzhengmingcheng(String pingzhengmingcheng) {
+		this.pingzhengmingcheng = pingzhengmingcheng;
+	}
+	
+	// 获取：凭证名称
+
+	public String getPingzhengmingcheng() {
+		return pingzhengmingcheng;
+	}
+				
+	
+	// 设置：类型
+
+	 
+	public void setLeixing(String leixing) {
+		this.leixing = leixing;
+	}
+	
+	// 获取：类型
+
+	public String getLeixing() {
+		return leixing;
+	}
+				
+	
+	//设置：凭证内容
+
+	 
+	public void setPingzhengneirong(String pingzhengneirong) {
+		this.pingzhengneirong = pingzhengneirong;
+	}
+	
+	//获取：凭证内容
+
+	public String getPingzhengneirong() {
+		return pingzhengneirong;
+	}
+				
+	
+	//设置：登记日期
+
+	 
+	public void setDengjiriqi(Date dengjiriqi) {
+		this.dengjiriqi = dengjiriqi;
+	}
+	
+	// 获取：登记日期
+
+	public Date getDengjiriqi() {
+		return dengjiriqi;
+	}
+				
+	
+	// 设置：附件
+
+	 
+	public void setFujian(String fujian) {
+		this.fujian = fujian;
+	}
+	
+	// 获取：附件
+
+	public String getFujian() {
+		return fujian;
+	}
+				
+	
+	// 设置：备注
+
+	 
+	public void setBeizhu(String beizhu) {
+		this.beizhu = beizhu;
+	}
+	
+	// 获取：备注
+
+	public String getBeizhu() {
+		return beizhu;
+	}
+			
+}

src/main/java/com/entity/model/RijizhangModel.java

@@ -0,0 +1,158 @@
+package com.entity.model;
+
+import com.entity.RijizhangEntity;
+
+import com.baomidou.mybatisplus.annotations.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import java.util.Date;
+import org.springframework.format.annotation.DateTimeFormat;
+import java.io.Serializable;
+ 
+
+//日记账
+ //接收传参的实体类
+ //（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
+ // 取自ModelAndView 的model名称
+ // @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+public class RijizhangModel  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	// 日期
+
+		
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 
+	private Date riqi;
+		
+	// 摘要
+
+	
+	private String zhaiyao;
+		
+	// 收入
+
+	private Integer shouru;
+		
+	//支出
+
+	
+	private Integer zhichu;
+		
+	//金额
+
+	
+	private String jine;
+		
+	// 管理工号
+
+	
+	private String guanligonghao;
+		
+	// 管理姓名
+
+	
+	private String guanlixingming;
+				
+	
+	// 设置：日期
+
+	 
+	public void setRiqi(Date riqi) {
+		this.riqi = riqi;
+	}
+	
+	//获取：日期
+
+	public Date getRiqi() {
+		return riqi;
+	}
+				
+	
+	// 设置：摘要
+
+	 
+	public void setZhaiyao(String zhaiyao) {
+		this.zhaiyao = zhaiyao;
+	}
+	
+	// 获取：摘要
+
+	public String getZhaiyao() {
+		return zhaiyao;
+	}
+				
+	
+	//设置：收入
+
+	 
+	public void setShouru(Integer shouru) {
+		this.shouru = shouru;
+	}
+	
+	// 获取：收入
+
+	public Integer getShouru() {
+		return shouru;
+	}
+				
+	
+	// 设置：支出
+
+	 
+	public void setZhichu(Integer zhichu) {
+		this.zhichu = zhichu;
+	}
+	
+	// 获取：支出
+
+	public Integer getZhichu() {
+		return zhichu;
+	}
+				
+	
+	//设置：金额
+
+	 
+	public void setJine(String jine) {
+		this.jine = jine;
+	}
+	
+	// 获取：金额
+
+	public String getJine() {
+		return jine;
+	}
+				
+	
+	//设置：管理工号
+
+	 
+	public void setGuanligonghao(String guanligonghao) {
+		this.guanligonghao = guanligonghao;
+	}
+	
+	//获取：管理工号
+
+	public String getGuanligonghao() {
+		return guanligonghao;
+	}
+				
+	
+	// 设置：管理姓名
+
+	 
+	public void setGuanlixingming(String guanlixingming) {
+		this.guanlixingming = guanlixingming;
+	}
+	
+	//获取：管理姓名
+
+	public String getGuanlixingming() {
+		return guanlixingming;
+	}
+			
+}

src/main/java/com/entity/model/ShangpinchukuModel.java

@@ -0,0 +1,194 @@
+package com.entity.model;
+
+import com.entity.ShangpinchukuEntity;
+
+import com.baomidou.mybatisplus.annotations.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import java.util.Date;
+import org.springframework.format.annotation.DateTimeFormat;
+import java.io.Serializable;
+ 
+
+//商品出库
+// 接收传参的实体类
+ //（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
+ // 取自ModelAndView 的model名称
+ // @author
+ //@email
+ // @date 2021-04-24 15:19:31
+
+public class ShangpinchukuModel  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	// 商品类型
+
+	
+	private String shangpinleixing;
+		
+	// 客户姓名
+
+	
+	private String kehuxingming;
+		
+	//商品数量
+
+	private Integer shangpinshuliang;
+		
+	// 出库时间
+
+		
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 
+	private Date chukushijian;
+		
+	// 备注
+
+	private String beizhu;
+		
+	//员工工号
+
+	
+	private String yuangonggonghao;
+		
+	//员工姓名
+
+	
+	private String yuangongxingming;
+		
+	// 是否审核
+
+	
+	private String sfsh;
+		
+	// 审核回复
+
+	
+	private String shhf;
+				
+	
+	// 设置：商品类型
+
+	 
+	public void setShangpinleixing(String shangpinleixing) {
+		this.shangpinleixing = shangpinleixing;
+	}
+	
+	// 获取：商品类型
+
+	public String getShangpinleixing() {
+		return shangpinleixing;
+	}
+				
+	
+	// 设置：客户姓名
+
+	 
+	public void setKehuxingming(String kehuxingming) {
+		this.kehuxingming = kehuxingming;
+	}
+	
+	// 获取：客户姓名
+
+	public String getKehuxingming() {
+		return kehuxingming;
+	}
+				
+	
+	// 设置：商品数量
+
+	 
+	public void setShangpinshuliang(Integer shangpinshuliang) {
+		this.shangpinshuliang = shangpinshuliang;
+	}
+	
+	// 获取：商品数量
+
+	public Integer getShangpinshuliang() {
+		return shangpinshuliang;
+	}
+				
+	
+	//设置：出库时间
+
+	 
+	public void setChukushijian(Date chukushijian) {
+		this.chukushijian = chukushijian;
+	}
+	
+	// 获取：出库时间
+
+	public Date getChukushijian() {
+		return chukushijian;
+	}
+				
+	
+	//设置：备注
+
+	 
+	public void setBeizhu(String beizhu) {
+		this.beizhu = beizhu;
+	}
+	
+	// 获取：备注
+
+	public String getBeizhu() {
+		return beizhu;
+	}
+				
+	
+	// 设置：员工工号
+
+	public void setYuangonggonghao(String yuangonggonghao) {
+		this.yuangonggonghao = yuangonggonghao;
+	}
+	
+	// 获取：员工工号
+
+	public String getYuangonggonghao() {
+		return yuangonggonghao;
+	}
+				
+	
+	//设置：员工姓名
+
+	 
+	public void setYuangongxingming(String yuangongxingming) {
+		this.yuangongxingming = yuangongxingming;
+	}
+	
+	//获取：员工姓名
+
+	public String getYuangongxingming() {
+		return yuangongxingming;
+	}
+				
+	
+	// 设置：是否审核
+
+	 
+	public void setSfsh(String sfsh) {
+		this.sfsh = sfsh;
+	}
+	
+	//获取：是否审核
+
+	public String getSfsh() {
+		return sfsh;
+	}
+				
+	
+	// 设置：审核回复
+
+	 
+	public void setShhf(String shhf) {
+		this.shhf = shhf;
+	}
+	
+	// 获取：审核回复
+
+	public String getShhf() {
+		return shhf;
+	}
+			
+}

src/main/java/com/entity/model/ShangpinkucunModel.java

@@ -0,0 +1,140 @@
+package com.entity.model;
+
+import com.entity.ShangpinkucunEntity;
+
+import com.baomidou.mybatisplus.annotations.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import java.util.Date;
+import org.springframework.format.annotation.DateTimeFormat;
+import java.io.Serializable;
+ 
+
+//商品库存
+// 接收传参的实体类
+//（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
+// 取自ModelAndView 的model名称
+// @author
+// @email
+ // @date 2021-04-24 15:19:31
+
+public class ShangpinkucunModel  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	//商品类型
+
+	
+	private String shangpinleixing;
+		
+	// 商品数量
+
+	
+	private Integer shangpinshuliang;
+		
+	//商品详情
+
+	
+	private String shangpinxiangqing;
+		
+	//存放位置
+
+	
+	private String cunfangweizhi;
+		
+	// 是否完好
+
+	
+	private String shifouwanhao;
+		
+	//登记日期
+
+		
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 
+	private Date dengjiriqi;
+				
+	
+	// 设置：商品类型
+
+	 
+	public void setShangpinleixing(String shangpinleixing) {
+		this.shangpinleixing = shangpinleixing;
+	}
+	
+	// 获取：商品类型
+
+	public String getShangpinleixing() {
+		return shangpinleixing;
+	}
+				
+	
+	// 设置：商品数量
+
+	 
+	public void setShangpinshuliang(Integer shangpinshuliang) {
+		this.shangpinshuliang = shangpinshuliang;
+	}
+	
+	// 获取：商品数量
+
+	public Integer getShangpinshuliang() {
+		return shangpinshuliang;
+	}
+				
+	
+	// 设置：商品详情
+
+	 
+	public void setShangpinxiangqing(String shangpinxiangqing) {
+		this.shangpinxiangqing = shangpinxiangqing;
+	}
+	
+	// 获取：商品详情
+
+	public String getShangpinxiangqing() {
+		return shangpinxiangqing;
+	}
+				
+	
+	// 设置：存放位置
+
+	 
+	public void setCunfangweizhi(String cunfangweizhi) {
+		this.cunfangweizhi = cunfangweizhi;
+	}
+	
+	//获取：存放位置
+
+	public String getCunfangweizhi() {
+		return cunfangweizhi;
+	}
+				
+	
+	//设置：是否完好
+
+	 
+	public void setShifouwanhao(String shifouwanhao) {
+		this.shifouwanhao = shifouwanhao;
+	}
+	
+	// 获取：是否完好
+
+	public String getShifouwanhao() {
+		return shifouwanhao;
+	}
+				
+	
+	// 设置：登记日期
+
+	 
+	public void setDengjiriqi(Date dengjiriqi) {
+		this.dengjiriqi = dengjiriqi;
+	}
+	
+	// 获取：登记日期
+
+	public Date getDengjiriqi() {
+		return dengjiriqi;
+	}
+			
+}

src/main/java/com/entity/model/ShangpinleixingModel.java

@@ -0,0 +1,23 @@
+package com.entity.model;
+
+import com.entity.ShangpinleixingEntity;
+
+import com.baomidou.mybatisplus.annotations.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import java.util.Date;
+import org.springframework.format.annotation.DateTimeFormat;
+import java.io.Serializable;
+ 
+
+// 商品类型
+//（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
+ // 取自ModelAndView 的model名称
+ // @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+public class ShangpinleixingModel  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 				
+}

src/main/java/com/entity/model/ShangpinrukuModel.java

@@ -0,0 +1,214 @@
+package com.entity.model;
+
+import com.entity.ShangpinrukuEntity;
+
+import com.baomidou.mybatisplus.annotations.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import java.util.Date;
+import org.springframework.format.annotation.DateTimeFormat;
+import java.io.Serializable;
+ 
+
+// 商品入库
+ // 接收传参的实体类
+ //（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
+// @author
+ // @email
+// @date 2021-04-24 15:19:31
+
+public class ShangpinrukuModel  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	// 商品类型
+
+	
+	private String shangpinleixing;
+		
+	//供应商姓名
+
+	
+	private String gongyingshangxingming;
+		
+	// 商品数量
+
+	
+	private Integer shangpinshuliang;
+		
+	//入库时间
+
+		
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 
+	private Date rukushijian;
+		
+	//是否完好
+
+	
+	private String shifouwanhao;
+		
+	// 备注
+
+	
+	private String beizhu;
+		
+	//员工工号
+
+	
+	private String yuangonggonghao;
+		
+	//员工姓名
+
+	
+	private String yuangongxingming;
+		
+	// 是否审核
+
+	
+	private String sfsh;
+		
+	// 审核回复
+
+	
+	private String shhf;
+				
+	
+	//设置：商品类型
+
+	 
+	public void setShangpinleixing(String shangpinleixing) {
+		this.shangpinleixing = shangpinleixing;
+	}
+	
+	// 获取：商品类型
+
+	public String getShangpinleixing() {
+		return shangpinleixing;
+	}
+				
+	
+	//设置：供应商姓名
+
+	 
+	public void setGongyingshangxingming(String gongyingshangxingming) {
+		this.gongyingshangxingming = gongyingshangxingming;
+	}
+	
+	// 获取：供应商姓名
+
+	public String getGongyingshangxingming() {
+		return gongyingshangxingming;
+	}
+				
+	
+	//设置：商品数量
+
+	public void setShangpinshuliang(Integer shangpinshuliang) {
+		this.shangpinshuliang = shangpinshuliang;
+	}
+	
+	//获取：商品数量
+
+	public Integer getShangpinshuliang() {
+		return shangpinshuliang;
+	}
+				
+	
+	//设置：入库时间
+
+	 
+	public void setRukushijian(Date rukushijian) {
+		this.rukushijian = rukushijian;
+	}
+	
+	// 获取：入库时间
+
+	public Date getRukushijian() {
+		return rukushijian;
+	}
+				
+	
+	// 设置：是否完好
+
+	 
+	public void setShifouwanhao(String shifouwanhao) {
+		this.shifouwanhao = shifouwanhao;
+	}
+	
+	//获取：是否完好
+
+	public String getShifouwanhao() {
+		return shifouwanhao;
+	}
+				
+	
+	//设置：备注
+
+	 
+	public void setBeizhu(String beizhu) {
+		this.beizhu = beizhu;
+	}
+	
+	//获取：备注
+
+	public String getBeizhu() {
+		return beizhu;
+	}
+				
+	
+	//设置：员工工号
+
+	 
+	public void setYuangonggonghao(String yuangonggonghao) {
+		this.yuangonggonghao = yuangonggonghao;
+	}
+	
+	//获取：员工工号
+
+	public String getYuangonggonghao() {
+		return yuangonggonghao;
+	}
+				
+	
+	//设置：员工姓名
+
+	 
+	public void setYuangongxingming(String yuangongxingming) {
+		this.yuangongxingming = yuangongxingming;
+	}
+	
+	//获取：员工姓名
+
+	public String getYuangongxingming() {
+		return yuangongxingming;
+	}
+				
+	
+	//设置：是否审核
+
+	 
+	public void setSfsh(String sfsh) {
+		this.sfsh = sfsh;
+	}
+	
+	//获取：是否审核
+
+	public String getSfsh() {
+		return sfsh;
+	}
+				
+	
+	//设置：审核回复
+
+	 
+	public void setShhf(String shhf) {
+		this.shhf = shhf;
+	}
+	
+	// 获取：审核回复
+
+	public String getShhf() {
+		return shhf;
+	}
+			
+}

src/main/java/com/entity/model/YuangongModel.java

@@ -0,0 +1,156 @@
+package com.entity.model;
+
+import com.entity.YuangongEntity;
+
+import com.baomidou.mybatisplus.annotations.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import java.util.Date;
+import org.springframework.format.annotation.DateTimeFormat;
+import java.io.Serializable;
+ 
+
+// 员工
+ // 接收传参的实体类
+ //（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
+// 取自ModelAndView 的model名称
+ // @author
+ // @email
+// @date 2021-04-24 15:19:31
+
+public class YuangongModel  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	// 密码
+
+	
+	private String mima;
+		
+	// 员工姓名
+
+	
+	private String yuangongxingming;
+		
+	// 性别
+
+	
+	private String xingbie;
+		
+	//部门
+
+	
+	private String bumen;
+		
+	//手机
+
+	
+	private String shouji;
+		
+	// 邮箱
+
+	
+	private String youxiang;
+		
+	//身份证
+
+	
+	private String shenfenzheng;
+				
+	
+	//设置：密码
+
+	 
+	public void setMima(String mima) {
+		this.mima = mima;
+	}
+	
+	// 获取：密码
+
+	public String getMima() {
+		return mima;
+	}
+				
+	
+	//设置：员工姓名
+
+	 
+	public void setYuangongxingming(String yuangongxingming) {
+		this.yuangongxingming = yuangongxingming;
+	}
+	
+	//获取：员工姓名
+
+	public String getYuangongxingming() {
+		return yuangongxingming;
+	}
+				
+	
+	// 设置：性别
+
+	 
+	public void setXingbie(String xingbie) {
+		this.xingbie = xingbie;
+	}
+	
+	// 获取：性别
+
+	public String getXingbie() {
+		return xingbie;
+	}
+				
+	
+	// 设置：部门
+
+	 
+	public void setBumen(String bumen) {
+		this.bumen = bumen;
+	}
+	
+	//获取：部门
+
+	public String getBumen() {
+		return bumen;
+	}
+				
+	
+	// 设置：手机
+
+	public void setShouji(String shouji) {
+		this.shouji = shouji;
+	}
+	
+	// 获取：手机
+
+	public String getShouji() {
+		return shouji;
+	}
+				
+	
+	// 设置：邮箱
+
+	 
+	public void setYouxiang(String youxiang) {
+		this.youxiang = youxiang;
+	}
+	
+	// 获取：邮箱
+
+	public String getYouxiang() {
+		return youxiang;
+	}
+				
+	
+	// 设置：身份证
+
+	 
+	public void setShenfenzheng(String shenfenzheng) {
+		this.shenfenzheng = shenfenzheng;
+	}
+	
+	// 获取：身份证
+
+	public String getShenfenzheng() {
+		return shenfenzheng;
+	}
+			
+}

src/main/java/com/entity/model/YuangongbaoxiaoModel.java

@@ -0,0 +1,179 @@
+package com.entity.model;
+
+import com.entity.YuangongbaoxiaoEntity;
+
+import com.baomidou.mybatisplus.annotations.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import java.util.Date;
+import org.springframework.format.annotation.DateTimeFormat;
+import java.io.Serializable;
+ 
+
+//员工报销
+// 接收传参的实体类
+ //（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
+ //取自ModelAndView 的model名称
+ //@author
+ //@email
+ //@date 2021-04-24 15:19:31
+
+public class YuangongbaoxiaoModel  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	// 员工姓名
+
+	
+	private String yuangongxingming;
+		
+	//报销项目
+
+	
+	private String baoxiaoxiangmu;
+		
+	//报销金额
+
+	
+	private Integer baoxiaojine;
+		
+	// 申请日期
+
+		
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 
+	private Date shenqingriqi;
+		
+	//备注
+
+	
+	private String beizhu;
+		
+	//管理工号
+
+	
+	private String guanligonghao;
+		
+	//管理姓名
+
+	
+	private String guanlixingming;
+		
+	//是否支付
+
+	
+	private String ispay;
+				
+	
+	// 设置：员工姓名
+
+	 
+	public void setYuangongxingming(String yuangongxingming) {
+		this.yuangongxingming = yuangongxingming;
+	}
+	
+	//获取：员工姓名
+
+	public String getYuangongxingming() {
+		return yuangongxingming;
+	}
+				
+	
+	//设置：报销项目
+
+	 
+	public void setBaoxiaoxiangmu(String baoxiaoxiangmu) {
+		this.baoxiaoxiangmu = baoxiaoxiangmu;
+	}
+	
+	//获取：报销项目
+
+	public String getBaoxiaoxiangmu() {
+		return baoxiaoxiangmu;
+	}
+				
+	
+	// 设置：报销金额
+
+	 
+	public void setBaoxiaojine(Integer baoxiaojine) {
+		this.baoxiaojine = baoxiaojine;
+	}
+	
+	//获取：报销金额
+
+	public Integer getBaoxiaojine() {
+		return baoxiaojine;
+	}
+				
+	
+	// 设置：申请日期
+
+	 
+	public void setShenqingriqi(Date shenqingriqi) {
+		this.shenqingriqi = shenqingriqi;
+	}
+	
+	//获取：申请日期
+
+	public Date getShenqingriqi() {
+		return shenqingriqi;
+	}
+				
+	
+	// 设置：备注
+
+	 
+	public void setBeizhu(String beizhu) {
+		this.beizhu = beizhu;
+	}
+	
+	// 获取：备注
+
+	public String getBeizhu() {
+		return beizhu;
+	}
+				
+	
+	//设置：管理工号
+
+	 
+	public void setGuanligonghao(String guanligonghao) {
+		this.guanligonghao = guanligonghao;
+	}
+	
+	// 获取：管理工号
+
+	public String getGuanligonghao() {
+		return guanligonghao;
+	}
+				
+	
+	// 设置：管理姓名
+
+	 
+	public void setGuanlixingming(String guanlixingming) {
+		this.guanlixingming = guanlixingming;
+	}
+	
+	/**
+	 * 获取：管理姓名
+	 */
+	public String getGuanlixingming() {
+		return guanlixingming;
+	}
+				
+	
+	//设置：是否支付
+
+	 
+	public void setIspay(String ispay) {
+		this.ispay = ispay;
+	}
+	
+	//获取：是否支付
+
+	public String getIspay() {
+		return ispay;
+	}
+			
+}

src/main/java/com/entity/model/YuangongjiaokuanModel.java

@@ -0,0 +1,215 @@
+package com.entity.model;
+
+import com.entity.YuangongjiaokuanEntity;
+
+import com.baomidou.mybatisplus.annotations.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import java.util.Date;
+import org.springframework.format.annotation.DateTimeFormat;
+import java.io.Serializable;
+ 
+
+//员工缴款
+ //接收传参的实体类
+ //（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
+//  取自ModelAndView 的model名称
+ // @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+public class YuangongjiaokuanModel  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	// 员工姓名
+
+	
+	private String yuangongxingming;
+		
+	// 缴费名称
+
+	
+	private String jiaofeimingcheng;
+		
+	//缴款金额
+
+	
+	private Integer jiaokuanjine;
+		
+	//缴款日期
+
+		
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 
+	private Date jiaokuanriqi;
+		
+	// 备注
+
+	
+	private String beizhu;
+		
+	// 管理工号
+
+	
+	private String guanligonghao;
+		
+	// 管理姓名
+
+	
+	private String guanlixingming;
+		
+	// 是否审核
+
+	
+	private String sfsh;
+		
+	// 审核回复
+
+	
+	private String shhf;
+		
+	// 是否支付
+
+	
+	private String ispay;
+				
+	
+	// 设置：员工姓名
+
+	 
+	public void setYuangongxingming(String yuangongxingming) {
+		this.yuangongxingming = yuangongxingming;
+	}
+	
+	// 获取：员工姓名
+
+	public String getYuangongxingming() {
+		return yuangongxingming;
+	}
+				
+	
+	// 设置：缴费名称
+	 
+	public void setJiaofeimingcheng(String jiaofeimingcheng) {
+		this.jiaofeimingcheng = jiaofeimingcheng;
+	}
+	
+	// 获取：缴费名称
+
+	public String getJiaofeimingcheng() {
+		return jiaofeimingcheng;
+	}
+				
+	
+	// 设置：缴款金额
+
+	 
+	public void setJiaokuanjine(Integer jiaokuanjine) {
+		this.jiaokuanjine = jiaokuanjine;
+	}
+	
+	// 获取：缴款金额
+
+	public Integer getJiaokuanjine() {
+		return jiaokuanjine;
+	}
+				
+	
+	// 设置：缴款日期
+
+	 
+	public void setJiaokuanriqi(Date jiaokuanriqi) {
+		this.jiaokuanriqi = jiaokuanriqi;
+	}
+	
+	//获取：缴款日期
+
+	public Date getJiaokuanriqi() {
+		return jiaokuanriqi;
+	}
+				
+	
+	// 设置：备注
+
+	 
+	public void setBeizhu(String beizhu) {
+		this.beizhu = beizhu;
+	}
+	
+	//获取：备注
+
+	public String getBeizhu() {
+		return beizhu;
+	}
+				
+	
+	// 设置：管理工号
+
+	 
+	public void setGuanligonghao(String guanligonghao) {
+		this.guanligonghao = guanligonghao;
+	}
+	
+	// 获取：管理工号
+
+	public String getGuanligonghao() {
+		return guanligonghao;
+	}
+				
+	
+	//设置：管理姓名
+
+	 
+	public void setGuanlixingming(String guanlixingming) {
+		this.guanlixingming = guanlixingming;
+	}
+	
+	//获取：管理姓名
+
+	public String getGuanlixingming() {
+		return guanlixingming;
+	}
+				
+	
+	//设置：是否审核
+
+	 
+	public void setSfsh(String sfsh) {
+		this.sfsh = sfsh;
+	}
+	
+	// 获取：是否审核
+
+	public String getSfsh() {
+		return sfsh;
+	}
+				
+	
+	// 设置：审核回复
+
+	 
+	public void setShhf(String shhf) {
+		this.shhf = shhf;
+	}
+	
+	//获取：审核回复
+
+	public String getShhf() {
+		return shhf;
+	}
+				
+	
+	//设置：是否支付
+
+	 
+	public void setIspay(String ispay) {
+		this.ispay = ispay;
+	}
+	
+	//获取：是否支付
+
+	public String getIspay() {
+		return ispay;
+	}
+			
+}

src/main/java/com/entity/model/YuangongxinchouModel.java

@@ -0,0 +1,235 @@
+package com.entity.model;
+
+import com.entity.YuangongxinchouEntity;
+
+import com.baomidou.mybatisplus.annotations.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import java.util.Date;
+import org.springframework.format.annotation.DateTimeFormat;
+import java.io.Serializable;
+ 
+
+// 员工薪酬
+ // 接收传参的实体类
+ //（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
+ // 取自ModelAndView 的model名称
+ // @author
+// @email
+ // @date 2021-04-24 15:19:31
+
+public class YuangongxinchouModel  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	//员工姓名
+
+	
+	private String yuangongxingming;
+		
+	// 基本工资
+
+	
+	private Integer jibengongzi;
+		
+	// 全勤奖励
+
+	
+	private Integer quanqinjiangli;
+		
+	// 绩效奖励
+
+	
+	private Integer jixiaojiangli;
+		
+	//社保补助
+
+	
+	private Integer shebaobuzhu;
+		
+	// 扣款金额
+
+	
+	private Integer koukuanjine;
+		
+	// 扣款事项
+
+	
+	private String koukuanshixiang;
+		
+	// 实发工资
+
+	
+	private String shifagongzi;
+		
+	// 日期
+
+		
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 
+	private Date riqi;
+		
+	// 管理工号
+
+	
+	private String guanligonghao;
+		
+	//管理姓名
+
+	
+	private String guanlixingming;
+				
+	
+	// 设置：员工姓名
+
+	 
+	public void setYuangongxingming(String yuangongxingming) {
+		this.yuangongxingming = yuangongxingming;
+	}
+	
+	// 获取：员工姓名
+
+	public String getYuangongxingming() {
+		return yuangongxingming;
+	}
+				
+	
+	//设置：基本工资
+
+	 
+	public void setJibengongzi(Integer jibengongzi) {
+		this.jibengongzi = jibengongzi;
+	}
+	
+	//获取：基本工资
+
+	public Integer getJibengongzi() {
+		return jibengongzi;
+	}
+				
+	
+	// 设置：全勤奖励
+
+	 
+	public void setQuanqinjiangli(Integer quanqinjiangli) {
+		this.quanqinjiangli = quanqinjiangli;
+	}
+	
+	//获取：全勤奖励
+
+	public Integer getQuanqinjiangli() {
+		return quanqinjiangli;
+	}
+				
+	
+	// 设置：绩效奖励
+
+	 
+	public void setJixiaojiangli(Integer jixiaojiangli) {
+		this.jixiaojiangli = jixiaojiangli;
+	}
+	
+	// 获取：绩效奖励
+
+	public Integer getJixiaojiangli() {
+		return jixiaojiangli;
+	}
+				
+	
+	// 设置：社保补助
+
+	 
+	public void setShebaobuzhu(Integer shebaobuzhu) {
+		this.shebaobuzhu = shebaobuzhu;
+	}
+	
+	//获取：社保补助
+
+	public Integer getShebaobuzhu() {
+		return shebaobuzhu;
+	}
+				
+	
+	//设置：扣款金额
+
+	 
+	public void setKoukuanjine(Integer koukuanjine) {
+		this.koukuanjine = koukuanjine;
+	}
+	
+	// 获取：扣款金额
+
+	public Integer getKoukuanjine() {
+		return koukuanjine;
+	}
+				
+	
+	//设置：扣款事项
+
+	 
+	public void setKoukuanshixiang(String koukuanshixiang) {
+		this.koukuanshixiang = koukuanshixiang;
+	}
+	
+	//获取：扣款事项
+
+	public String getKoukuanshixiang() {
+		return koukuanshixiang;
+	}
+				
+	
+	// 设置：实发工资
+
+	 
+	public void setShifagongzi(String shifagongzi) {
+		this.shifagongzi = shifagongzi;
+	}
+	
+	// 获取：实发工资
+
+	public String getShifagongzi() {
+		return shifagongzi;
+	}
+				
+	
+	//设置：日期
+
+	 
+	public void setRiqi(Date riqi) {
+		this.riqi = riqi;
+	}
+	
+	// 获取：日期
+
+	public Date getRiqi() {
+		return riqi;
+	}
+				
+	
+	// 设置：管理工号
+
+	 
+	public void setGuanligonghao(String guanligonghao) {
+		this.guanligonghao = guanligonghao;
+	}
+	
+	// 获取：管理工号
+
+	public String getGuanligonghao() {
+		return guanligonghao;
+	}
+				
+	
+	// 设置：管理姓名
+
+	 
+	public void setGuanlixingming(String guanlixingming) {
+		this.guanlixingming = guanlixingming;
+	}
+	
+	//获取：管理姓名
+
+	public String getGuanlixingming() {
+		return guanlixingming;
+	}
+			
+}

src/main/java/com/entity/view/ChengbenjieyuView.java

@@ -0,0 +1,48 @@
+package com.entity.view;
+
+// 引入成本结余实体类
+import com.entity.ChengbenjieyuEntity;
+
+// MyBatis-Plus 注解，指定该实体类对应的数据库表名
+import com.baomidou.mybatisplus.annotations.TableName;
+// Apache Commons BeanUtils 工具类，用于对象属性的复制
+import org.apache.commons.beanutils.BeanUtils;
+// 反射调用方法时可能抛出的异常类
+import java.lang.reflect.InvocationTargetException;
+// 实现 Serializable 接口，使该类的对象可以被序列化
+import java.io.Serializable;
+
+// 成本结余
+// 后端返回视图实体辅助类
+// （通常后端关联的表或者自定义的字段需要返回使用）
+// @author
+// @email
+ // @date 2021-04-24 15:19:31
+
+// 指定该视图实体类对应数据库中的表名为 "chengbenjieyu"
+@TableName("chengbenjieyu")
+// 继承自 ChengbenjieyuEntity，同时实现 Serializable 接口
+public class ChengbenjieyuView extends ChengbenjieyuEntity implements Serializable {
+	// 序列化版本号，用于在反序列化时验证版本一致性
+	private static final long serialVersionUID = 1L;
+
+	// 无参构造函数，用于创建一个空的 ChengbenjieyuView 对象
+
+	public ChengbenjieyuView() {
+	}
+
+	// 有参构造函数，根据传入的 ChengbenjieyuEntity 对象创建 ChengbenjieyuView 对象
+	// @param chengbenjieyuEntity 成本结余实体对象
+
+	public ChengbenjieyuView(ChengbenjieyuEntity chengbenjieyuEntity) {
+		try {
+			// 使用 BeanUtils.copyProperties 方法将传入的 chengbenjieyuEntity 对象的属性复制到当前对象
+			// 这样可以方便地将实体类的属性值传递给视图类
+			BeanUtils.copyProperties(this, chengbenjieyuEntity);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			// 当出现非法访问异常或反射调用目标方法异常时，打印异常堆栈信息
+			// 这里的异常处理可以进一步完善，例如记录日志或抛出自定义异常
+			e.printStackTrace();
+		}
+	}
+}

src/main/java/com/entity/view/JizhangpingzhengView.java

@@ -0,0 +1,45 @@
+package com.entity.view;
+
+// 引入记账凭证实体类，该实体类可能包含了与记账凭证相关的属性和方法
+import com.entity.JizhangpingzhengEntity;
+
+// 引入 MyBatis-Plus 的注解，用于指定数据库表名
+import com.baomidou.mybatisplus.annotations.TableName;
+// 引入 Apache Commons BeanUtils 工具类，用于对象属性的复制操作
+import org.apache.commons.beanutils.BeanUtils;
+// 引入反射操作中调用目标方法时可能抛出的异常类
+import java.lang.reflect.InvocationTargetException;
+// 引入可序列化接口，使该类的对象能够被序列化
+import java.io.Serializable;
+
+// 记账凭证
+// 后端返回视图实体辅助类
+// （通常后端关联的表或者自定义的字段需要返回使用）
+ // @author
+// @email
+// @date 2021-04-24 15:19:31
+
+// 使用注解指定该视图实体类对应的数据库表名为 "jizhangpingzheng"
+@TableName("jizhangpingzheng")
+// 该类继承自记账凭证实体类，并实现了可序列化接口
+public class JizhangpingzhengView extends JizhangpingzhengEntity implements Serializable {
+	// 定义序列化版本号，用于在反序列化时验证类的版本一致性，保证对象在不同环境下的正确读写
+	private static final long serialVersionUID = 1L;
+
+	// 无参构造函数，用于创建一个空的记账凭证视图对象，方便在需要时实例化该类
+	public JizhangpingzhengView() {
+	}
+
+	// 有参构造函数，接受一个记账凭证实体对象作为参数
+	public JizhangpingzhengView(JizhangpingzhengEntity jizhangpingzhengEntity) {
+		try {
+			// 使用 BeanUtils 的 copyProperties 方法将传入的记账凭证实体对象的属性复制到当前视图对象中
+			// 这样可以快速地将实体类的属性值传递给视图类，减少手动设置属性的工作量
+			BeanUtils.copyProperties(this, jizhangpingzhengEntity);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			// 如果在属性复制过程中发生非法访问异常（如访问权限不足）或调用目标方法异常（如反射调用出错）
+			// 则打印异常堆栈信息，以便开发者定位和解决问题。在实际应用中，可进一步优化异常处理，如记录日志等
+			e.printStackTrace();
+		}
+	}
+}

src/main/java/com/entity/view/RijizhangView.java

@@ -0,0 +1,48 @@
+package com.entity.view;
+
+// 引入日记账实体类，该类包含了日记账相关的属性和方法
+import com.entity.RijizhangEntity;
+
+// 引入 MyBatis-Plus 的 TableName 注解，用于指定实体类对应的数据库表名
+import com.baomidou.mybatisplus.annotations.TableName;
+// 引入 Apache Commons BeanUtils 工具类，它提供了方便的对象属性复制功能
+import org.apache.commons.beanutils.BeanUtils;
+// 引入反射调用方法时可能抛出的异常类
+import java.lang.reflect.InvocationTargetException;
+// 引入 Serializable 接口，实现该接口的类的对象可以被序列化和反序列化
+import java.io.Serializable;
+
+// 日记账
+// 后端返回视图实体辅助类
+// （通常后端关联的表或者自定义的字段需要返回使用）
+ //@author
+ // @email
+// @date 2021-04-24 15:19:31
+
+// 使用 TableName 注解指定该视图类对应数据库中的 "rijizhang" 表
+@TableName("rijizhang")
+// 继承自 RijizhangEntity 类，同时实现 Serializable 接口
+public class RijizhangView extends RijizhangEntity implements Serializable {
+	// 定义序列化版本号，用于确保在反序列化时类的版本一致
+	private static final long serialVersionUID = 1L;
+
+	// 无参构造函数，用于创建一个空的 RijizhangView 对象
+
+	public RijizhangView() {
+	}
+
+	// 有参构造函数，根据传入的 RijizhangEntity 对象创建 RijizhangView 对象
+	// @param rijizhangEntity 日记账实体对象
+
+	public RijizhangView(RijizhangEntity rijizhangEntity) {
+		try {
+			// 使用 BeanUtils 的 copyProperties 方法将传入的 rijizhangEntity 对象的属性复制到当前对象
+			// 这样可以避免手动逐个复制属性，提高代码的可维护性
+			BeanUtils.copyProperties(this, rijizhangEntity);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			// 当复制属性过程中出现非法访问异常或者反射调用目标方法异常时，打印异常堆栈信息
+			// 在实际项目中，可以考虑记录日志或者抛出自定义异常，方便后续排查问题
+			e.printStackTrace();
+		}
+	}
+}

src/main/java/com/entity/view/ShangpinchukuView.java

@@ -0,0 +1,44 @@
+package com.entity.view;
+
+// 导入商品出库实体类，该类可能包含商品出库相关的属性和业务逻辑
+import com.entity.ShangpinchukuEntity;
+
+// 导入 MyBatis-Plus 的注解，用于指定数据库表名
+import com.baomidou.mybatisplus.annotations.TableName;
+// 导入 Apache Commons BeanUtils 工具类，用于对象属性的复制操作
+import org.apache.commons.beanutils.BeanUtils;
+// 导入反射调用方法时可能抛出的异常类
+import java.lang.reflect.InvocationTargetException;
+// 导入可序列化接口，使该类的对象能够进行序列化操作
+import java.io.Serializable;
+
+// 商品出库
+//后端返回视图实体辅助类
+// （通常后端关联的表或者自定义的字段需要返回使用）
+ // @author
+ //@email
+ // @date 2021-04-24 15:19:31
+
+// 使用注解指定该视图实体类对应的数据库表名为 "shangpinchuku"
+@TableName("shangpinchuku")
+// 该类继承自商品出库实体类，并实现了可序列化接口
+public class ShangpinchukuView extends ShangpinchukuEntity implements Serializable {
+	// 定义序列化版本号，用于在反序列化时验证类的版本一致性
+	private static final long serialVersionUID = 1L;
+
+	// 无参构造函数，用于创建一个空的商品出库视图对象
+	public ShangpinchukuView() {
+	}
+
+	// 有参构造函数，接受一个商品出库实体对象作为参数
+	public ShangpinchukuView(ShangpinchukuEntity shangpinchukuEntity) {
+		try {
+			// 使用 BeanUtils 的 copyProperties 方法将传入的商品出库实体对象的属性复制到当前视图对象中
+			BeanUtils.copyProperties(this, shangpinchukuEntity);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			// 如果在属性复制过程中发生非法访问异常（例如访问权限不足）或调用目标方法异常（例如反射调用失败）
+			// 则打印异常堆栈信息，以便开发者排查问题。在实际应用中，可进一步优化异常处理逻辑，如记录日志等
+			e.printStackTrace();
+		}
+	}
+}

src/main/java/com/entity/view/ShangpinkucunView.java

@@ -0,0 +1,48 @@
+package com.entity.view;
+
+// 引入商品库存实体类，该类包含了商品库存的相关属性和方法
+import com.entity.ShangpinkucunEntity;
+
+// 引入 MyBatis-Plus 框架的 TableName 注解，用于指定实体类对应的数据库表名
+import com.baomidou.mybatisplus.annotations.TableName;
+// 引入 Apache Commons BeanUtils 工具类，用于实现对象属性的复制
+import org.apache.commons.beanutils.BeanUtils;
+// 引入反射调用方法时可能抛出的异常类
+import java.lang.reflect.InvocationTargetException;
+// 引入 Serializable 接口，实现该接口的类的对象可以进行序列化和反序列化操作
+import java.io.Serializable;
+
+//商品库存
+//后端返回视图实体辅助类
+// （通常后端关联的表或者自定义的字段需要返回使用）
+ // @author
+//@email
+//@date 2021-04-24 15:19:31
+
+// 使用 TableName 注解指定该视图实体类对应的数据库表名为 "shangpinkucun"
+@TableName("shangpinkucun")
+// 继承自 ShangpinkucunEntity 类，同时实现 Serializable 接口
+public class ShangpinkucunView extends ShangpinkucunEntity implements Serializable {
+	// 定义序列化版本号，用于在反序列化时验证类的版本一致性
+	private static final long serialVersionUID = 1L;
+
+	// 无参构造函数，用于创建一个空的 ShangpinkucunView 对象
+
+	public ShangpinkucunView() {
+	}
+
+	// 有参构造函数，根据传入的 ShangpinkucunEntity 对象创建 ShangpinkucunView 对象
+	 // @param shangpinkucunEntity 商品库存实体对象
+
+	public ShangpinkucunView(ShangpinkucunEntity shangpinkucunEntity) {
+		try {
+			// 使用 BeanUtils.copyProperties 方法将传入的 shangpinkucunEntity 对象的属性复制到当前对象
+			// 这样可以方便地将实体类的属性值传递给视图类，避免手动逐个设置属性
+			BeanUtils.copyProperties(this, shangpinkucunEntity);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			// 当出现非法访问异常（如访问私有属性）或反射调用目标方法异常（如方法不存在）时
+			// 打印异常堆栈信息，方便开发者定位问题。在实际应用中，可考虑将异常信息记录到日志文件中
+			e.printStackTrace();
+		}
+	}
+}

src/main/java/com/entity/view/ShangpinleixingView.java

@@ -0,0 +1,48 @@
+package com.entity.view;
+
+// 导入商品类型实体类，这个类包含了商品类型的基本属性和方法
+import com.entity.ShangpinleixingEntity;
+
+// 导入 MyBatis-Plus 框架的 TableName 注解，用于指定该实体类对应的数据库表名
+import com.baomidou.mybatisplus.annotations.TableName;
+// 导入 Apache Commons BeanUtils 工具类，用于将一个 JavaBean 对象的属性复制到另一个 JavaBean 对象
+import org.apache.commons.beanutils.BeanUtils;
+// 导入反射调用方法时可能抛出的异常类
+import java.lang.reflect.InvocationTargetException;
+// 导入 Serializable 接口，实现该接口的类的对象可以被序列化，以便在网络传输或持久化存储中使用
+import java.io.Serializable;
+
+// 商品类型
+// 后端返回视图实体辅助类
+//（通常后端关联的表或者自定义的字段需要返回使用）
+ // @author
+ // @email
+ //@date 2021-04-24 15:19:31
+
+// 使用 TableName 注解指定该视图实体类对应数据库中的 "shangpinleixing" 表
+@TableName("shangpinleixing")
+// 继承自 ShangpinleixingEntity 类，同时实现 Serializable 接口
+public class ShangpinleixingView extends ShangpinleixingEntity implements Serializable {
+	// 定义序列化版本号，用于在反序列化时验证类的版本一致性
+	private static final long serialVersionUID = 1L;
+
+	//无参构造函数，用于创建一个空的 ShangpinleixingView 对象
+
+	public ShangpinleixingView() {
+	}
+
+	//有参构造函数，根据传入的 ShangpinleixingEntity 对象创建 ShangpinleixingView 对象
+	// @param shangpinleixingEntity 商品类型实体对象
+
+	public ShangpinleixingView(ShangpinleixingEntity shangpinleixingEntity) {
+		try {
+			// 使用 BeanUtils.copyProperties 方法将传入的 shangpinleixingEntity 对象的属性复制到当前对象
+			// 这样可以避免手动逐个复制属性，提高代码的可维护性
+			BeanUtils.copyProperties(this, shangpinleixingEntity);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			// 当复制属性过程中出现非法访问异常（如访问私有属性）或反射调用目标方法异常（如方法不存在）时
+			// 打印异常堆栈信息，方便开发者定位问题。在实际项目中，建议将异常信息记录到日志文件中
+			e.printStackTrace();
+		}
+	}
+}

src/main/java/com/entity/view/ShangpinrukuView.java

@@ -0,0 +1,47 @@
+package com.entity.view;
+
+// 导入商品入库实体类，该类定义了商品入库信息的相关属性和方法
+import com.entity.ShangpinrukuEntity;
+
+// 导入 MyBatis-Plus 的 TableName 注解，用于指定该实体类对应的数据库表名
+import com.baomidou.mybatisplus.annotations.TableName;
+// 导入 Apache Commons BeanUtils 工具类，用于将一个 JavaBean 对象的属性复制到另一个 JavaBean 对象
+import org.apache.commons.beanutils.BeanUtils;
+// 导入反射调用方法时可能抛出的异常类
+import java.lang.reflect.InvocationTargetException;
+// 导入 Serializable 接口，实现该接口的类的对象可以进行序列化和反序列化操作
+import java.io.Serializable;
+
+//商品入库
+// 后端返回视图实体辅助类
+// （通常后端关联的表或者自定义的字段需要返回使用）
+// @email
+// @date 2021-04-24 15:19:31
+
+// 使用 TableName 注解指定该视图实体类对应的数据库表名为 "shangpinruku"
+@TableName("shangpinruku")
+// 继承自 ShangpinrukuEntity 类，同时实现 Serializable 接口
+public class ShangpinrukuView extends ShangpinrukuEntity implements Serializable {
+	// 定义序列化版本号，用于在反序列化时验证类的版本一致性
+	private static final long serialVersionUID = 1L;
+
+	// 无参构造函数，用于创建一个空的 ShangpinrukuView 对象
+
+	public ShangpinrukuView() {
+	}
+
+	//有参构造函数，根据传入的 ShangpinrukuEntity 对象创建 ShangpinrukuView 对象
+	 // @param shangpinrukuEntity 商品入库实体对象
+
+	public ShangpinrukuView(ShangpinrukuEntity shangpinrukuEntity) {
+		try {
+			// 使用 BeanUtils.copyProperties 方法将传入的 shangpinrukuEntity 对象的属性复制到当前对象
+			// 这样可以避免手动逐个复制属性，提高代码的可维护性
+			BeanUtils.copyProperties(this, shangpinrukuEntity);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			// 当复制属性过程中出现非法访问异常（如访问私有属性）或反射调用目标方法异常（如方法不存在）时
+			// 打印异常堆栈信息，方便开发者定位问题。在实际项目中，建议将异常信息记录到日志文件中
+			e.printStackTrace();
+		}
+	}
+}

src/main/java/com/entity/view/YuangongView.java

@@ -0,0 +1,48 @@
+package com.entity.view;
+
+// 导入员工实体类，该类包含员工的基本属性和方法
+import com.entity.YuangongEntity;
+
+// 导入 MyBatis-Plus 框架的 TableName 注解，用于指定该实体类对应的数据库表名
+import com.baomidou.mybatisplus.annotations.TableName;
+// 导入 Apache Commons BeanUtils 工具类，用于将一个 JavaBean 对象的属性复制到另一个 JavaBean 对象
+import org.apache.commons.beanutils.BeanUtils;
+// 导入反射调用方法时可能抛出的异常类
+import java.lang.reflect.InvocationTargetException;
+// 导入 Serializable 接口，实现该接口的类的对象可以进行序列化和反序列化操作
+import java.io.Serializable;
+
+// 员工
+ // 后端返回视图实体辅助类
+ // （通常后端关联的表或者自定义的字段需要返回使用）
+// @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+// 使用 TableName 注解指定该视图实体类对应的数据库表名为 "yuangong"
+@TableName("yuangong")
+// 继承自 YuangongEntity 类，同时实现 Serializable 接口
+public class YuangongView extends YuangongEntity implements Serializable {
+	// 定义序列化版本号，用于在反序列化时验证类的版本一致性
+	private static final long serialVersionUID = 1L;
+
+	// 无参构造函数，用于创建一个空的 YuangongView 对象
+
+	public YuangongView() {
+	}
+
+	//有参构造函数，根据传入的 YuangongEntity 对象创建 YuangongView 对象
+	// @param yuangongEntity 员工实体对象
+
+	public YuangongView(YuangongEntity yuangongEntity) {
+		try {
+			// 使用 BeanUtils.copyProperties 方法将传入的 yuangongEntity 对象的属性复制到当前对象
+			// 这样可以避免手动逐个复制属性，提高代码的可维护性
+			BeanUtils.copyProperties(this, yuangongEntity);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			// 当复制属性过程中出现非法访问异常（如访问私有属性）或反射调用目标方法异常（如方法不存在）时
+			// 打印异常堆栈信息，方便开发者定位问题。在实际项目中，建议将异常信息记录到日志文件中
+			e.printStackTrace();
+		}
+	}
+}

src/main/java/com/entity/view/YuangongbaoxiaoView.java

@@ -0,0 +1,48 @@
+package com.entity.view;
+
+// 导入员工报销实体类，该类封装了员工报销的相关数据和业务逻辑
+import com.entity.YuangongbaoxiaoEntity;
+
+// 导入 MyBatis-Plus 框架中的 TableName 注解，用于指定实体类对应的数据库表名
+import com.baomidou.mybatisplus.annotations.TableName;
+// 导入 Apache Commons BeanUtils 工具类，其提供了方便的对象属性复制功能
+import org.apache.commons.beanutils.BeanUtils;
+// 导入反射调用方法时可能抛出的异常类
+import java.lang.reflect.InvocationTargetException;
+// 导入 Serializable 接口，实现该接口的类的对象可进行序列化操作
+import java.io.Serializable;
+
+// 员工报销
+// 后端返回视图实体辅助类
+// （通常后端关联的表或者自定义的字段需要返回使用）
+ // @author
+ // @email
+ //@date 2021-04-24 15:19:31
+
+// 使用 TableName 注解指定该视图实体类对应数据库中的 "yuangongbaoxiao" 表
+@TableName("yuangongbaoxiao")
+// 继承自 YuangongbaoxiaoEntity 类，同时实现 Serializable 接口
+public class YuangongbaoxiaoView extends YuangongbaoxiaoEntity implements Serializable {
+	// 定义序列化版本号，确保在反序列化时类的版本一致性
+	private static final long serialVersionUID = 1L;
+
+	// 无参构造函数，用于创建一个空的 YuangongbaoxiaoView 对象
+
+	public YuangongbaoxiaoView() {
+	}
+
+	// 有参构造函数，根据传入的 YuangongbaoxiaoEntity 对象创建 YuangongbaoxiaoView 对象
+	// @param yuangongbaoxiaoEntity 员工报销实体对象
+
+	public YuangongbaoxiaoView(YuangongbaoxiaoEntity yuangongbaoxiaoEntity) {
+		try {
+			// 利用 BeanUtils 的 copyProperties 方法将传入实体对象的属性复制到当前视图对象
+			// 避免手动逐个设置属性，提高代码的简洁性和可维护性
+			BeanUtils.copyProperties(this, yuangongbaoxiaoEntity);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			// 当复制属性过程中出现非法访问异常（如访问私有属性）或反射调用目标方法异常时
+			// 打印异常堆栈信息，便于开发者定位问题。实际应用中，可考虑记录日志或抛出自定义异常
+			e.printStackTrace();
+		}
+	}
+}

src/main/java/com/entity/view/YuangongjiaokuanView.java

@@ -0,0 +1,48 @@
+package com.entity.view;
+
+// 引入员工缴款实体类，该类定义了员工缴款相关的数据结构和业务逻辑
+import com.entity.YuangongjiaokuanEntity;
+
+// 引入 MyBatis-Plus 的 TableName 注解，用于指定该实体类对应的数据库表名
+import com.baomidou.mybatisplus.annotations.TableName;
+// 引入 Apache Commons BeanUtils 工具类，可用于方便地复制对象属性
+import org.apache.commons.beanutils.BeanUtils;
+// 引入反射调用方法时可能抛出的异常类
+import java.lang.reflect.InvocationTargetException;
+// 引入 Serializable 接口，实现该接口的类的对象可进行序列化操作
+import java.io.Serializable;
+
+// 员工缴款
+// 后端返回视图实体辅助类
+ // （通常后端关联的表或者自定义的字段需要返回使用）
+ // @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+// 使用 TableName 注解指定该视图实体类对应数据库中的 "yuangongjiaokuan" 表
+@TableName("yuangongjiaokuan")
+// 继承自 YuangongjiaokuanEntity 类，同时实现 Serializable 接口
+public class YuangongjiaokuanView extends YuangongjiaokuanEntity implements Serializable {
+	// 定义序列化版本号，确保反序列化时类版本的一致性
+	private static final long serialVersionUID = 1L;
+
+	//无参构造函数，用于创建一个空的 YuangongjiaokuanView 对象
+
+	public YuangongjiaokuanView() {
+	}
+
+	// 有参构造函数，根据传入的 YuangongjiaokuanEntity 对象创建 YuangongjiaokuanView 对象
+	// @param yuangongjiaokuanEntity 员工缴款实体对象
+
+	public YuangongjiaokuanView(YuangongjiaokuanEntity yuangongjiaokuanEntity) {
+		try {
+			// 利用 BeanUtils 的 copyProperties 方法将传入实体对象的属性复制到当前视图对象
+			// 避免手动逐个复制属性，提高代码的简洁性和可维护性
+			BeanUtils.copyProperties(this, yuangongjiaokuanEntity);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			// 当复制属性过程中出现非法访问异常（如访问私有属性）或反射调用目标方法异常时
+			// 打印异常堆栈信息，方便开发者定位问题。实际项目中可考虑记录日志
+			e.printStackTrace();
+		}
+	}
+}

src/main/java/com/entity/view/YuangongxinchouView.java

@@ -0,0 +1,48 @@
+package com.entity.view;
+
+// 导入员工薪酬实体类，该类应该包含了员工薪酬相关的属性和方法
+import com.entity.YuangongxinchouEntity;
+
+// 导入 MyBatis-Plus 框架中的 TableName 注解，用于指定该实体类对应的数据库表名
+import com.baomidou.mybatisplus.annotations.TableName;
+// 导入 Apache Commons BeanUtils 工具类，用于将一个 JavaBean 对象的属性复制到另一个 JavaBean 对象
+import org.apache.commons.beanutils.BeanUtils;
+// 导入反射调用方法时可能抛出的异常类
+import java.lang.reflect.InvocationTargetException;
+// 导入 Serializable 接口，实现该接口的类的对象可以进行序列化和反序列化操作
+import java.io.Serializable;
+
+// 员工薪酬
+ //后端返回视图实体辅助类
+ // （通常后端关联的表或者自定义的字段需要返回使用）
+// @author
+// @email
+ // @date 2021-04-24 15:19:31
+
+// 使用 TableName 注解指定该视图实体类对应的数据库表名为 "yuangongxinchou"
+@TableName("yuangongxinchou")
+// 继承自 YuangongxinchouEntity 类，同时实现 Serializable 接口
+public class YuangongxinchouView extends YuangongxinchouEntity implements Serializable {
+	// 定义序列化版本号，用于在反序列化时验证类的版本一致性
+	private static final long serialVersionUID = 1L;
+
+	// 无参构造函数，用于创建一个空的 YuangongxinchouView 对象
+
+	public YuangongxinchouView() {
+	}
+
+	// 有参构造函数，根据传入的 YuangongxinchouEntity 对象创建 YuangongxinchouView 对象
+	// @param yuangongxinchouEntity 员工薪酬实体对象
+
+	public YuangongxinchouView(YuangongxinchouEntity yuangongxinchouEntity) {
+		try {
+			// 使用 BeanUtils.copyProperties 方法将传入的 yuangongxinchouEntity 对象的属性复制到当前对象
+			// 这样可以避免手动逐个复制属性，提高代码的可维护性
+			BeanUtils.copyProperties(this, yuangongxinchouEntity);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			// 当复制属性过程中出现非法访问异常（如访问私有属性）或反射调用目标方法异常（如方法不存在）时
+			// 打印异常堆栈信息，方便开发者定位问题。在实际项目中，建议将异常信息记录到日志文件中
+			e.printStackTrace();
+		}
+	}
+}

src/main/java/com/entity/vo/ChengbenjieyuVO.java

@@ -0,0 +1,140 @@
+package com.entity.vo;
+
+import com.entity.ChengbenjieyuEntity;
+
+import com.baomidou.mybatisplus.annotations.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import java.util.Date;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.io.Serializable;
+ 
+
+//成本结余
+// 手机端接口返回实体辅助类
+// （主要作用去除一些不必要的字段）
+ // @author
+// @email
+//@date 2021-04-24 15:19:31
+
+public class ChengbenjieyuVO  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	// 收入项目
+
+	
+	private String shouruxiangmu;
+		
+	// 收入金额
+
+	
+	private Integer shourujine;
+		
+	// 支出项目
+
+	
+	private String zhichuxiangmu;
+		
+	//支出金额
+
+	
+	private Integer zhichujine;
+		
+	//结余金额
+
+	
+	private String jieyujine;
+		
+	// 日期
+
+		
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 
+	private Date riqi;
+				
+	
+	// 设置：收入项目
+
+	 
+	public void setShouruxiangmu(String shouruxiangmu) {
+		this.shouruxiangmu = shouruxiangmu;
+	}
+	
+	// 获取：收入项目
+
+	public String getShouruxiangmu() {
+		return shouruxiangmu;
+	}
+				
+	
+	//设置：收入金额
+
+	 
+	public void setShourujine(Integer shourujine) {
+		this.shourujine = shourujine;
+	}
+	
+	// 获取：收入金额
+
+	public Integer getShourujine() {
+		return shourujine;
+	}
+				
+	
+	// 设置：支出项目
+
+	 
+	public void setZhichuxiangmu(String zhichuxiangmu) {
+		this.zhichuxiangmu = zhichuxiangmu;
+	}
+	
+	// 获取：支出项目
+
+	public String getZhichuxiangmu() {
+		return zhichuxiangmu;
+	}
+				
+	
+	// 设置：支出金额
+
+	 
+	public void setZhichujine(Integer zhichujine) {
+		this.zhichujine = zhichujine;
+	}
+	
+	// 获取：支出金额
+
+	public Integer getZhichujine() {
+		return zhichujine;
+	}
+				
+	
+	// 设置：结余金额
+
+	 
+	public void setJieyujine(String jieyujine) {
+		this.jieyujine = jieyujine;
+	}
+	
+	//获取：结余金额
+
+	public String getJieyujine() {
+		return jieyujine;
+	}
+				
+	
+	// 设置：日期
+
+	 
+	public void setRiqi(Date riqi) {
+		this.riqi = riqi;
+	}
+	
+	// 获取：日期
+
+	public Date getRiqi() {
+		return riqi;
+	}
+			
+}

src/main/java/com/entity/vo/JizhangpingzhengVO.java

@@ -0,0 +1,140 @@
+package com.entity.vo;
+
+import com.entity.JizhangpingzhengEntity;
+
+import com.baomidou.mybatisplus.annotations.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import java.util.Date;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.io.Serializable;
+ 
+
+//记账凭证
+ //手机端接口返回实体辅助类
+ // （主要作用去除一些不必要的字段）
+ // @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+public class JizhangpingzhengVO  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	// 凭证名称
+
+	
+	private String pingzhengmingcheng;
+		
+	//类型
+
+	
+	private String leixing;
+		
+	//凭证内容
+
+	
+	private String pingzhengneirong;
+		
+	// 登记日期
+
+		
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 
+	private Date dengjiriqi;
+		
+	//附件
+
+	
+	private String fujian;
+		
+	//备注
+
+	
+	private String beizhu;
+				
+	
+	//设置：凭证名称
+
+	 
+	public void setPingzhengmingcheng(String pingzhengmingcheng) {
+		this.pingzhengmingcheng = pingzhengmingcheng;
+	}
+	
+	//获取：凭证名称
+
+	public String getPingzhengmingcheng() {
+		return pingzhengmingcheng;
+	}
+				
+	
+	// 设置：类型
+
+	 
+	public void setLeixing(String leixing) {
+		this.leixing = leixing;
+	}
+	
+	// 获取：类型
+
+	public String getLeixing() {
+		return leixing;
+	}
+				
+	
+	//设置：凭证内容
+
+	 
+	public void setPingzhengneirong(String pingzhengneirong) {
+		this.pingzhengneirong = pingzhengneirong;
+	}
+	
+	// 获取：凭证内容
+
+	public String getPingzhengneirong() {
+		return pingzhengneirong;
+	}
+				
+	
+	//设置：登记日期
+
+	 
+	public void setDengjiriqi(Date dengjiriqi) {
+		this.dengjiriqi = dengjiriqi;
+	}
+	
+	// 获取：登记日期
+
+	public Date getDengjiriqi() {
+		return dengjiriqi;
+	}
+				
+	
+	// 设置：附件
+
+	 
+	public void setFujian(String fujian) {
+		this.fujian = fujian;
+	}
+	
+	//获取：附件
+
+	public String getFujian() {
+		return fujian;
+	}
+				
+	
+	// 设置：备注
+
+	 
+	public void setBeizhu(String beizhu) {
+		this.beizhu = beizhu;
+	}
+	
+	//获取：备注
+
+	public String getBeizhu() {
+		return beizhu;
+	}
+			
+}

src/main/java/com/entity/vo/RijizhangVO.java

@@ -0,0 +1,159 @@
+package com.entity.vo;
+
+import com.entity.RijizhangEntity;
+
+import com.baomidou.mybatisplus.annotations.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import java.util.Date;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.io.Serializable;
+ 
+
+// 日记账
+ //手机端接口返回实体辅助类
+ // （主要作用去除一些不必要的字段）
+ // @author
+ //@email
+  //@date 2021-04-24 15:19:31
+
+public class RijizhangVO  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	// 日期
+
+		
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 
+	private Date riqi;
+		
+	//摘要
+
+	
+	private String zhaiyao;
+		
+	// 收入
+
+	
+	private Integer shouru;
+		
+	// 支出
+
+	
+	private Integer zhichu;
+		
+	// 金额
+
+	
+	private String jine;
+		
+	// 管理工号
+
+	
+	private String guanligonghao;
+		
+	//管理姓名
+
+	
+	private String guanlixingming;
+				
+	
+	//设置：日期
+
+	 
+	public void setRiqi(Date riqi) {
+		this.riqi = riqi;
+	}
+	
+	//获取：日期
+
+	public Date getRiqi() {
+		return riqi;
+	}
+				
+	
+	//设置：摘要
+
+	 
+	public void setZhaiyao(String zhaiyao) {
+		this.zhaiyao = zhaiyao;
+	}
+	
+	// 获取：摘要
+
+	public String getZhaiyao() {
+		return zhaiyao;
+	}
+				
+	
+	//设置：收入
+
+	 
+	public void setShouru(Integer shouru) {
+		this.shouru = shouru;
+	}
+	
+	//获取：收入
+
+	public Integer getShouru() {
+		return shouru;
+	}
+				
+	
+	// 设置：支出
+
+	 
+	public void setZhichu(Integer zhichu) {
+		this.zhichu = zhichu;
+	}
+	
+	//获取：支出
+
+	public Integer getZhichu() {
+		return zhichu;
+	}
+				
+	
+	// 设置：金额
+
+	 
+	public void setJine(String jine) {
+		this.jine = jine;
+	}
+	
+	// 获取：金额
+
+	public String getJine() {
+		return jine;
+	}
+				
+	
+	//设置：管理工号
+
+	 
+	public void setGuanligonghao(String guanligonghao) {
+		this.guanligonghao = guanligonghao;
+	}
+	
+	// 获取：管理工号
+
+	public String getGuanligonghao() {
+		return guanligonghao;
+	}
+				
+	
+	// 设置：管理姓名
+
+	 
+	public void setGuanlixingming(String guanlixingming) {
+		this.guanlixingming = guanlixingming;
+	}
+	
+	// 获取：管理姓名
+
+	public String getGuanlixingming() {
+		return guanlixingming;
+	}
+			
+}

src/main/java/com/entity/vo/ShangpinchukuVO.java

@@ -0,0 +1,197 @@
+package com.entity.vo;
+
+import com.entity.ShangpinchukuEntity;
+
+import com.baomidou.mybatisplus.annotations.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import java.util.Date;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.io.Serializable;
+ 
+
+//商品出库
+ // 手机端接口返回实体辅助类
+ //（主要作用去除一些不必要的字段）
+//@author
+//@email
+ //@date 2021-04-24 15:19:31
+
+public class ShangpinchukuVO  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	// 商品类型
+
+	
+	private String shangpinleixing;
+		
+	//客户姓名
+
+	
+	private String kehuxingming;
+		
+	// 商品数量
+
+	
+	private Integer shangpinshuliang;
+		
+	//出库时间
+
+		
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 
+	private Date chukushijian;
+		
+	//备注
+
+	
+	private String beizhu;
+		
+	//员工工号
+
+	
+	private String yuangonggonghao;
+		
+	// 员工姓名
+
+	
+	private String yuangongxingming;
+		
+	// 是否审核
+
+	
+	private String sfsh;
+		
+	//审核回复
+
+	private String shhf;
+				
+	
+	//设置：商品类型
+
+	 
+	public void setShangpinleixing(String shangpinleixing) {
+		this.shangpinleixing = shangpinleixing;
+	}
+	
+	// 获取：商品类型
+
+	public String getShangpinleixing() {
+		return shangpinleixing;
+	}
+				
+	
+	//设置：客户姓名
+
+	 
+	public void setKehuxingming(String kehuxingming) {
+		this.kehuxingming = kehuxingming;
+	}
+	
+	//获取：客户姓名
+
+	public String getKehuxingming() {
+		return kehuxingming;
+	}
+				
+	
+	//设置：商品数量
+
+	 
+	public void setShangpinshuliang(Integer shangpinshuliang) {
+		this.shangpinshuliang = shangpinshuliang;
+	}
+	
+	// 获取：商品数量
+
+	public Integer getShangpinshuliang() {
+		return shangpinshuliang;
+	}
+				
+	
+	//设置：出库时间
+
+	 
+	public void setChukushijian(Date chukushijian) {
+		this.chukushijian = chukushijian;
+	}
+	
+	// 获取：出库时间
+
+	public Date getChukushijian() {
+		return chukushijian;
+	}
+				
+	
+	//设置：备注
+
+	 
+	public void setBeizhu(String beizhu) {
+		this.beizhu = beizhu;
+	}
+	
+	//获取：备注
+
+	public String getBeizhu() {
+		return beizhu;
+	}
+				
+	
+	//设置：员工工号
+
+	 
+	public void setYuangonggonghao(String yuangonggonghao) {
+		this.yuangonggonghao = yuangonggonghao;
+	}
+	
+	// 获取：员工工号
+
+	public String getYuangonggonghao() {
+		return yuangonggonghao;
+	}
+				
+	
+	// 设置：员工姓名
+
+	 
+	public void setYuangongxingming(String yuangongxingming) {
+		this.yuangongxingming = yuangongxingming;
+	}
+	
+	//获取：员工姓名
+
+	public String getYuangongxingming() {
+		return yuangongxingming;
+	}
+				
+	
+
+	//设置：是否审核
+
+	 
+	public void setSfsh(String sfsh) {
+		this.sfsh = sfsh;
+	}
+	
+	//获取：是否审核
+
+	public String getSfsh() {
+		return sfsh;
+	}
+				
+	
+	// 设置：审核回复
+
+	 
+	public void setShhf(String shhf) {
+		this.shhf = shhf;
+	}
+	
+	// 获取：审核回复
+
+	public String getShhf() {
+		return shhf;
+	}
+			
+}

src/main/java/com/entity/vo/ShangpinkucunVO.java

@@ -0,0 +1,139 @@
+package com.entity.vo;
+
+import com.entity.ShangpinkucunEntity;
+
+import com.baomidou.mybatisplus.annotations.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import java.util.Date;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.io.Serializable;
+ 
+
+// 商品库存
+ // 手机端接口返回实体辅助类
+// （主要作用去除一些不必要的字段）
+ // @author
+// @email
+ //@date 2021-04-24 15:19:31
+
+public class ShangpinkucunVO  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	// 商品类型
+
+	
+	private String shangpinleixing;
+		
+	//商品数量
+
+	
+	private Integer shangpinshuliang;
+		
+	// 商品详情
+
+	private String shangpinxiangqing;
+		
+	//存放位置
+
+	
+	private String cunfangweizhi;
+		
+	//是否完好
+
+	
+	private String shifouwanhao;
+		
+	// 登记日期
+
+		
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 
+	private Date dengjiriqi;
+				
+	
+	// 设置：商品类型
+
+	 
+	public void setShangpinleixing(String shangpinleixing) {
+		this.shangpinleixing = shangpinleixing;
+	}
+	
+	// 获取：商品类型
+
+	public String getShangpinleixing() {
+		return shangpinleixing;
+	}
+				
+	
+	//设置：商品数量
+
+	 
+	public void setShangpinshuliang(Integer shangpinshuliang) {
+		this.shangpinshuliang = shangpinshuliang;
+	}
+	
+	//获取：商品数量
+
+	public Integer getShangpinshuliang() {
+		return shangpinshuliang;
+	}
+				
+	
+	// 设置：商品详情
+
+	 
+	public void setShangpinxiangqing(String shangpinxiangqing) {
+		this.shangpinxiangqing = shangpinxiangqing;
+	}
+	
+	// 获取：商品详情
+
+	public String getShangpinxiangqing() {
+		return shangpinxiangqing;
+	}
+				
+	
+	// 设置：存放位置
+
+	 
+	public void setCunfangweizhi(String cunfangweizhi) {
+		this.cunfangweizhi = cunfangweizhi;
+	}
+	
+	// 获取：存放位置
+
+	public String getCunfangweizhi() {
+		return cunfangweizhi;
+	}
+				
+	
+	// 设置：是否完好
+
+	 
+	public void setShifouwanhao(String shifouwanhao) {
+		this.shifouwanhao = shifouwanhao;
+	}
+	
+	// 获取：是否完好
+
+	public String getShifouwanhao() {
+		return shifouwanhao;
+	}
+				
+	
+	// 设置：登记日期
+
+	 
+	public void setDengjiriqi(Date dengjiriqi) {
+		this.dengjiriqi = dengjiriqi;
+	}
+	
+	// 获取：登记日期
+
+	public Date getDengjiriqi() {
+		return dengjiriqi;
+	}
+			
+}

src/main/java/com/entity/vo/ShangpinleixingVO.java

@@ -0,0 +1,24 @@
+package com.entity.vo;
+
+import com.entity.ShangpinleixingEntity;
+
+import com.baomidou.mybatisplus.annotations.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import java.util.Date;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.io.Serializable;
+ 
+
+// 商品类型
+ // 手机端接口返回实体辅助类
+ //（主要作用去除一些不必要的字段）
+ // @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+public class ShangpinleixingVO  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 				
+}

src/main/java/com/entity/vo/ShangpinrukuVO.java

@@ -0,0 +1,214 @@
+package com.entity.vo;
+
+import com.entity.ShangpinrukuEntity;
+
+import com.baomidou.mybatisplus.annotations.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import java.util.Date;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.io.Serializable;
+ 
+
+// 商品入库
+// （主要作用去除一些不必要的字段）
+//@author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+public class ShangpinrukuVO  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	// 商品类型
+
+	
+	private String shangpinleixing;
+		
+	//供应商姓名
+
+	
+	private String gongyingshangxingming;
+		
+	//商品数量
+
+	
+	private Integer shangpinshuliang;
+		
+	//入库时间
+
+		
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 
+	private Date rukushijian;
+		
+	// 是否完好
+
+	
+	private String shifouwanhao;
+		
+	//备注
+	
+	private String beizhu;
+		
+	//员工工号
+
+	
+	private String yuangonggonghao;
+		
+	//员工姓名
+
+	
+	private String yuangongxingming;
+		
+	//是否审核
+
+	
+	private String sfsh;
+		
+	//审核回复
+
+	
+	private String shhf;
+				
+	
+	//设置：商品类型
+
+	 
+	public void setShangpinleixing(String shangpinleixing) {
+		this.shangpinleixing = shangpinleixing;
+	}
+	
+	// 获取：商品类型
+
+	public String getShangpinleixing() {
+		return shangpinleixing;
+	}
+				
+	
+	//设置：供应商姓名
+
+	 
+	public void setGongyingshangxingming(String gongyingshangxingming) {
+		this.gongyingshangxingming = gongyingshangxingming;
+	}
+	
+	//获取：供应商姓名
+
+	public String getGongyingshangxingming() {
+		return gongyingshangxingming;
+	}
+				
+	
+	// 设置：商品数量
+
+	 
+	public void setShangpinshuliang(Integer shangpinshuliang) {
+		this.shangpinshuliang = shangpinshuliang;
+	}
+	
+	//获取：商品数量
+
+	public Integer getShangpinshuliang() {
+		return shangpinshuliang;
+	}
+				
+	
+	// 设置：入库时间
+
+	 
+	public void setRukushijian(Date rukushijian) {
+		this.rukushijian = rukushijian;
+	}
+	
+	// 获取：入库时间
+
+	public Date getRukushijian() {
+		return rukushijian;
+	}
+				
+	
+	// 设置：是否完好
+
+	 
+	public void setShifouwanhao(String shifouwanhao) {
+		this.shifouwanhao = shifouwanhao;
+	}
+	
+	//获取：是否完好
+
+	public String getShifouwanhao() {
+		return shifouwanhao;
+	}
+				
+	
+	//设置：备注
+
+	 
+	public void setBeizhu(String beizhu) {
+		this.beizhu = beizhu;
+	}
+	
+	//获取：备注
+
+	public String getBeizhu() {
+		return beizhu;
+	}
+				
+	
+	// 设置：员工工号
+
+	 
+	public void setYuangonggonghao(String yuangonggonghao) {
+		this.yuangonggonghao = yuangonggonghao;
+	}
+	
+	//获取：员工工号
+
+	public String getYuangonggonghao() {
+		return yuangonggonghao;
+	}
+				
+	
+	//设置：员工姓名
+
+	 
+	public void setYuangongxingming(String yuangongxingming) {
+		this.yuangongxingming = yuangongxingming;
+	}
+	
+	//获取：员工姓名
+
+	public String getYuangongxingming() {
+		return yuangongxingming;
+	}
+				
+	
+	//设置：是否审核
+
+	 
+	public void setSfsh(String sfsh) {
+		this.sfsh = sfsh;
+	}
+	
+	// 获取：是否审核
+
+	public String getSfsh() {
+		return sfsh;
+	}
+				
+	
+	//设置：审核回复
+
+	 
+	public void setShhf(String shhf) {
+		this.shhf = shhf;
+	}
+	
+	//获取：审核回复
+
+	public String getShhf() {
+		return shhf;
+	}
+			
+}

src/main/java/com/entity/vo/YuangongVO.java

@@ -0,0 +1,156 @@
+package com.entity.vo;
+
+import com.entity.YuangongEntity;
+
+import com.baomidou.mybatisplus.annotations.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import java.util.Date;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.io.Serializable;
+ 
+
+// 员工
+ // 手机端接口返回实体辅助类
+// （主要作用去除一些不必要的字段）
+ // @author
+ //@email
+ //@date 2021-04-24 15:19:31
+
+public class YuangongVO  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	// 密码
+
+	
+	private String mima;
+		
+	// 员工姓名
+
+	
+	private String yuangongxingming;
+		
+	// 性别
+
+	
+	private String xingbie;
+		
+	//部门
+
+	private String bumen;
+		
+	//手机
+
+	
+	private String shouji;
+		
+	//邮箱
+
+	
+	private String youxiang;
+		
+	// 身份证
+
+	
+	private String shenfenzheng;
+				
+	
+	// 设置：密码
+
+	 
+	public void setMima(String mima) {
+		this.mima = mima;
+	}
+	
+	// 获取：密码
+
+	public String getMima() {
+		return mima;
+	}
+				
+	
+	// 设置：员工姓名
+
+	 
+	public void setYuangongxingming(String yuangongxingming) {
+		this.yuangongxingming = yuangongxingming;
+	}
+	
+	//获取：员工姓名
+
+	public String getYuangongxingming() {
+		return yuangongxingming;
+	}
+				
+	
+	//设置：性别
+
+	 
+	public void setXingbie(String xingbie) {
+		this.xingbie = xingbie;
+	}
+	
+	// 获取：性别
+
+	public String getXingbie() {
+		return xingbie;
+	}
+				
+	
+	// 设置：部门
+
+	 
+	public void setBumen(String bumen) {
+		this.bumen = bumen;
+	}
+	
+	// 获取：部门
+
+	public String getBumen() {
+		return bumen;
+	}
+				
+	
+	// 设置：手机
+
+	 
+	public void setShouji(String shouji) {
+		this.shouji = shouji;
+	}
+	
+	// 获取：手机
+
+	public String getShouji() {
+		return shouji;
+	}
+				
+	
+	// 设置：邮箱
+
+	 
+	public void setYouxiang(String youxiang) {
+		this.youxiang = youxiang;
+	}
+	
+	//获取：邮箱
+
+	public String getYouxiang() {
+		return youxiang;
+	}
+				
+	
+	// 设置：身份证
+
+	 
+	public void setShenfenzheng(String shenfenzheng) {
+		this.shenfenzheng = shenfenzheng;
+	}
+	
+	// 获取：身份证
+
+	public String getShenfenzheng() {
+		return shenfenzheng;
+	}
+			
+}

src/main/java/com/entity/vo/YuangongbaoxiaoVO.java

@@ -0,0 +1,177 @@
+package com.entity.vo;
+
+import com.entity.YuangongbaoxiaoEntity;
+
+import com.baomidou.mybatisplus.annotations.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import java.util.Date;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.io.Serializable;
+ 
+
+//员工报销
+ // 手机端接口返回实体辅助类
+ //@author
+// @email
+//@date 2021-04-24 15:19:31
+
+public class YuangongbaoxiaoVO  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	//员工姓名
+
+	
+	private String yuangongxingming;
+		
+	// 报销项目
+
+	
+	private String baoxiaoxiangmu;
+		
+	// 报销金额
+
+	
+	private Integer baoxiaojine;
+		
+	//申请日期
+
+		
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 
+	private Date shenqingriqi;
+		
+	// 备注
+
+	
+	private String beizhu;
+		
+	// 管理工号
+
+	
+	private String guanligonghao;
+		
+	//管理姓名
+
+	
+	private String guanlixingming;
+		
+	//是否支付
+
+	
+	private String ispay;
+				
+	
+	// 设置：员工姓名
+
+	 
+	public void setYuangongxingming(String yuangongxingming) {
+		this.yuangongxingming = yuangongxingming;
+	}
+	
+	// 获取：员工姓名
+
+	public String getYuangongxingming() {
+		return yuangongxingming;
+	}
+				
+	
+	// 设置：报销项目
+
+	 
+	public void setBaoxiaoxiangmu(String baoxiaoxiangmu) {
+		this.baoxiaoxiangmu = baoxiaoxiangmu;
+	}
+	
+	// 获取：报销项目
+
+	public String getBaoxiaoxiangmu() {
+		return baoxiaoxiangmu;
+	}
+				
+	
+	// 设置：报销金额
+
+	 
+	public void setBaoxiaojine(Integer baoxiaojine) {
+		this.baoxiaojine = baoxiaojine;
+	}
+	
+	//获取：报销金额
+
+	public Integer getBaoxiaojine() {
+		return baoxiaojine;
+	}
+				
+	
+	//设置：申请日期
+
+	 
+	public void setShenqingriqi(Date shenqingriqi) {
+		this.shenqingriqi = shenqingriqi;
+	}
+	
+	//获取：申请日期
+
+	public Date getShenqingriqi() {
+		return shenqingriqi;
+	}
+				
+	
+	// 设置：备注
+
+	 
+	public void setBeizhu(String beizhu) {
+		this.beizhu = beizhu;
+	}
+	
+	// 获取：备注
+
+	public String getBeizhu() {
+		return beizhu;
+	}
+				
+	
+	// 设置：管理工号
+
+	 
+	public void setGuanligonghao(String guanligonghao) {
+		this.guanligonghao = guanligonghao;
+	}
+	
+	// 获取：管理工号
+
+	public String getGuanligonghao() {
+		return guanligonghao;
+	}
+				
+	
+	// 设置：管理姓名
+
+	 
+	public void setGuanlixingming(String guanlixingming) {
+		this.guanlixingming = guanlixingming;
+	}
+	
+	// 获取：管理姓名
+
+	public String getGuanlixingming() {
+		return guanlixingming;
+	}
+				
+	
+	// 设置：是否支付
+
+	 
+	public void setIspay(String ispay) {
+		this.ispay = ispay;
+	}
+	
+	//获取：是否支付
+
+	public String getIspay() {
+		return ispay;
+	}
+			
+}

src/main/java/com/entity/vo/YuangongjiaokuanVO.java

@@ -0,0 +1,216 @@
+package com.entity.vo;
+
+import com.entity.YuangongjiaokuanEntity;
+
+import com.baomidou.mybatisplus.annotations.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import java.util.Date;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.io.Serializable;
+ 
+
+// 员工缴款
+ // 手机端接口返回实体辅助类
+// （主要作用去除一些不必要的字段）
+ // @author
+ //@email
+ //@date 2021-04-24 15:19:31
+
+public class YuangongjiaokuanVO  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	// 员工姓名
+
+	
+	private String yuangongxingming;
+		
+	// 缴费名称
+
+	
+	private String jiaofeimingcheng;
+		
+	//缴款金额
+
+	
+	private Integer jiaokuanjine;
+		
+	// 缴款日期
+
+		
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 
+	private Date jiaokuanriqi;
+		
+	//备注
+
+	
+	private String beizhu;
+		
+	// 管理工号
+
+	
+	private String guanligonghao;
+		
+	//管理姓名
+
+	
+	private String guanlixingming;
+		
+	//是否审核
+
+	
+	private String sfsh;
+		
+	// 审核回复
+
+	
+	private String shhf;
+		
+	// 是否支付
+
+	
+	private String ispay;
+				
+	
+	// 设置：员工姓名
+
+	 
+	public void setYuangongxingming(String yuangongxingming) {
+		this.yuangongxingming = yuangongxingming;
+	}
+	
+	//获取：员工姓名
+
+	public String getYuangongxingming() {
+		return yuangongxingming;
+	}
+				
+	
+	// 设置：缴费名称
+
+	 
+	public void setJiaofeimingcheng(String jiaofeimingcheng) {
+		this.jiaofeimingcheng = jiaofeimingcheng;
+	}
+	
+	//获取：缴费名称
+
+	public String getJiaofeimingcheng() {
+		return jiaofeimingcheng;
+	}
+				
+	
+	//设置：缴款金额
+
+	 
+	public void setJiaokuanjine(Integer jiaokuanjine) {
+		this.jiaokuanjine = jiaokuanjine;
+	}
+	
+	//获取：缴款金额
+
+	public Integer getJiaokuanjine() {
+		return jiaokuanjine;
+	}
+				
+	
+	// 设置：缴款日期
+
+	 
+	public void setJiaokuanriqi(Date jiaokuanriqi) {
+		this.jiaokuanriqi = jiaokuanriqi;
+	}
+	
+	//获取：缴款日期
+
+	public Date getJiaokuanriqi() {
+		return jiaokuanriqi;
+	}
+				
+	
+	// 设置：备注
+
+	 
+	public void setBeizhu(String beizhu) {
+		this.beizhu = beizhu;
+	}
+	
+	//获取：备注
+
+	public String getBeizhu() {
+		return beizhu;
+	}
+				
+	
+	// 设置：管理工号
+
+	 
+	public void setGuanligonghao(String guanligonghao) {
+		this.guanligonghao = guanligonghao;
+	}
+	
+	// 获取：管理工号
+
+	public String getGuanligonghao() {
+		return guanligonghao;
+	}
+				
+	
+	// 设置：管理姓名
+
+	 
+	public void setGuanlixingming(String guanlixingming) {
+		this.guanlixingming = guanlixingming;
+	}
+	
+	// 获取：管理姓名
+
+	public String getGuanlixingming() {
+		return guanlixingming;
+	}
+				
+	
+	// 设置：是否审核
+
+	 
+	public void setSfsh(String sfsh) {
+		this.sfsh = sfsh;
+	}
+	
+	// 获取：是否审核
+
+	public String getSfsh() {
+		return sfsh;
+	}
+				
+	
+	// 设置：审核回复
+
+	 
+	public void setShhf(String shhf) {
+		this.shhf = shhf;
+	}
+	
+	// 获取：审核回复
+
+	public String getShhf() {
+		return shhf;
+	}
+				
+	
+	// 设置：是否支付
+
+	 
+	public void setIspay(String ispay) {
+		this.ispay = ispay;
+	}
+	
+	// 获取：是否支付
+
+	public String getIspay() {
+		return ispay;
+	}
+			
+}

src/main/java/com/entity/vo/YuangongxinchouVO.java

@@ -0,0 +1,232 @@
+package com.entity.vo;
+
+import com.entity.YuangongxinchouEntity;
+
+import com.baomidou.mybatisplus.annotations.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import java.util.Date;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.io.Serializable;
+ 
+
+// 员工薪酬
+ // 手机端接口返回实体辅助类
+ // （主要作用去除一些不必要的字段）
+ // @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+public class YuangongxinchouVO  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	// 员工姓名
+
+	
+	private String yuangongxingming;
+		
+	// 基本工资
+
+	
+	private Integer jibengongzi;
+		
+	// 全勤奖励
+
+	private Integer quanqinjiangli;
+		
+	// 绩效奖励
+
+	
+	private Integer jixiaojiangli;
+		
+	// 社保补助
+
+	
+	private Integer shebaobuzhu;
+		
+	//扣款金额
+
+	private Integer koukuanjine;
+		
+	//扣款事项
+
+	
+	private String koukuanshixiang;
+		
+	// 实发工资
+
+	
+	private String shifagongzi;
+		
+	// 日期
+
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 
+	private Date riqi;
+		
+	// 管理工号
+
+	
+	private String guanligonghao;
+		
+	// 管理姓名
+
+	
+	private String guanlixingming;
+				
+	
+	// 设置：员工姓名
+
+	 
+	public void setYuangongxingming(String yuangongxingming) {
+		this.yuangongxingming = yuangongxingming;
+	}
+	
+	//获取：员工姓名
+
+	public String getYuangongxingming() {
+		return yuangongxingming;
+	}
+				
+	
+	//设置：基本工资
+
+	 
+	public void setJibengongzi(Integer jibengongzi) {
+		this.jibengongzi = jibengongzi;
+	}
+	
+	// 获取：基本工资
+
+	public Integer getJibengongzi() {
+		return jibengongzi;
+	}
+				
+	
+	//设置：全勤奖励
+
+	 
+	public void setQuanqinjiangli(Integer quanqinjiangli) {
+		this.quanqinjiangli = quanqinjiangli;
+	}
+	
+	// 获取：全勤奖励
+
+	public Integer getQuanqinjiangli() {
+		return quanqinjiangli;
+	}
+				
+	
+	// 设置：绩效奖励
+
+	 
+	public void setJixiaojiangli(Integer jixiaojiangli) {
+		this.jixiaojiangli = jixiaojiangli;
+	}
+	
+	// 获取：绩效奖励
+
+	public Integer getJixiaojiangli() {
+		return jixiaojiangli;
+	}
+				
+	
+	//设置：社保补助
+
+	 
+	public void setShebaobuzhu(Integer shebaobuzhu) {
+		this.shebaobuzhu = shebaobuzhu;
+	}
+	
+	// 获取：社保补助
+
+	public Integer getShebaobuzhu() {
+		return shebaobuzhu;
+	}
+				
+	
+	// 设置：扣款金额
+
+	 
+	public void setKoukuanjine(Integer koukuanjine) {
+		this.koukuanjine = koukuanjine;
+	}
+	
+	// 获取：扣款金额
+
+	public Integer getKoukuanjine() {
+		return koukuanjine;
+	}
+				
+	
+	// 设置：扣款事项
+
+	 
+	public void setKoukuanshixiang(String koukuanshixiang) {
+		this.koukuanshixiang = koukuanshixiang;
+	}
+	
+	// 获取：扣款事项
+
+	public String getKoukuanshixiang() {
+		return koukuanshixiang;
+	}
+				
+	
+	// 设置：实发工资
+
+	 
+	public void setShifagongzi(String shifagongzi) {
+		this.shifagongzi = shifagongzi;
+	}
+	
+	//获取：实发工资
+
+	public String getShifagongzi() {
+		return shifagongzi;
+	}
+				
+	
+	// 设置：日期
+
+	 
+	public void setRiqi(Date riqi) {
+		this.riqi = riqi;
+	}
+	
+	//获取：日期
+
+	public Date getRiqi() {
+		return riqi;
+	}
+				
+	
+	// 设置：管理工号
+
+	 
+	public void setGuanligonghao(String guanligonghao) {
+		this.guanligonghao = guanligonghao;
+	}
+	
+	// 获取：管理工号
+
+	public String getGuanligonghao() {
+		return guanligonghao;
+	}
+				
+	
+	//设置：管理姓名
+
+	 
+	public void setGuanlixingming(String guanlixingming) {
+		this.guanlixingming = guanlixingming;
+	}
+	
+	// 获取：管理姓名
+
+	public String getGuanlixingming() {
+		return guanlixingming;
+	}
+			
+}

src/main/java/com/service/ChengbenjieyuService.java

@@ -0,0 +1,60 @@
+package com.service;
+
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.service.IService;
+import com.utils.PageUtils;
+import com.entity.ChengbenjieyuEntity;
+import java.util.List;
+import java.util.Map;
+import com.entity.vo.ChengbenjieyuVO;
+import org.apache.ibatis.annotations.Param;
+import com.entity.view.ChengbenjieyuView;
+
+//成本结余
+//该接口定义了与成本结余相关的业务逻辑操作，继承自 MyBatis-Plus 的 IService 接口，
+ // 具备对 ChengbenjieyuEntity 实体的基本增删改查功能，同时提供了一些自定义的查询和分页方法。
+// @author
+ //@email
+ //@date 2021-04-24 15:19:31
+
+public interface ChengbenjieyuService extends IService<ChengbenjieyuEntity> {
+
+	// 根据传入的参数进行分页查询成本结余数据。
+	 // @param params 包含查询条件和分页信息的参数映射，如页码、每页记录数等。
+	 //@return 封装了分页信息和查询结果的 PageUtils 对象，包含当前页的数据列表、总记录数、总页数等信息。
+
+	PageUtils queryPage(Map<String, Object> params);
+
+	//根据指定的查询条件，查询成本结余值对象（VO）列表。
+	//值对象（VO）通常用于封装特定业务场景下需要展示或处理的数据，可能只包含实体类的部分字段。
+	 // @param wrapper 用于构建查询条件的包装器，可设置各种条件（如等于、大于、小于等）来筛选数据。
+	//@return 符合查询条件的成本结余值对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<ChengbenjieyuVO> selectListVO(Wrapper<ChengbenjieyuEntity> wrapper);
+
+	//根据指定的查询条件，查询单个成本结余值对象（VO）。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个成本结余值对象，如果没有符合条件的数据则返回 null。
+
+	ChengbenjieyuVO selectVO(@Param("ew") Wrapper<ChengbenjieyuEntity> wrapper);
+
+	//根据指定的查询条件，查询成本结余视图对象列表。
+	 //视图对象通常用于展示数据，可能包含关联查询或格式化后的数据。
+	 //@param wrapper 用于构建查询条件的包装器。
+	//@return 符合查询条件的成本结余视图对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<ChengbenjieyuView> selectListView(Wrapper<ChengbenjieyuEntity> wrapper);
+
+	// 根据指定的查询条件，查询单个成本结余视图对象。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 //@return 符合查询条件的单个成本结余视图对象，如果没有符合条件的数据则返回 null。
+
+	ChengbenjieyuView selectView(@Param("ew") Wrapper<ChengbenjieyuEntity> wrapper);
+
+	// 根据传入的参数和查询条件进行分页查询成本结余数据。
+	 // @param params 包含查询条件和分页信息的参数映射。
+	 // @param wrapper 用于构建查询条件的包装器，可进一步细化查询条件。
+	 // @return 封装了分页信息和查询结果的 PageUtils 对象。
+
+	PageUtils queryPage(Map<String, Object> params, Wrapper<ChengbenjieyuEntity> wrapper);
+}

src/main/java/com/service/CommonService.java

@@ -0,0 +1,57 @@
+package com.service;
+
+import java.util.List;
+import java.util.Map;
+
+// 通用服务接口，提供一系列通用的数据处理和业务逻辑方法。
+ // 该接口中的方法可用于不同业务场景下的数据查询、处理和统计等操作。
+
+public interface CommonService {
+
+	// 根据传入的参数获取选项列表。
+	 // 该方法可能用于获取下拉框、单选框等选项控件的选项数据。
+	 // @param params 包含查询条件的参数映射，可根据不同业务需求传入不同的键值对。
+	 // @return 包含选项值的字符串列表，如果没有符合条件的选项则返回空列表。
+	List<String> getOption(Map<String, Object> params);
+
+	// 根据传入的参数获取关联数据。
+	 //该方法可能用于根据某个选项的值获取与之关联的其他数据，例如根据部门名称获取该部门下的员工信息。
+	// @param params 包含查询条件的参数映射，通常包含选项的值以及其他关联查询所需的条件。
+	// @return 包含关联数据的映射，键为数据的属性名，值为对应的数据值，如果没有关联数据则返回空映射。
+
+	Map<String, Object> getFollowByOption(Map<String, Object> params);
+
+	//执行审核相关操作。
+	// 该方法的具体功能取决于业务需求，可能用于审核数据的合法性、状态更新等操作。
+	 // @param params 包含审核所需信息的参数映射，例如审核对象的 ID、审核状态等。
+
+	void sh(Map<String, Object> params);
+
+	// 统计提醒数量。
+	// 该方法可能用于统计满足特定条件的提醒数量，例如未读消息数量、待办事项数量等。
+	 // @param params 包含统计条件的参数映射，例如提醒类型、时间范围等。
+	 // @return 满足条件的提醒数量。
+
+	int remindCount(Map<String, Object> params);
+
+	// 根据传入的参数进行计算并返回结果。
+	//该方法可能用于执行一些复杂的计算逻辑，例如数据汇总、统计分析等。
+	 // @param params 包含计算所需数据和条件的参数映射。
+	 // @return 包含计算结果的映射，键为结果的名称，值为对应的计算结果。
+
+	Map<String, Object> selectCal(Map<String, Object> params);
+
+	// 根据传入的参数进行分组查询并返回结果列表。
+	 // 该方法可能用于对数据进行分组统计，例如按部门分组统计员工数量。
+	 // @param params 包含分组查询条件的参数映射，例如分组字段、统计字段等。
+	 // @return 包含分组查询结果的列表，每个元素是一个映射，键为统计结果的属性名，值为对应的数据值。
+
+	List<Map<String, Object>> selectGroup(Map<String, Object> params);
+
+	// 根据传入的参数查询数据值列表。
+	//该方法可能用于查询满足特定条件的数据值，例如查询某个时间段内的销售金额列表。
+	 // @param params 包含查询条件的参数映射。
+	 // @return 包含查询结果的数据值列表，每个元素是一个映射，键为数据的属性名，值为对应的数据值。
+
+	List<Map<String, Object>> selectValue(Map<String, Object> params);
+}

src/main/java/com/service/ConfigService.java

@@ -0,0 +1,21 @@
+
+package com.service;
+
+import java.util.Map;
+
+import com.baomidou.mybatisplus.service.IService;
+import com.entity.ConfigEntity;
+import com.utils.PageUtils;
+
+// 系统用户
+ // 该接口用于处理系统用户相关的业务逻辑，继承自 MyBatis-Plus 的 IService 接口，
+ // 具备对 ConfigEntity 实体的基本增删改查功能，同时定义了分页查询方法。
+
+public interface ConfigService extends IService<ConfigEntity> {
+
+	//根据传入的参数进行分页查询系统用户相关配置数据。
+	 // @param params 包含查询条件和分页信息的参数映射，例如页码、每页记录数、查询关键字等。
+	 // @return 封装了分页信息和查询结果的 PageUtils 对象，包含当前页的数据列表、总记录数、总页数等信息。
+
+	PageUtils queryPage(Map<String, Object> params);
+}

src/main/java/com/service/JizhangpingzhengService.java

@@ -0,0 +1,60 @@
+package com.service;
+
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.service.IService;
+import com.utils.PageUtils;
+import com.entity.JizhangpingzhengEntity;
+import java.util.List;
+import java.util.Map;
+import com.entity.vo.JizhangpingzhengVO;
+import org.apache.ibatis.annotations.Param;
+import com.entity.view.JizhangpingzhengView;
+
+//记账凭证
+ //此接口用于处理记账凭证相关的业务逻辑，继承自 MyBatis-Plus 的 IService 接口，
+ // 具备对 JizhangpingzhengEntity 实体对象的基本增删改查功能，同时提供了自定义的查询和分页方法。
+// @author
+ //@email
+ // @date 2021-04-24 15:19:31
+
+public interface JizhangpingzhengService extends IService<JizhangpingzhengEntity> {
+
+	// 根据传入的参数对记账凭证数据进行分页查询。
+	 //@param params 包含查询条件和分页信息的参数映射，如页码、每页记录数、查询关键字等。
+	 //@return 封装了分页信息和查询结果的 PageUtils 对象，包含当前页的记账凭证数据列表、总记录数、总页数等信息。
+
+	PageUtils queryPage(Map<String, Object> params);
+
+	//根据指定的查询条件，查询记账凭证值对象（VO）列表。
+	 // 值对象（VO）一般用于封装特定业务场景下需要展示或处理的数据，可能只包含实体类的部分字段。
+	// @param wrapper 用于构建查询条件的包装器，可设置各种条件（如等于、大于、小于等）来筛选记账凭证数据。
+	 //@return 符合查询条件的记账凭证值对象列表，若没有符合条件的数据则返回空列表。
+
+	List<JizhangpingzhengVO> selectListVO(Wrapper<JizhangpingzhengEntity> wrapper);
+
+	// 根据指定的查询条件，查询单个记账凭证值对象（VO）。
+	 //@param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个记账凭证值对象，若没有符合条件的数据则返回 null。
+
+	JizhangpingzhengVO selectVO(@Param("ew") Wrapper<JizhangpingzhengEntity> wrapper);
+
+	// 根据指定的查询条件，查询记账凭证视图对象列表。
+	 // 视图对象通常用于展示数据，可能包含关联查询或格式化后的数据。
+	 //@param wrapper 用于构建查询条件的包装器。
+	 //@return 符合查询条件的记账凭证视图对象列表，若没有符合条件的数据则返回空列表。
+
+	List<JizhangpingzhengView> selectListView(Wrapper<JizhangpingzhengEntity> wrapper);
+
+	// 根据指定的查询条件，查询单个记账凭证视图对象。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个记账凭证视图对象，若没有符合条件的数据则返回 null。
+
+	JizhangpingzhengView selectView(@Param("ew") Wrapper<JizhangpingzhengEntity> wrapper);
+
+	// 根据传入的参数和查询条件对记账凭证数据进行分页查询。
+	 //@param params 包含查询条件和分页信息的参数映射。
+	 //@param wrapper 用于构建查询条件的包装器，可进一步细化查询条件。
+	 // @return 封装了分页信息和查询结果的 PageUtils 对象。
+
+	PageUtils queryPage(Map<String, Object> params, Wrapper<JizhangpingzhengEntity> wrapper);
+}

src/main/java/com/service/RijizhangService.java

@@ -0,0 +1,61 @@
+package com.service;
+
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.service.IService;
+import com.utils.PageUtils;
+import com.entity.RijizhangEntity;
+import java.util.List;
+import java.util.Map;
+import com.entity.vo.RijizhangVO;
+import org.apache.ibatis.annotations.Param;
+import com.entity.view.RijizhangView;
+
+//日记账
+// 该接口用于处理日记账相关的业务逻辑，继承自 MyBatis-Plus 的 IService 接口，
+// 具备对 RijizhangEntity 实体的基本增删改查功能，同时提供了自定义的查询和分页方法。
+//@author
+// @email
+//@date 2021-04-24 15:19:31
+
+public interface RijizhangService extends IService<RijizhangEntity> {
+
+	//根据传入的参数对日记账数据进行分页查询。
+	 //@param params 包含查询条件和分页信息的参数映射，如页码、每页记录数、查询关键字等。
+	// @return 封装了分页信息和查询结果的 PageUtils 对象，包含当前页的日记账数据列表、总记录数、总页数等信息。
+
+	PageUtils queryPage(Map<String, Object> params);
+
+	// 根据指定的查询条件，查询日记账值对象（VO）列表。
+	//值对象（VO）通常用于封装特定业务场景下需要展示或处理的数据，可能只包含实体类的部分字段。
+	 // @param wrapper 用于构建查询条件的包装器，可设置各种条件（如等于、大于、小于等）来筛选日记账数据。
+	 //@return 符合查询条件的日记账值对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<RijizhangVO> selectListVO(Wrapper<RijizhangEntity> wrapper);
+
+	// 根据指定的查询条件，查询单个日记账值对象（VO）。
+	// @param wrapper 用于构建查询条件的包装器。
+	//@return 符合查询条件的单个日记账值对象，如果没有符合条件的数据则返回 null。
+
+	RijizhangVO selectVO(@Param("ew") Wrapper<RijizhangEntity> wrapper);
+
+	// 根据指定的查询条件，查询日记账视图对象列表。
+	// 视图对象通常用于展示数据，可能包含关联查询或格式化后的数据。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 //@return 符合查询条件的日记账视图对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<RijizhangView> selectListView(Wrapper<RijizhangEntity> wrapper);
+
+	// 根据指定的查询条件，查询单个日记账视图对象。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个日记账视图对象，如果没有符合条件的数据则返回 null。
+
+	RijizhangView selectView(@Param("ew") Wrapper<RijizhangEntity> wrapper);
+
+	//根据传入的参数和查询条件对日记账数据进行分页查询。
+	 // @param params 包含查询条件和分页信息的参数映射。
+	 // @param wrapper 用于构建查询条件的包装器，可进一步细化查询条件。
+	 // @return 封装了分页信息和查询结果的 PageUtils 对象。
+
+	PageUtils queryPage(Map<String, Object> params, Wrapper<RijizhangEntity> wrapper);
+}
+

src/main/java/com/service/ShangpinchukuService.java

@@ -0,0 +1,60 @@
+package com.service;
+
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.service.IService;
+import com.utils.PageUtils;
+import com.entity.ShangpinchukuEntity;
+import java.util.List;
+import java.util.Map;
+import com.entity.vo.ShangpinchukuVO;
+import org.apache.ibatis.annotations.Param;
+import com.entity.view.ShangpinchukuView;
+
+// 商品出库
+ // 此接口主要用于处理商品出库相关的业务逻辑，继承自 MyBatis-Plus 的 IService 接口，
+ //具备对 ShangpinchukuEntity 实体对象的基本增删改查功能，同时定义了一些自定义的查询和分页方法。
+ //@author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+public interface ShangpinchukuService extends IService<ShangpinchukuEntity> {
+
+	// 根据传入的参数对商品出库信息进行分页查询。
+	//@param params 包含查询条件和分页信息的参数映射，例如页码、每页记录数、筛选条件等。
+	// @return 封装了分页信息和查询结果的 PageUtils 对象，包含当前页的商品出库信息列表、总记录数、总页数等。
+
+	PageUtils queryPage(Map<String, Object> params);
+
+	//根据指定的查询条件，查询商品出库值对象（VO）列表。
+	 // 值对象（VO）一般用于封装特定业务场景下需要展示或处理的数据，可能只包含实体类的部分字段。
+	// @param wrapper 用于构建查询条件的包装器，可设置各种条件（如等于、大于、小于等）来筛选商品出库信息。
+	 //@return 符合查询条件的商品出库值对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<ShangpinchukuVO> selectListVO(Wrapper<ShangpinchukuEntity> wrapper);
+
+	// 根据指定的查询条件，查询单个商品出库值对象（VO）。
+	 //@param wrapper 用于构建查询条件的包装器。
+	 //@return 符合查询条件的单个商品出库值对象，如果没有符合条件的数据则返回 null。
+
+	ShangpinchukuVO selectVO(@Param("ew") Wrapper<ShangpinchukuEntity> wrapper);
+
+	//根据指定的查询条件，查询商品出库视图对象列表。
+	 // 视图对象通常用于展示数据，可能包含关联查询或格式化后的数据。
+	 //@param wrapper 用于构建查询条件的包装器。
+	 //@return 符合查询条件的商品出库视图对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<ShangpinchukuView> selectListView(Wrapper<ShangpinchukuEntity> wrapper);
+
+	// 根据指定的查询条件，查询单个商品出库视图对象。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 //@return 符合查询条件的单个商品出库视图对象，如果没有符合条件的数据则返回 null。
+
+	ShangpinchukuView selectView(@Param("ew") Wrapper<ShangpinchukuEntity> wrapper);
+
+	// 根据传入的参数和查询条件对商品出库信息进行分页查询。
+	 // @param params 包含查询条件和分页信息的参数映射。
+	 // @param wrapper 用于构建查询条件的包装器，可进一步细化查询条件。
+	 //@return 封装了分页信息和查询结果的 PageUtils 对象。
+
+	PageUtils queryPage(Map<String, Object> params, Wrapper<ShangpinchukuEntity> wrapper);
+}

src/main/java/com/service/ShangpinkucunService.java

@@ -0,0 +1,61 @@
+package com.service;
+
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.service.IService;
+import com.utils.PageUtils;
+import com.entity.ShangpinkucunEntity;
+import java.util.List;
+import java.util.Map;
+import com.entity.vo.ShangpinkucunVO;
+import org.apache.ibatis.annotations.Param;
+import com.entity.view.ShangpinkucunView;
+
+// 商品库存
+ // 该接口负责处理商品库存相关的业务逻辑，继承自 MyBatis-Plus 的 IService 接口，
+ // 具备对 ShangpinkucunEntity 实体的基本增删改查功能，同时提供了自定义的查询和分页方法。
+// @author
+// @email
+// @date 2021-04-24 15:19:31
+
+public interface ShangpinkucunService extends IService<ShangpinkucunEntity> {
+
+	//根据传入的参数对商品库存信息进行分页查询。
+	 // @param params 包含查询条件和分页信息的参数映射，例如页码、每页记录数、查询关键字等。
+	 // @return 封装了分页信息和查询结果的 PageUtils 对象，包含当前页的商品库存信息列表、总记录数、总页数等。
+
+	PageUtils queryPage(Map<String, Object> params);
+
+	// 根据指定的查询条件，查询商品库存值对象（VO）列表。
+	//值对象（VO）通常用于封装特定业务场景下需要展示或处理的数据，可能只包含实体类的部分字段。
+	//@param wrapper 用于构建查询条件的包装器，可设置各种条件（如等于、大于、小于等）来筛选商品库存信息。
+	 // @return 符合查询条件的商品库存值对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<ShangpinkucunVO> selectListVO(Wrapper<ShangpinkucunEntity> wrapper);
+
+	// 根据指定的查询条件，查询单个商品库存值对象（VO）。
+	 //@param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个商品库存值对象，如果没有符合条件的数据则返回 null。
+
+	ShangpinkucunVO selectVO(@Param("ew") Wrapper<ShangpinkucunEntity> wrapper);
+
+	// 根据指定的查询条件，查询商品库存视图对象列表。
+	// 视图对象通常用于展示数据，可能包含关联查询或格式化后的数据。
+	// @param wrapper 用于构建查询条件的包装器。
+	// @return 符合查询条件的商品库存视图对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<ShangpinkucunView> selectListView(Wrapper<ShangpinkucunEntity> wrapper);
+
+	// 根据指定的查询条件，查询单个商品库存视图对象。
+	 //@param wrapper 用于构建查询条件的包装器。
+	// @return 符合查询条件的单个商品库存视图对象，如果没有符合条件的数据则返回 null。
+
+	ShangpinkucunView selectView(@Param("ew") Wrapper<ShangpinkucunEntity> wrapper);
+
+	//根据传入的参数和查询条件对商品库存信息进行分页查询。
+	// @param params 包含查询条件和分页信息的参数映射。
+	 //@param wrapper 用于构建查询条件的包装器，可进一步细化查询条件。
+	// @return 封装了分页信息和查询结果的 PageUtils 对象。
+
+	PageUtils queryPage(Map<String, Object> params, Wrapper<ShangpinkucunEntity> wrapper);
+}
+

src/main/java/com/service/ShangpinleixingService.java

@@ -0,0 +1,61 @@
+package com.service;
+
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.service.IService;
+import com.utils.PageUtils;
+import com.entity.ShangpinleixingEntity;
+import java.util.List;
+import java.util.Map;
+import com.entity.vo.ShangpinleixingVO;
+import org.apache.ibatis.annotations.Param;
+import com.entity.view.ShangpinleixingView;
+
+//商品类型
+//此接口用于处理商品类型相关的业务逻辑，继承自 MyBatis-Plus 的 IService 接口，
+ //具备对 ShangpinleixingEntity 实体的基本增删改查功能，同时提供了自定义的查询和分页方法。
+ // @author
+ // @email
+ //@date 2021-04-24 15:19:31
+
+public interface ShangpinleixingService extends IService<ShangpinleixingEntity> {
+
+	//根据传入的参数对商品类型信息进行分页查询。
+	//@param params 包含查询条件和分页信息的参数映射，如页码、每页记录数、查询关键字等。
+	 // @return 封装了分页信息和查询结果的 PageUtils 对象，包含当前页的商品类型信息列表、总记录数、总页数等。
+
+	PageUtils queryPage(Map<String, Object> params);
+
+	// 根据指定的查询条件，查询商品类型值对象（VO）列表。
+	// 值对象（VO）通常用于封装特定业务场景下需要展示或处理的数据，可能只包含实体类的部分字段。
+	// @param wrapper 用于构建查询条件的包装器，可设置各种条件（如等于、大于、小于等）来筛选商品类型信息。
+	 //@return 符合查询条件的商品类型值对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<ShangpinleixingVO> selectListVO(Wrapper<ShangpinleixingEntity> wrapper);
+
+	// 根据指定的查询条件，查询单个商品类型值对象（VO）。
+	 //@param wrapper 用于构建查询条件的包装器。
+	 //@return 符合查询条件的单个商品类型值对象，如果没有符合条件的数据则返回 null。
+
+	ShangpinleixingVO selectVO(@Param("ew") Wrapper<ShangpinleixingEntity> wrapper);
+
+	// 根据指定的查询条件，查询商品类型视图对象列表。
+	 // 视图对象通常用于展示数据，可能包含关联查询或格式化后的数据。
+	// @param wrapper 用于构建查询条件的包装器。
+	 //@return 符合查询条件的商品类型视图对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<ShangpinleixingView> selectListView(Wrapper<ShangpinleixingEntity> wrapper);
+
+	//根据指定的查询条件，查询单个商品类型视图对象。
+	//@param wrapper 用于构建查询条件的包装器。
+	//@return 符合查询条件的单个商品类型视图对象，如果没有符合条件的数据则返回 null。
+
+	ShangpinleixingView selectView(@Param("ew") Wrapper<ShangpinleixingEntity> wrapper);
+
+	// 根据传入的参数和查询条件对商品类型信息进行分页查询。
+	//@param params 包含查询条件和分页信息的参数映射。
+	//@param wrapper 用于构建查询条件的包装器，可进一步细化查询条件。
+	// @return 封装了分页信息和查询结果的 PageUtils 对象。
+
+	PageUtils queryPage(Map<String, Object> params, Wrapper<ShangpinleixingEntity> wrapper);
+}
+

src/main/java/com/service/ShangpinrukuService.java

@@ -0,0 +1,61 @@
+package com.service;
+
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.service.IService;
+import com.utils.PageUtils;
+import com.entity.ShangpinrukuEntity;
+import java.util.List;
+import java.util.Map;
+import com.entity.vo.ShangpinrukuVO;
+import org.apache.ibatis.annotations.Param;
+import com.entity.view.ShangpinrukuView;
+
+//商品入库
+// 该接口主要用于处理商品入库相关的业务逻辑，继承自 MyBatis-Plus 的 IService 接口，
+// 具备对 ShangpinrukuEntity 实体的基本增删改查功能，同时提供了自定义的查询和分页方法。
+ // @author
+ //@email
+ // @date 2021-04-24 15:19:31
+
+public interface ShangpinrukuService extends IService<ShangpinrukuEntity> {
+
+	// 根据传入的参数对商品入库信息进行分页查询。
+	 //@param params 包含查询条件和分页信息的参数映射，如页码、每页记录数、查询关键字等。
+	 // @return 封装了分页信息和查询结果的 PageUtils 对象，包含当前页的商品入库信息列表、总记录数、总页数等。
+
+	PageUtils queryPage(Map<String, Object> params);
+
+	//根据指定的查询条件，查询商品入库值对象（VO）列表。
+	// 值对象（VO）通常用于封装特定业务场景下需要展示或处理的数据，可能只包含实体类的部分字段。
+	 // @param wrapper 用于构建查询条件的包装器，可设置各种条件（如等于、大于、小于等）来筛选商品入库信息。
+	 //@return 符合查询条件的商品入库值对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<ShangpinrukuVO> selectListVO(Wrapper<ShangpinrukuEntity> wrapper);
+
+	// 根据指定的查询条件，查询单个商品入库值对象（VO）。
+	// @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个商品入库值对象，如果没有符合条件的数据则返回 null。
+
+	ShangpinrukuVO selectVO(@Param("ew") Wrapper<ShangpinrukuEntity> wrapper);
+
+	//根据指定的查询条件，查询商品入库视图对象列表。
+	// 视图对象通常用于展示数据，可能包含关联查询或格式化后的数据。
+	// @param wrapper 用于构建查询条件的包装器。
+	// @return 符合查询条件的商品入库视图对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<ShangpinrukuView> selectListView(Wrapper<ShangpinrukuEntity> wrapper);
+
+	// 根据指定的查询条件，查询单个商品入库视图对象。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个商品入库视图对象，如果没有符合条件的数据则返回 null。
+
+	ShangpinrukuView selectView(@Param("ew") Wrapper<ShangpinrukuEntity> wrapper);
+
+	// 根据传入的参数和查询条件对商品入库信息进行分页查询。
+	 // @param params 包含查询条件和分页信息的参数映射。
+	 // @param wrapper 用于构建查询条件的包装器，可进一步细化查询条件。
+	// @return 封装了分页信息和查询结果的 PageUtils 对象。
+
+	PageUtils queryPage(Map<String, Object> params, Wrapper<ShangpinrukuEntity> wrapper);
+}
+

src/main/java/com/service/TokenService.java

@@ -0,0 +1,52 @@
+package com.service;
+
+import java.util.List;
+import java.util.Map;
+
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.service.IService;
+import com.entity.TokenEntity;
+import com.utils.PageUtils;
+
+// token
+//该接口用于处理与 Token 相关的业务逻辑，继承自 MyBatis-Plus 的 IService 接口，
+ // 具备对 TokenEntity 实体的基本增删改查功能，同时定义了一些自定义的业务方法。
+
+public interface TokenService extends IService<TokenEntity> {
+
+	// 根据传入的参数对 Token 数据进行分页查询。
+	 // @param params 包含查询条件和分页信息的参数映射，例如页码、每页记录数、查询关键字等。
+	 // @return 封装了分页信息和查询结果的 PageUtils 对象，包含当前页的 Token 数据列表、总记录数、总页数等信息。
+
+	PageUtils queryPage(Map<String, Object> params);
+
+	//根据指定的查询条件，查询 Token 实体的列表视图。
+	 // @param wrapper 用于构建查询条件的包装器，可设置各种条件（如等于、大于、小于等）来筛选 Token 实体数据。
+	 //@return 符合查询条件的 Token 实体列表，如果没有符合条件的数据则返回空列表。
+
+	List<TokenEntity> selectListView(Wrapper<TokenEntity> wrapper);
+
+	// 根据传入的参数和查询条件对 Token 数据进行分页查询。
+	// 此方法相比 queryPage(Map<String, Object> params) 增加了查询条件包装器，
+	 //可以更灵活地进行条件查询和分页。
+	 // @param params 包含查询条件和分页信息的参数映射。
+	 // @param wrapper 用于构建查询条件的包装器，可进一步细化查询条件。
+	 // @return 封装了分页信息和查询结果的 PageUtils 对象。
+
+	PageUtils queryPage(Map<String, Object> params, Wrapper<TokenEntity> wrapper);
+
+	// 生成 Token。
+	 // @param userid 用户 ID，用于标识生成 Token 对应的用户。
+	 // @param username 用户名，可能用于记录生成 Token 的用户标识。
+	 // @param tableName 表名，可能与 Token 关联的数据库表相关。
+	 // @param role 用户角色，可能用于权限控制或 Token 的相关属性设置。
+	 // @return 生成的 Token 字符串。
+
+	String generateToken(Long userid, String username, String tableName, String role);
+
+	// 根据给定的 Token 获取对应的 Token 实体。
+	 // @param token 要查询的 Token 字符串。
+	 // @return 对应的 Token 实体，如果不存在则返回 null。
+
+	TokenEntity getTokenEntity(String token);
+}

src/main/java/com/service/UserService.java

@@ -0,0 +1,37 @@
+package com.service;
+
+import java.util.List;
+import java.util.Map;
+
+import org.apache.ibatis.annotations.Param;
+
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.service.IService;
+import com.entity.UserEntity;
+import com.utils.PageUtils;
+
+//系统用户
+ // 该接口用于处理系统用户相关的业务逻辑，继承自 MyBatis-Plus 的 IService 接口，
+ // 具备对 UserEntity 实体的基本增删改查功能，同时提供了一些自定义的查询和分页方法。
+
+public interface UserService extends IService<UserEntity> {
+
+	//根据传入的参数对系统用户数据进行分页查询。
+	 // @param params 包含查询条件和分页信息的参数映射，例如页码、每页记录数、查询关键字等。
+	 //@return 封装了分页信息和查询结果的 PageUtils 对象，包含当前页的系统用户数据列表、总记录数、总页数等。
+
+	PageUtils queryPage(Map<String, Object> params);
+
+	// 根据指定的查询条件，查询系统用户实体列表。
+	 // @param wrapper 用于构建查询条件的包装器，可设置各种条件（如等于、大于、小于等）来筛选系统用户数据。
+	 // @return 符合查询条件的系统用户实体列表，如果没有符合条件的数据则返回空列表。
+
+	List<UserEntity> selectListView(Wrapper<UserEntity> wrapper);
+
+	// 根据传入的参数和查询条件对系统用户数据进行分页查询。
+	 //@param params 包含查询条件和分页信息的参数映射。
+	 //@param wrapper 用于构建查询条件的包装器，可进一步细化查询条件。
+	 // @return 封装了分页信息和查询结果的 PageUtils 对象。
+
+	PageUtils queryPage(Map<String, Object> params, Wrapper<UserEntity> wrapper);
+}

src/main/java/com/service/YuangongService.java

@@ -0,0 +1,61 @@
+package com.service;
+
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.service.IService;
+import com.utils.PageUtils;
+import com.entity.YuangongEntity;
+import java.util.List;
+import java.util.Map;
+import com.entity.vo.YuangongVO;
+import org.apache.ibatis.annotations.Param;
+import com.entity.view.YuangongView;
+
+//员工
+//此接口用于处理员工相关的业务逻辑，继承自 MyBatis-Plus 的 IService 接口，
+ // 具备对 YuangongEntity 实体的基本增删改查功能，同时提供了自定义的查询和分页方法。
+// @author
+ // @email
+ //@date 2021-04-24 15:19:31
+
+public interface YuangongService extends IService<YuangongEntity> {
+
+	// 根据传入的参数对员工信息进行分页查询。
+	 // @param params 包含查询条件和分页信息的参数映射，例如页码、每页记录数、查询关键字等。
+	 //@return 封装了分页信息和查询结果的 PageUtils 对象，包含当前页的员工信息列表、总记录数、总页数等。
+
+	PageUtils queryPage(Map<String, Object> params);
+
+	//根据指定的查询条件，查询员工值对象（VO）列表。
+	// 值对象（VO）通常用于封装特定业务场景下需要展示或处理的数据，可能只包含实体类的部分字段。
+	 // @param wrapper 用于构建查询条件的包装器，可设置各种条件（如等于、大于、小于等）来筛选员工信息。
+	 // @return 符合查询条件的员工值对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<YuangongVO> selectListVO(Wrapper<YuangongEntity> wrapper);
+
+	//根据指定的查询条件，查询单个员工值对象（VO）。
+	 //@param wrapper 用于构建查询条件的包装器。
+	 //@return 符合查询条件的单个员工值对象，如果没有符合条件的数据则返回 null。
+
+	YuangongVO selectVO(@Param("ew") Wrapper<YuangongEntity> wrapper);
+
+	// 根据指定的查询条件，查询员工视图对象列表。
+	 //视图对象通常用于展示数据，可能包含关联查询或格式化后的数据。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的员工视图对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<YuangongView> selectListView(Wrapper<YuangongEntity> wrapper);
+
+	// 根据指定的查询条件，查询单个员工视图对象。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个员工视图对象，如果没有符合条件的数据则返回 null。
+
+	YuangongView selectView(@Param("ew") Wrapper<YuangongEntity> wrapper);
+
+	// 根据传入的参数和查询条件对员工信息进行分页查询。
+	 // @param params 包含查询条件和分页信息的参数映射。
+	 //@param wrapper 用于构建查询条件的包装器，可进一步细化查询条件。
+	 // @return 封装了分页信息和查询结果的 PageUtils 对象。
+
+	PageUtils queryPage(Map<String, Object> params, Wrapper<YuangongEntity> wrapper);
+}
+

src/main/java/com/service/YuangongbaoxiaoService.java

@@ -0,0 +1,61 @@
+package com.service;
+
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.service.IService;
+import com.utils.PageUtils;
+import com.entity.YuangongbaoxiaoEntity;
+import java.util.List;
+import java.util.Map;
+import com.entity.vo.YuangongbaoxiaoVO;
+import org.apache.ibatis.annotations.Param;
+import com.entity.view.YuangongbaoxiaoView;
+
+//员工报销
+ //该接口用于处理员工报销相关的业务逻辑，继承自 MyBatis-Plus 的 IService 接口，
+ // 具备对 YuangongbaoxiaoEntity 实体的基本增删改查功能，同时提供了自定义的查询和分页方法。
+ // @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+public interface YuangongbaoxiaoService extends IService<YuangongbaoxiaoEntity> {
+
+	// 根据传入的参数对员工报销信息进行分页查询。
+	 // @param params 包含查询条件和分页信息的参数映射，例如页码、每页记录数、查询关键字等。
+	 // @return 封装了分页信息和查询结果的 PageUtils 对象，包含当前页的员工报销信息列表、总记录数、总页数等。
+
+	PageUtils queryPage(Map<String, Object> params);
+
+	// 根据指定的查询条件，查询员工报销值对象（VO）列表。
+	//值对象（VO）通常用于封装特定业务场景下需要展示或处理的数据，可能只包含实体类的部分字段。
+	// @param wrapper 用于构建查询条件的包装器，可设置各种条件（如等于、大于、小于等）来筛选员工报销信息。
+	 // @return 符合查询条件的员工报销值对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<YuangongbaoxiaoVO> selectListVO(Wrapper<YuangongbaoxiaoEntity> wrapper);
+
+	// 根据指定的查询条件，查询单个员工报销值对象（VO）。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个员工报销值对象，如果没有符合条件的数据则返回 null。
+
+	YuangongbaoxiaoVO selectVO(@Param("ew") Wrapper<YuangongbaoxiaoEntity> wrapper);
+
+	// 根据指定的查询条件，查询员工报销视图对象列表。
+	 // 视图对象通常用于展示数据，可能包含关联查询或格式化后的数据。
+	//@param wrapper 用于构建查询条件的包装器。
+	 //@return 符合查询条件的员工报销视图对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<YuangongbaoxiaoView> selectListView(Wrapper<YuangongbaoxiaoEntity> wrapper);
+
+	// 根据指定的查询条件，查询单个员工报销视图对象。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个员工报销视图对象，如果没有符合条件的数据则返回 null。
+
+	YuangongbaoxiaoView selectView(@Param("ew") Wrapper<YuangongbaoxiaoEntity> wrapper);
+
+	// 根据传入的参数和查询条件对员工报销信息进行分页查询。
+	 // @param params 包含查询条件和分页信息的参数映射。
+	 // @param wrapper 用于构建查询条件的包装器，可进一步细化查询条件。
+	 // @return 封装了分页信息和查询结果的 PageUtils 对象。
+
+	PageUtils queryPage(Map<String, Object> params, Wrapper<YuangongbaoxiaoEntity> wrapper);
+}
+

src/main/java/com/service/YuangongjiaokuanService.java

@@ -0,0 +1,60 @@
+package com.service;
+
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.service.IService;
+import com.utils.PageUtils;
+import com.entity.YuangongjiaokuanEntity;
+import java.util.List;
+import java.util.Map;
+import com.entity.vo.YuangongjiaokuanVO;
+import org.apache.ibatis.annotations.Param;
+import com.entity.view.YuangongjiaokuanView;
+
+// 员工缴款
+ // 该接口负责处理员工缴款相关的业务逻辑，继承自 MyBatis-Plus 的 IService 接口，
+ // 具备对 YuangongjiaokuanEntity 实体的基本增删改查功能，同时提供了自定义的查询和分页方法。
+ // @author
+ // @email
+// @date 2021-04-24 15:19:31
+
+public interface YuangongjiaokuanService extends IService<YuangongjiaokuanEntity> {
+
+	// 根据传入的参数对员工缴款信息进行分页查询。
+	 //@param params 包含查询条件和分页信息的参数映射，如页码、每页记录数、查询关键字等。
+	 // @return 封装了分页信息和查询结果的 PageUtils 对象，包含当前页的员工缴款信息列表、总记录数、总页数等。
+
+	PageUtils queryPage(Map<String, Object> params);
+
+	// 根据指定的查询条件，查询员工缴款值对象（VO）列表。
+	 //值对象（VO）通常用于封装特定业务场景下需要展示或处理的数据，可能只包含实体类的部分字段。
+	 // @param wrapper 用于构建查询条件的包装器，可设置各种条件（如等于、大于、小于等）来筛选员工缴款信息。
+	 //@return 符合查询条件的员工缴款值对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<YuangongjiaokuanVO> selectListVO(Wrapper<YuangongjiaokuanEntity> wrapper);
+
+	//根据指定的查询条件，查询单个员工缴款值对象（VO）。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个员工缴款值对象，如果没有符合条件的数据则返回 null。
+
+	YuangongjiaokuanVO selectVO(@Param("ew") Wrapper<YuangongjiaokuanEntity> wrapper);
+
+	//根据指定的查询条件，查询员工缴款视图对象列表。
+	 // 视图对象通常用于展示数据，可能包含关联查询或格式化后的数据。
+	//@param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的员工缴款视图对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<YuangongjiaokuanView> selectListView(Wrapper<YuangongjiaokuanEntity> wrapper);
+
+	// 根据指定的查询条件，查询单个员工缴款视图对象。
+	// @param wrapper 用于构建查询条件的包装器。
+	 //@return 符合查询条件的单个员工缴款视图对象，如果没有符合条件的数据则返回 null。
+
+	YuangongjiaokuanView selectView(@Param("ew") Wrapper<YuangongjiaokuanEntity> wrapper);
+
+	// 根据传入的参数和查询条件对员工缴款信息进行分页查询。
+	 // @param params 包含查询条件和分页信息的参数映射。
+	 // @param wrapper 用于构建查询条件的包装器，可进一步细化查询条件。
+	 // @return 封装了分页信息和查询结果的 PageUtils 对象。
+
+	PageUtils queryPage(Map<String, Object> params, Wrapper<YuangongjiaokuanEntity> wrapper);
+}

src/main/java/com/service/YuangongxinchouService.java

@@ -0,0 +1,60 @@
+package com.service;
+
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.service.IService;
+import com.utils.PageUtils;
+import com.entity.YuangongxinchouEntity;
+import java.util.List;
+import java.util.Map;
+import com.entity.vo.YuangongxinchouVO;
+import org.apache.ibatis.annotations.Param;
+import com.entity.view.YuangongxinchouView;
+
+// 员工薪酬
+// 该接口主要用于处理员工薪酬相关的业务逻辑，继承自 MyBatis-Plus 的 IService 接口，
+// 具备对 YuangongxinchouEntity 实体的基本增删改查功能，同时提供了自定义的查询和分页方法。
+ //@author
+ // @email
+//@date 2021-04-24 15:19:31
+
+public interface YuangongxinchouService extends IService<YuangongxinchouEntity> {
+
+	//根据传入的参数对员工薪酬信息进行分页查询。
+	 // @param params 包含查询条件和分页信息的参数映射，如页码、每页记录数、查询关键字等。
+	 //@return 封装了分页信息和查询结果的 PageUtils 对象，包含当前页的员工薪酬信息列表、总记录数、总页数等。
+
+	PageUtils queryPage(Map<String, Object> params);
+
+	// 根据指定的查询条件，查询员工薪酬值对象（VO）列表。
+	// 值对象（VO）通常用于封装特定业务场景下需要展示或处理的数据，可能只包含实体类的部分字段。
+	//@param wrapper 用于构建查询条件的包装器，可设置各种条件（如等于、大于、小于等）来筛选员工薪酬信息。
+	// @return 符合查询条件的员工薪酬值对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<YuangongxinchouVO> selectListVO(Wrapper<YuangongxinchouEntity> wrapper);
+
+	// 根据指定的查询条件，查询单个员工薪酬值对象（VO）。
+	 //@param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个员工薪酬值对象，如果没有符合条件的数据则返回 null。
+
+	YuangongxinchouVO selectVO(@Param("ew") Wrapper<YuangongxinchouEntity> wrapper);
+
+	//根据指定的查询条件，查询员工薪酬视图对象列表。
+	 //视图对象通常用于展示数据，可能包含关联查询或格式化后的数据。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的员工薪酬视图对象列表，如果没有符合条件的数据则返回空列表。
+
+	List<YuangongxinchouView> selectListView(Wrapper<YuangongxinchouEntity> wrapper);
+
+	// 根据指定的查询条件，查询单个员工薪酬视图对象。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个员工薪酬视图对象，如果没有符合条件的数据则返回 null。
+
+	YuangongxinchouView selectView(@Param("ew") Wrapper<YuangongxinchouEntity> wrapper);
+
+	// 根据传入的参数和查询条件对员工薪酬信息进行分页查询。
+	 // @param params 包含查询条件和分页信息的参数映射。
+	 // @param wrapper 用于构建查询条件的包装器，可进一步细化查询条件。
+	 // @return 封装了分页信息和查询结果的 PageUtils 对象。
+
+	PageUtils queryPage(Map<String, Object> params, Wrapper<YuangongxinchouEntity> wrapper);
+}

src/main/java/com/service/impl/ChengbenjieyuServiceImpl.java

@@ -0,0 +1,99 @@
+package com.service.impl;
+
+import org.springframework.stereotype.Service;
+import java.util.Map;
+import java.util.List;
+
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.mapper.EntityWrapper;
+import com.baomidou.mybatisplus.plugins.Page;
+import com.baomidou.mybatisplus.service.impl.ServiceImpl;
+import com.utils.PageUtils;
+import com.utils.Query;
+
+import com.dao.ChengbenjieyuDao;
+import com.entity.ChengbenjieyuEntity;
+import com.service.ChengbenjieyuService;
+import com.entity.vo.ChengbenjieyuVO;
+import com.entity.view.ChengbenjieyuView;
+
+//成本结余服务的实现类，实现了 ChengbenjieyuService 接口。
+ // 该类继承自 MyBatis-Plus 的 ServiceImpl 类，借助 MyBatis-Plus 提供的通用 CRUD 方法来操作数据库。
+ //它主要负责处理成本结余相关的数据查询和分页操作。
+
+@Service("chengbenjieyuService")
+public class ChengbenjieyuServiceImpl extends ServiceImpl<ChengbenjieyuDao, ChengbenjieyuEntity> implements ChengbenjieyuService {
+
+	// 根据传入的参数进行分页查询成本结余实体数据。
+	// @param params 包含分页和查询条件的参数 Map。常见的参数可能有页码、每页数量等。
+	//@return 封装了分页信息和查询结果的 PageUtils 对象，方便前端展示和处理分页数据。
+
+	@Override
+	public PageUtils queryPage(Map<String, Object> params) {
+		// 根据传入的参数创建分页对象，用于指定分页查询的要求，如页码、每页数量等。
+		Page<ChengbenjieyuEntity> page = this.selectPage(
+				// 调用 Query 工具类的方法，根据传入的参数生成对应的分页对象。
+				new Query<ChengbenjieyuEntity>(params).getPage(),
+				// 创建一个空的实体包装器，这里不设置具体的查询条件，表示查询所有数据。
+				new EntityWrapper<ChengbenjieyuEntity>()
+		);
+		// 将分页查询得到的结果封装到 PageUtils 对象中，方便后续使用。
+		return new PageUtils(page);
+	}
+
+	// 根据传入的参数和查询条件包装器进行分页查询成本结余视图数据。
+	 // @param params 包含分页和查询条件的参数 Map。
+	 // @param wrapper 用于构建查询条件的包装器，可设置如 where 子句等条件。
+	 //@return 封装了分页信息和查询结果的 PageUtils 对象。
+
+	@Override
+	public PageUtils queryPage(Map<String, Object> params, Wrapper<ChengbenjieyuEntity> wrapper) {
+		// 根据传入的参数创建成本结余视图的分页对象。
+		Page<ChengbenjieyuView> page = new Query<ChengbenjieyuView>(params).getPage();
+		// 调用基础映射器的方法，根据分页对象和查询条件包装器查询成本结余视图列表，并将结果设置到分页对象中。
+		page.setRecords(baseMapper.selectListView(page, wrapper));
+		// 将分页查询得到的结果封装到 PageUtils 对象中。
+		PageUtils pageUtil = new PageUtils(page);
+		return pageUtil;
+	}
+
+	// 根据查询条件包装器查询成本结余值对象（VO）列表。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 //@return 符合查询条件的成本结余值对象（VO）列表。
+
+	@Override
+	public List<ChengbenjieyuVO> selectListVO(Wrapper<ChengbenjieyuEntity> wrapper) {
+		// 调用基础映射器的方法，根据查询条件包装器查询成本结余值对象（VO）列表。
+		return baseMapper.selectListVO(wrapper);
+	}
+
+	// 根据查询条件包装器查询单个成本结余值对象（VO）。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个成本结余值对象（VO），若未找到则可能返回 null。
+
+	@Override
+	public ChengbenjieyuVO selectVO(Wrapper<ChengbenjieyuEntity> wrapper) {
+		// 调用基础映射器的方法，根据查询条件包装器查询单个成本结余值对象（VO）。
+		return baseMapper.selectVO(wrapper);
+	}
+
+	//根据查询条件包装器查询成本结余视图列表。
+	// @param wrapper 用于构建查询条件的包装器。
+	// @return 符合查询条件的成本结余视图列表。
+
+	@Override
+	public List<ChengbenjieyuView> selectListView(Wrapper<ChengbenjieyuEntity> wrapper) {
+		// 调用基础映射器的方法，根据查询条件包装器查询成本结余视图列表。
+		return baseMapper.selectListView(wrapper);
+	}
+
+	// 根据查询条件包装器查询单个成本结余视图。
+	// @param wrapper 用于构建查询条件的包装器。
+	 //@return 符合查询条件的单个成本结余视图，若未找到则可能返回 null。
+
+	@Override
+	public ChengbenjieyuView selectView(Wrapper<ChengbenjieyuEntity> wrapper) {
+		// 调用基础映射器的方法，根据查询条件包装器查询单个成本结余视图。
+		return baseMapper.selectView(wrapper);
+	}
+}

src/main/java/com/service/impl/CommonServiceImpl.java

@@ -0,0 +1,91 @@
+
+package com.service.impl;
+
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import com.dao.CommonDao;
+import com.service.CommonService;
+
+//通用服务的实现类，实现了 CommonService 接口，用于处理系统中一些通用的业务逻辑。
+// 该类依赖于 CommonDao 来进行数据库操作。
+
+@Service("commonService")
+public class CommonServiceImpl implements CommonService {
+
+	// 自动注入 CommonDao 实例，用于执行数据库操作
+	@Autowired
+	private CommonDao commonDao;
+
+	// 根据传入的参数获取选项列表。
+	 // @param params 包含查询条件的参数 Map，用于指定获取选项的条件。
+	 // @return 返回符合条件的选项列表，列表中的元素为字符串类型。
+
+	@Override
+	public List<String> getOption(Map<String, Object> params) {
+		// 调用 CommonDao 的 getOption 方法，根据传入的参数查询选项列表
+		return commonDao.getOption(params);
+	}
+
+	// 根据传入的参数获取关联信息。
+	//@param params 包含查询条件的参数 Map，用于指定获取关联信息的条件。
+	 // @return 返回符合条件的关联信息，以键值对的形式存储在 Map 中。
+
+	@Override
+	public Map<String, Object> getFollowByOption(Map<String, Object> params) {
+		// 调用 CommonDao 的 getFollowByOption 方法，根据传入的参数查询关联信息
+		return commonDao.getFollowByOption(params);
+	}
+
+	// 执行审核操作。
+	 // @param params 包含审核相关信息的参数 Map，如审核对象的标识、审核状态等。
+
+	@Override
+	public void sh(Map<String, Object> params) {
+		// 调用 CommonDao 的 sh 方法，根据传入的参数执行审核操作
+		commonDao.sh(params);
+	}
+
+	// 根据传入的参数统计提醒数量。
+	 // @param params 包含统计条件的参数 Map，用于指定统计提醒数量的条件。
+	 //@return 返回符合条件的提醒数量。
+
+	@Override
+	public int remindCount(Map<String, Object> params) {
+		// 调用 CommonDao 的 remindCount 方法，根据传入的参数统计提醒数量
+		return commonDao.remindCount(params);
+	}
+
+	// 根据传入的参数进行计算并返回计算结果。
+	// @param params 包含计算条件的参数 Map，用于指定计算的条件和相关数据。
+	 //@return 返回计算结果，以键值对的形式存储在 Map 中。
+
+	@Override
+	public Map<String, Object> selectCal(Map<String, Object> params) {
+		// 调用 CommonDao 的 selectCal 方法，根据传入的参数进行计算并返回结果
+		return commonDao.selectCal(params);
+	}
+
+	// 根据传入的参数进行分组查询并返回结果列表。
+	// @param params 包含分组查询条件的参数 Map，用于指定分组查询的条件。
+	 //@return 返回符合条件的分组查询结果列表，列表中的元素为键值对形式的 Map。
+
+	@Override
+	public List<Map<String, Object>> selectGroup(Map<String, Object> params) {
+		// 调用 CommonDao 的 selectGroup 方法，根据传入的参数进行分组查询并返回结果列表
+		return commonDao.selectGroup(params);
+	}
+
+	//根据传入的参数查询值列表。
+	//@param params 包含查询条件的参数 Map，用于指定查询值的条件。
+	 // @return 返回符合条件的值列表，列表中的元素为键值对形式的 Map。
+
+	@Override
+	public List<Map<String, Object>> selectValue(Map<String, Object> params) {
+		// 调用 CommonDao 的 selectValue 方法，根据传入的参数查询值列表
+		return commonDao.selectValue(params);
+	}
+}

src/main/java/com/service/impl/ConfigServiceImpl.java

@@ -0,0 +1,41 @@
+
+package com.service.impl;
+
+import java.util.Map;
+
+import org.springframework.stereotype.Service;
+
+import com.baomidou.mybatisplus.mapper.EntityWrapper;
+import com.baomidou.mybatisplus.plugins.Page;
+import com.baomidou.mybatisplus.service.impl.ServiceImpl;
+import com.dao.ConfigDao;
+import com.entity.ConfigEntity;
+import com.entity.UserEntity;
+import com.service.ConfigService;
+import com.utils.PageUtils;
+import com.utils.Query;
+
+// 配置服务的实现类，实现了 ConfigService 接口。
+// 该类继承自 MyBatis-Plus 的 ServiceImpl 类，借助 MyBatis-Plus 提供的通用 CRUD 方法来操作数据库。
+ // 主要负责处理配置相关的数据分页查询操作。
+
+@Service("configService")
+public class ConfigServiceImpl extends ServiceImpl<ConfigDao, ConfigEntity> implements ConfigService {
+
+	// 根据传入的参数进行分页查询配置实体数据。
+	// @param params 包含分页和查询条件的参数 Map。常见的参数可能有页码、每页数量等。
+	 // @return 封装了分页信息和查询结果的 PageUtils 对象，方便前端展示和处理分页数据。
+
+	@Override
+	public PageUtils queryPage(Map<String, Object> params) {
+		// 根据传入的参数创建分页对象，用于指定分页查询的要求，如页码、每页数量等。
+		Page<ConfigEntity> page = this.selectPage(
+				// 调用 Query 工具类的方法，根据传入的参数生成对应的分页对象。
+				new Query<ConfigEntity>(params).getPage(),
+				// 创建一个空的实体包装器，这里不设置具体的查询条件，表示查询所有数据。
+				new EntityWrapper<ConfigEntity>()
+		);
+		// 将分页查询得到的结果封装到 PageUtils 对象中，方便后续使用。
+		return new PageUtils(page);
+	}
+}

src/main/java/com/service/impl/JizhangpingzhengServiceImpl.java

@@ -0,0 +1,98 @@
+package com.service.impl;
+
+import org.springframework.stereotype.Service;
+import java.util.Map;
+import java.util.List;
+
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.mapper.EntityWrapper;
+import com.baomidou.mybatisplus.plugins.Page;
+import com.baomidou.mybatisplus.service.impl.ServiceImpl;
+import com.utils.PageUtils;
+import com.utils.Query;
+
+import com.dao.JizhangpingzhengDao;
+import com.entity.JizhangpingzhengEntity;
+import com.service.JizhangpingzhengService;
+import com.entity.vo.JizhangpingzhengVO;
+import com.entity.view.JizhangpingzhengView;
+
+//记账凭证服务的实现类，继承自 MyBatis-Plus 的 ServiceImpl 类，
+ //并实现了 JizhangpingzhengService 接口，用于处理记账凭证相关的业务逻辑。
+
+@Service("jizhangpingzhengService")
+public class JizhangpingzhengServiceImpl extends ServiceImpl<JizhangpingzhengDao, JizhangpingzhengEntity> implements JizhangpingzhengService {
+
+	// 根据传入的参数查询记账凭证实体的分页数据。
+	// @param params 包含查询条件和分页参数的 Map，例如页码、每页数量等。
+	// @return 封装了分页信息和查询结果的 PageUtils 对象，便于前端展示分页数据。
+
+	@Override
+	public PageUtils queryPage(Map<String, Object> params) {
+		// 根据传入的参数创建一个分页对象，用于指定分页查询的相关信息
+		Page<JizhangpingzhengEntity> page = this.selectPage(
+				// 通过 Query 工具类根据参数构建分页对象
+				new Query<JizhangpingzhengEntity>(params).getPage(),
+				// 创建一个空的实体包装器，这里不添加额外的查询条件，即查询所有数据
+				new EntityWrapper<JizhangpingzhengEntity>()
+		);
+		// 将分页查询的结果封装到 PageUtils 对象中并返回
+		return new PageUtils(page);
+	}
+
+	// 根据传入的参数和查询条件包装器查询记账凭证视图的分页数据。
+	 // @param params  包含查询条件和分页参数的 Map。
+	 //@param wrapper 用于构建查询条件的包装器，可用于筛选特定的记账凭证数据。
+	 // @return 封装了分页信息和查询结果的 PageUtils 对象。
+
+	@Override
+	public PageUtils queryPage(Map<String, Object> params, Wrapper<JizhangpingzhengEntity> wrapper) {
+		// 根据传入的参数创建记账凭证视图的分页对象
+		Page<JizhangpingzhengView> page = new Query<JizhangpingzhengView>(params).getPage();
+		// 通过基础映射器，根据分页对象和查询条件包装器查询记账凭证视图列表，并设置到分页对象中
+		page.setRecords(baseMapper.selectListView(page, wrapper));
+		// 将分页查询的结果封装到 PageUtils 对象中并返回
+		PageUtils pageUtil = new PageUtils(page);
+		return pageUtil;
+	}
+
+	// 根据查询条件包装器查询记账凭证值对象（VO）的列表。
+	// @param wrapper 用于构建查询条件的包装器。
+	 //@return 符合查询条件的记账凭证值对象（VO）列表。
+
+	@Override
+	public List<JizhangpingzhengVO> selectListVO(Wrapper<JizhangpingzhengEntity> wrapper) {
+		// 通过基础映射器根据查询条件包装器查询记账凭证值对象（VO）列表并返回
+		return baseMapper.selectListVO(wrapper);
+	}
+
+	//根据查询条件包装器查询单个记账凭证值对象（VO）。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个记账凭证值对象（VO），若未找到则可能返回 null。
+
+	@Override
+	public JizhangpingzhengVO selectVO(Wrapper<JizhangpingzhengEntity> wrapper) {
+		// 通过基础映射器根据查询条件包装器查询单个记账凭证值对象（VO）并返回
+		return baseMapper.selectVO(wrapper);
+	}
+
+	// 根据查询条件包装器查询记账凭证视图的列表。
+	 //@param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的记账凭证视图列表。
+
+	@Override
+	public List<JizhangpingzhengView> selectListView(Wrapper<JizhangpingzhengEntity> wrapper) {
+		// 通过基础映射器根据查询条件包装器查询记账凭证视图列表并返回
+		return baseMapper.selectListView(wrapper);
+	}
+
+	// 根据查询条件包装器查询单个记账凭证视图。
+	// @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个记账凭证视图，若未找到则可能返回 null。
+
+	@Override
+	public JizhangpingzhengView selectView(Wrapper<JizhangpingzhengEntity> wrapper) {
+		// 通过基础映射器根据查询条件包装器查询单个记账凭证视图并返回
+		return baseMapper.selectView(wrapper);
+	}
+}

src/main/java/com/service/impl/RijizhangServiceImpl.java

@@ -0,0 +1,104 @@
+package com.service.impl;
+
+import org.springframework.stereotype.Service;
+import java.util.Map;
+import java.util.List;
+
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.mapper.EntityWrapper;
+import com.baomidou.mybatisplus.plugins.Page;
+import com.baomidou.mybatisplus.service.impl.ServiceImpl;
+import com.utils.PageUtils;
+import com.utils.Query;
+
+import com.dao.RijizhangDao;
+import com.entity.RijizhangEntity;
+import com.service.RijizhangService;
+import com.entity.vo.RijizhangVO;
+import com.entity.view.RijizhangView;
+
+//日记账服务的实现类，实现了 RijizhangService 接口。
+ // 继承自 MyBatis-Plus 的 ServiceImpl 类，用于处理与日记账相关的业务逻辑，
+ // 借助 MyBatis-Plus 提供的通用数据访问方法来操作数据库中的日记账数据。
+
+@Service("rijizhangService")
+public class RijizhangServiceImpl extends ServiceImpl<RijizhangDao, RijizhangEntity> implements RijizhangService {
+
+	//根据传入的参数进行分页查询日记账实体数据。
+	 //@param params 包含分页和查询条件的参数 Map，例如：页码、每页数量、查询关键字等。
+	 // @return 封装了分页信息（如总页数、当前页数、每页数量、总记录数等）和查询结果（日记账实体列表）的 PageUtils 对象，
+	//        方便在业务层或展示层进行处理和展示分页数据。
+
+	@Override
+	public PageUtils queryPage(Map<String, Object> params) {
+		// 根据传入的参数创建一个分页对象，用于指定分页查询的相关设置，如页码和每页数量等。
+		Page<RijizhangEntity> page = this.selectPage(
+				// 调用 Query 工具类的方法，根据传入的参数生成对应的分页对象。
+				new Query<RijizhangEntity>(params).getPage(),
+				// 创建一个空的实体包装器，这里不设置具体的查询条件，即查询所有的日记账实体。
+				new EntityWrapper<RijizhangEntity>()
+		);
+		// 将分页查询得到的结果封装到 PageUtils 对象中并返回，以便后续使用。
+		return new PageUtils(page);
+	}
+
+	// 根据传入的参数和查询条件包装器进行分页查询日记账视图数据。
+	 // @param params  包含分页和查询条件的参数 Map，与上面的 queryPage 方法中的 params 类似，
+	//               可用于指定分页和一些通用的查询条件。
+	 // @param wrapper 用于构建具体查询条件的包装器，例如可以设置 where 子句等条件来筛选特定的日记账数据。
+	 // @return 封装了分页信息和查询结果（日记账视图列表）的 PageUtils 对象。
+
+	@Override
+	public PageUtils queryPage(Map<String, Object> params, Wrapper<RijizhangEntity> wrapper) {
+		// 根据传入的参数创建日记账视图的分页对象。
+		Page<RijizhangView> page = new Query<RijizhangView>(params).getPage();
+		// 调用基础映射器（baseMapper）的方法，根据分页对象和查询条件包装器查询日记账视图列表，
+		// 并将查询结果设置到分页对象中。
+		page.setRecords(baseMapper.selectListView(page, wrapper));
+		// 将分页查询得到的结果封装到 PageUtils 对象中并返回。
+		PageUtils pageUtil = new PageUtils(page);
+		return pageUtil;
+	}
+
+	// 根据查询条件包装器查询日记账值对象（VO）的列表。
+	 // @param wrapper 用于构建查询条件的包装器，通过设置条件筛选出符合要求的日记账数据，
+	 //                并以值对象（VO）的形式返回。
+	 // @return 符合查询条件的日记账值对象（VO）列表，用于在业务层进行数据处理和展示。
+
+	@Override
+	public List<RijizhangVO> selectListVO(Wrapper<RijizhangEntity> wrapper) {
+		// 调用基础映射器的方法，根据查询条件包装器查询日记账值对象（VO）列表并返回。
+		return baseMapper.selectListVO(wrapper);
+	}
+
+	// 根据查询条件包装器查询单个日记账值对象（VO）。
+	// @param wrapper 用于构建查询条件的包装器，通过设置精确的条件筛选出唯一的日记账数据，
+	 //               并以值对象（VO）的形式返回。
+	 // @return 符合查询条件的单个日记账值对象（VO），如果没有找到符合条件的数据，则可能返回 null。
+
+	@Override
+	public RijizhangVO selectVO(Wrapper<RijizhangEntity> wrapper) {
+		// 调用基础映射器的方法，根据查询条件包装器查询单个日记账值对象（VO）并返回。
+		return baseMapper.selectVO(wrapper);
+	}
+
+	// 根据查询条件包装器查询日记账视图的列表。
+	 // @param wrapper 用于构建查询条件的包装器，通过设置条件筛选出符合要求的日记账视图数据。
+	 // @return 符合查询条件的日记账视图列表，用于在业务层进行数据展示或进一步处理。
+
+	@Override
+	public List<RijizhangView> selectListView(Wrapper<RijizhangEntity> wrapper) {
+		// 调用基础映射器的方法，根据查询条件包装器查询日记账视图列表并返回。
+		return baseMapper.selectListView(wrapper);
+	}
+
+	// 根据查询条件包装器查询单个日记账视图。
+	 // @param wrapper 用于构建查询条件的包装器，通过设置精确的条件筛选出唯一的日记账视图数据。
+	 // @return 符合查询条件的单个日记账视图，如果没有找到符合条件的数据，则可能返回 null。
+
+	@Override
+	public RijizhangView selectView(Wrapper<RijizhangEntity> wrapper) {
+		// 调用基础映射器的方法，根据查询条件包装器查询单个日记账视图并返回。
+		return baseMapper.selectView(wrapper);
+	}
+}