张金根

src/main/java/com/annotation/APPLoginUser.java

@@ -0,0 +1,26 @@
+package com.annotation;
+
+// 导入用于指定注解可以应用的元素类型的类
+import java.lang.annotation.ElementType;
+// 导入用于指定注解的保留策略的类
+import java.lang.annotation.Retention;
+// 导入用于指定注解保留策略的枚举类型
+import java.lang.annotation.RetentionPolicy;
+// 导入用于指定注解可以应用的目标类型的类
+import java.lang.annotation.Target;
+
+
+ //登录用户信息
+ // 此注解用于标记方法参数，表明该参数是当前登录用户的信息。
+ // 它可以在运行时通过反射机制被读取，以便在方法执行时获取登录用户的相关信息。
+
+// @Target 注解指定该注解可以应用的目标类型，这里是 PARAMETER，即可以应用于方法的参数上
+@Target(ElementType.PARAMETER)
+// @Retention 注解指定该注解的保留策略，这里是 RUNTIME，意味着该注解在运行时可以被 JVM 保留，从而可以通过反射机制获取注解信息
+@Retention(RetentionPolicy.RUNTIME)
+// 定义一个名为 APPLoginUser 的注解
+public @interface APPLoginUser {
+
+    // 注解体为空，这意味着该注解没有定义任何属性，只是作为一个标记使用
+    // 可以在方法参数上使用 @APPLoginUser 来标识该参数与登录用户信息相关
+}

src/main/java/com/annotation/IgnoreAuth.java

@@ -0,0 +1,24 @@
+package com.annotation;
+
+// 导入 Java 注解相关的类，涵盖了用于定义注解属性的通用类
+import java.lang.annotation.*;
+
+
+// 忽略 Token 验证
+ // 此注解的作用是标记某些方法在执行时无需进行 Token 验证。
+ // 在项目里，通常会有部分接口无需进行身份验证，就可以直接访问，
+//这时就能使用这个注解来标记这些方法。
+
+// @Target 注解用来指定该注解可以应用的目标类型，这里是 METHOD，意味着该注解能够应用在方法上
+@Target(ElementType.METHOD)
+// @Retention 注解用于指定该注解的保留策略，这里是 RUNTIME，
+// 表明该注解在运行时可被 JVM 保留，进而可以通过反射机制获取注解信息
+@Retention(RetentionPolicy.RUNTIME)
+// @Documented 注解表明该注解会被包含在 JavaDoc 文档中
+@Documented
+// 定义一个名为 IgnoreAuth 的注解
+public @interface IgnoreAuth {
+
+    // 注解体为空，说明该注解只是作为一个标记使用，不定义任何属性
+    // 可以在方法上使用 @IgnoreAuth 来标记该方法无需进行 Token 验证
+}

src/main/java/com/annotation/LoginUser.java

@@ -0,0 +1,28 @@
+// 声明该类所在的包名为 com.annotation
+package com.annotation;
+
+// 导入用于指定注解可以应用的元素类型的类
+import java.lang.annotation.ElementType;
+// 导入用于指定注解保留策略的类
+import java.lang.annotation.Retention;
+// 导入用于指定注解保留策略的枚举类型
+import java.lang.annotation.RetentionPolicy;
+// 导入用于指定注解可以应用的目标类型的类
+import java.lang.annotation.Target;
+
+
+//登录用户信息
+// 此注解用于标记方法参数，表明该参数和当前登录用户的信息相关。
+// 在程序运行时，可通过反射机制读取该注解，从而获取登录用户的相关信息。
+// @Target 注解指定了该注解可以应用的目标类型，这里设置为 PARAMETER，即该注解可用于方法的参数
+@Target(ElementType.PARAMETER)
+// @Retention 注解指定了该注解的保留策略，这里设置为 RUNTIME，意味着该注解在运行时会被 JVM 保留，能通过反射获取注解信息
+@Retention(RetentionPolicy.RUNTIME)
+
+ //定义一个名为 LoginUser 的注解
+ // 该注解可用于标记那些期望接收登录用户信息的方法参数
+
+public @interface LoginUser {
+    // 注解体为空，说明该注解只是作为一个标记使用，不包含额外的属性
+    // 开发者可以在方法参数上使用 @LoginUser 来表明该参数是登录用户信息
+}

src/main/java/com/config/MyMetaObjectHandler.java

@@ -0,0 +1,49 @@
+// 声明该类所在的包为 com.config
+package com.config;
+
+// 导入日期类，用于表示时间
+import java.util.Date;
+
+// 导入 MyBatis 的 MetaObject 类，它可以用来访问和修改对象的属性
+import org.apache.ibatis.reflection.MetaObject;
+
+// 导入 MyBatis-Plus 的 MetaObjectHandler 类，这是一个元对象处理器接口，用于实现自动填充功能
+import com.baomidou.mybatisplus.mapper.MetaObjectHandler;
+
+
+ // 自定义填充处理器
+// 该类继承自 MyBatis-Plus 的 MetaObjectHandler 类，用于在插入和更新操作时自动填充一些字段的值。
+
+public class MyMetaObjectHandler extends MetaObjectHandler {
+
+
+     // 插入操作时的自动填充方法
+     // 当执行插入操作时，MyBatis-Plus 会调用此方法，允许我们为某些字段自动设置值。
+      //@param metaObject 包含了当前要插入对象的元数据信息，可以通过它来访问和修改对象的属性。
+
+    @Override
+    public void insertFill(MetaObject metaObject) {
+        // 使用 setFieldValByName 方法为指定字段设置值
+        // 这里为名为 "ctime" 的字段设置当前日期和时间，即记录创建的时间
+        // 参数依次为：要设置值的字段名、要设置的值、包含对象元数据的 MetaObject
+        this.setFieldValByName("ctime", new Date(), metaObject);
+    }
+
+
+     // 是否开启更新填充的方法
+     // 该方法返回一个布尔值，用于指示是否开启更新操作时的自动填充功能。
+    // @return false 表示不开启更新填充功能。
+    @Override
+    public boolean openUpdateFill() {
+        return false;
+    }
+
+
+     // 更新操作时的自动填充方法
+     // 由于 openUpdateFill 方法返回 false，即关闭了更新填充功能，所以该方法内不执行任何操作。
+     //@param metaObject 包含了当前要更新对象的元数据信息。
+    @Override
+    public void updateFill(MetaObject metaObject) {
+        // 关闭更新填充、这里不执行
+    }
+}

src/main/java/com/controller/BumenfenleiController.java

@@ -0,0 +1,317 @@
+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.BumenfenleiEntity;
+// 导入部门分类视图类
+import com.entity.view.BumenfenleiView;
+
+// 导入部门分类服务类
+import com.service.BumenfenleiService;
+// 导入令牌服务类
+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("/bumenfenlei")
+public class BumenfenleiController {
+    // 自动注入部门分类服务类的实例
+    @Autowired
+    private BumenfenleiService bumenfenleiService;
+
+
+    //后端列表
+    //该方法用于处理后端获取部门分类列表的请求，支持分页查询。
+    // @param params 请求参数，包含分页、排序等信息
+    // @param bumenfenlei 部门分类实体，用于构建查询条件
+    //@param request HTTP 请求对象
+    // @return 包含分页数据的响应结果
+
+    @RequestMapping("/page")
+    public R page(@RequestParam Map<String, Object> params, BumenfenleiEntity bumenfenlei,
+                  HttpServletRequest request) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<BumenfenleiEntity> ew = new EntityWrapper<BumenfenleiEntity>();
+        // 调用服务类的查询分页方法，传入请求参数和处理后的查询条件
+        PageUtils page = bumenfenleiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, bumenfenlei), params), params));
+        // 返回成功响应，并将分页数据放入响应结果中
+        return R.ok().put("data", page);
+    }
+
+
+     // 前端列表
+     // 该方法用于处理前端获取部门分类列表的请求，支持分页查询。
+     //@param params 请求参数，包含分页、排序等信息
+     // @param bumenfenlei 部门分类实体，用于构建查询条件
+     //@param request HTTP 请求对象
+    // @return 包含分页数据的响应结果
+
+    @RequestMapping("/list")
+    public R list(@RequestParam Map<String, Object> params, BumenfenleiEntity bumenfenlei,
+                  HttpServletRequest request) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<BumenfenleiEntity> ew = new EntityWrapper<BumenfenleiEntity>();
+        // 调用服务类的查询分页方法，传入请求参数和处理后的查询条件
+        PageUtils page = bumenfenleiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, bumenfenlei), params), params));
+        // 返回成功响应，并将分页数据放入响应结果中
+        return R.ok().put("data", page);
+    }
+
+
+     // 列表
+    // 该方法用于获取满足特定条件的部门分类列表。
+     //@param bumenfenlei 部门分类实体，用于构建查询条件
+     // @return 包含部门分类列表的响应结果
+
+    @RequestMapping("/lists")
+    public R list(BumenfenleiEntity bumenfenlei) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<BumenfenleiEntity> ew = new EntityWrapper<BumenfenleiEntity>();
+        // 设置查询条件，使所有字段相等
+        ew.allEq(MPUtil.allEQMapPre(bumenfenlei, "bumenfenlei"));
+        // 调用服务类的查询列表视图方法，传入查询条件
+        return R.ok().put("data", bumenfenleiService.selectListView(ew));
+    }
+
+
+    // 查询
+     // 该方法用于根据条件查询单个部门分类信息。
+     // @param bumenfenlei 部门分类实体，用于构建查询条件
+     // @return 包含查询结果的响应结果
+
+    @RequestMapping("/query")
+    public R query(BumenfenleiEntity bumenfenlei) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<BumenfenleiEntity> ew = new EntityWrapper<BumenfenleiEntity>();
+        // 设置查询条件，使所有字段相等
+        ew.allEq(MPUtil.allEQMapPre(bumenfenlei, "bumenfenlei"));
+        // 调用服务类的查询视图方法，传入查询条件
+        BumenfenleiView bumenfenleiView = bumenfenleiService.selectView(ew);
+        // 返回成功响应，并将查询结果放入响应结果中
+        return R.ok("查询部门分类成功").put("data", bumenfenleiView);
+    }
+
+
+     // 后端详情
+    // 该方法用于获取指定 ID 的部门分类详细信息。
+   // @param id 部门分类的 ID
+    // @return 包含部门分类详细信息的响应结果
+
+    @RequestMapping("/info/{id}")
+    public R info(@PathVariable("id") Long id) {
+        // 根据 ID 查询部门分类实体
+        BumenfenleiEntity bumenfenlei = bumenfenleiService.selectById(id);
+        // 返回成功响应，并将部门分类详细信息放入响应结果中
+        return R.ok().put("data", bumenfenlei);
+    }
+
+
+    // 前端详情
+    // 该方法用于获取指定 ID 的部门分类详细信息。
+    //@param id 部门分类的 ID
+   // @return 包含部门分类详细信息的响应结果
+
+    @RequestMapping("/detail/{id}")
+    public R detail(@PathVariable("id") Long id) {
+        // 根据 ID 查询部门分类实体
+        BumenfenleiEntity bumenfenlei = bumenfenleiService.selectById(id);
+        // 返回成功响应，并将部门分类详细信息放入响应结果中
+        return R.ok().put("data", bumenfenlei);
+    }
+
+
+     // 后端保存
+     // 该方法用于在后端保存新的部门分类信息。
+     //@param bumenfenlei 部门分类实体，包含要保存的信息
+    // @param request HTTP 请求对象
+     //@return 保存成功的响应结果
+
+    @RequestMapping("/save")
+    public R save(@RequestBody BumenfenleiEntity bumenfenlei, HttpServletRequest request) {
+        // 为部门分类实体设置一个唯一的 ID，由当前时间戳和随机数组成
+        bumenfenlei.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(bumenfenlei);
+        // 调用服务类的插入方法，保存部门分类信息
+        bumenfenleiService.insert(bumenfenlei);
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     //前端保存
+    // 该方法用于在前端保存新的部门分类信息。
+     // @param bumenfenlei 部门分类实体，包含要保存的信息
+    // @param request HTTP 请求对象
+    // @return 保存成功的响应结果
+
+    @RequestMapping("/add")
+    public R add(@RequestBody BumenfenleiEntity bumenfenlei, HttpServletRequest request) {
+        // 为部门分类实体设置一个唯一的 ID，由当前时间戳和随机数组成
+        bumenfenlei.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(bumenfenlei);
+        // 调用服务类的插入方法，保存部门分类信息
+        bumenfenleiService.insert(bumenfenlei);
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 修改
+     // 该方法用于修改已有的部门分类信息。
+   // @param bumenfenlei 部门分类实体，包含要修改的信息
+     //@param request HTTP 请求对象
+    //@return 修改成功的响应结果
+
+    @RequestMapping("/update")
+    public R update(@RequestBody BumenfenleiEntity bumenfenlei, HttpServletRequest request) {
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(bumenfenlei);
+        // 调用服务类的更新方法，根据 ID 更新部门分类信息
+        bumenfenleiService.updateById(bumenfenlei); // 全部更新
+        // 返回成功响应
+        return R.ok();
+    }
+
+      //删除
+     //该方法用于批量删除指定 ID 的部门分类信息。
+    // @param ids 要删除的部门分类的 ID 数组
+    // @return 删除成功的响应结果
+
+    @RequestMapping("/delete")
+    public R delete(@RequestBody Long[] ids) {
+        // 调用服务类的批量删除方法，根据 ID 列表删除部门分类信息
+        bumenfenleiService.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<BumenfenleiEntity> wrapper = new EntityWrapper<BumenfenleiEntity>();
+        if (map.get("remindstart") != null) {
+            // 设置查询条件，列值大于等于提醒开始日期
+            wrapper.ge(columnName, map.get("remindstart"));
+        }
+        if (map.get("remindend") != null) {
+            // 设置查询条件，列值小于等于提醒结束日期
+            wrapper.le(columnName, map.get("remindend"));
+        }
+
+        // 调用服务类的统计数量方法，根据查询条件统计满足条件的部门分类数量
+        int count = bumenfenleiService.selectCount(wrapper);
+        // 返回成功响应，并将统计数量放入响应结果中
+        return R.ok().put("count", count);
+    }
+}

src/main/java/com/controller/FapiaoxinxiController.java

@@ -0,0 +1,284 @@
+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.FapiaoxinxiEntity;
+import com.entity.view.FapiaoxinxiView;
+
+import com.service.FapiaoxinxiService;
+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("/fapiaoxinxi")
+public class FapiaoxinxiController {
+    // 自动注入 FapiaoxinxiService 服务类的实例，用于处理发票信息的业务逻辑
+    @Autowired
+    private FapiaoxinxiService fapiaoxinxiService;
+
+
+     // 后端列表
+     // 该方法用于获取发票信息的分页列表，供后端使用
+     // @param params 请求参数，包含分页、排序等信息
+    // @param fapiaoxinxi 发票信息实体，用于构建查询条件
+     // @param request HTTP 请求对象
+     // @return 包含分页数据的响应结果
+
+    @RequestMapping("/page")
+    public R page(@RequestParam Map<String, Object> params, FapiaoxinxiEntity fapiaoxinxi,
+                  HttpServletRequest request) {
+        // 创建一个 EntityWrapper 对象，用于构建 SQL 查询条件
+        EntityWrapper<FapiaoxinxiEntity> ew = new EntityWrapper<FapiaoxinxiEntity>();
+        // 调用 fapiaoxinxiService 的 queryPage 方法进行分页查询，MPUtil 用于处理排序和条件查询
+        PageUtils page = fapiaoxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, fapiaoxinxi), params), params));
+        // 返回成功响应，并将分页数据放入响应结果中
+        return R.ok().put("data", page);
+    }
+
+
+     // 前端列表
+     // 该方法用于获取发票信息的分页列表，供前端使用
+     // @param params 请求参数，包含分页、排序等信息
+     // @param fapiaoxinxi 发票信息实体，用于构建查询条件
+     // @param request HTTP 请求对象
+    //  @return 包含分页数据的响应结果
+
+    @RequestMapping("/list")
+    public R list(@RequestParam Map<String, Object> params, FapiaoxinxiEntity fapiaoxinxi,
+                  HttpServletRequest request) {
+        // 创建一个 EntityWrapper 对象，用于构建 SQL 查询条件
+        EntityWrapper<FapiaoxinxiEntity> ew = new EntityWrapper<FapiaoxinxiEntity>();
+        // 调用 fapiaoxinxiService 的 queryPage 方法进行分页查询，MPUtil 用于处理排序和条件查询
+        PageUtils page = fapiaoxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, fapiaoxinxi), params), params));
+        // 返回成功响应，并将分页数据放入响应结果中
+        return R.ok().put("data", page);
+    }
+
+
+     // 列表
+     // 该方法用于获取满足特定条件的发票信息列表
+     // @param fapiaoxinxi 发票信息实体，用于构建查询条件
+    // @return 包含发票信息列表的响应结果
+
+    @RequestMapping("/lists")
+    public R list(FapiaoxinxiEntity fapiaoxinxi) {
+        // 创建一个 EntityWrapper 对象，用于构建 SQL 查询条件
+        EntityWrapper<FapiaoxinxiEntity> ew = new EntityWrapper<FapiaoxinxiEntity>();
+        // 设置查询条件，使所有字段相等
+        ew.allEq(MPUtil.allEQMapPre(fapiaoxinxi, "fapiaoxinxi"));
+        // 调用 fapiaoxinxiService 的 selectListView 方法查询列表
+        return R.ok().put("data", fapiaoxinxiService.selectListView(ew));
+    }
+
+
+    // 查询
+     //该方法用于根据条件查询单个发票信息
+     // @param fapiaoxinxi 发票信息实体，用于构建查询条件
+     // @return 包含查询结果的响应结果
+
+    @RequestMapping("/query")
+    public R query(FapiaoxinxiEntity fapiaoxinxi) {
+        // 创建一个 EntityWrapper 对象，用于构建 SQL 查询条件
+        EntityWrapper<FapiaoxinxiEntity> ew = new EntityWrapper<FapiaoxinxiEntity>();
+        // 设置查询条件，使所有字段相等
+        ew.allEq(MPUtil.allEQMapPre(fapiaoxinxi, "fapiaoxinxi"));
+        // 调用 fapiaoxinxiService 的 selectView 方法查询单个视图对象
+        FapiaoxinxiView fapiaoxinxiView =  fapiaoxinxiService.selectView(ew);
+        // 返回成功响应，并将查询结果放入响应结果中
+        return R.ok("查询发票信息成功").put("data", fapiaoxinxiView);
+    }
+
+
+     // 后端详情
+    // 该方法用于获取指定 ID 的发票信息详细内容
+     // @param id 发票信息的 ID
+     //@return 包含发票信息详细内容的响应结果
+
+    @RequestMapping("/info/{id}")
+    public R info(@PathVariable("id") Long id) {
+        // 根据 ID 调用 fapiaoxinxiService 的 selectById 方法查询发票信息实体
+        FapiaoxinxiEntity fapiaoxinxi = fapiaoxinxiService.selectById(id);
+        // 返回成功响应，并将发票信息实体放入响应结果中
+        return R.ok().put("data", fapiaoxinxi);
+    }
+
+
+     // 前端详情
+     // 该方法用于获取指定 ID 的发票信息详细内容，供前端使用
+     // @param id 发票信息的 ID
+     // @return 包含发票信息详细内容的响应结果
+
+    @RequestMapping("/detail/{id}")
+    public R detail(@PathVariable("id") Long id) {
+        // 根据 ID 调用 fapiaoxinxiService 的 selectById 方法查询发票信息实体
+        FapiaoxinxiEntity fapiaoxinxi = fapiaoxinxiService.selectById(id);
+        // 返回成功响应，并将发票信息实体放入响应结果中
+        return R.ok().put("data", fapiaoxinxi);
+    }
+
+
+    // 后端保存
+     // 该方法用于在后端保存新的发票信息
+     // @param fapiaoxinxi 发票信息实体，包含要保存的信息
+     // @param request HTTP 请求对象
+     //@return 保存成功的响应结果
+
+    @RequestMapping("/save")
+    public R save(@RequestBody FapiaoxinxiEntity fapiaoxinxi, HttpServletRequest request) {
+        // 为发票信息实体设置一个唯一的 ID，由当前时间戳和随机数组成
+        fapiaoxinxi.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(fapiaoxinxi);
+        // 调用 fapiaoxinxiService 的 insert 方法保存发票信息
+        fapiaoxinxiService.insert(fapiaoxinxi);
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+    // 前端保存
+     //该方法用于在前端保存新的发票信息
+     //@param fapiaoxinxi 发票信息实体，包含要保存的信息
+    // @param request HTTP 请求对象
+     // @return 保存成功的响应结果
+
+    @RequestMapping("/add")
+    public R add(@RequestBody FapiaoxinxiEntity fapiaoxinxi, HttpServletRequest request) {
+        // 为发票信息实体设置一个唯一的 ID，由当前时间戳和随机数组成
+        fapiaoxinxi.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(fapiaoxinxi);
+        // 调用 fapiaoxinxiService 的 insert 方法保存发票信息
+        fapiaoxinxiService.insert(fapiaoxinxi);
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 修改
+     // 该方法用于修改已有的发票信息
+    // @param fapiaoxinxi 发票信息实体，包含要修改的信息
+     // @param request HTTP 请求对象
+     //@return 修改成功的响应结果
+
+    @RequestMapping("/update")
+    public R update(@RequestBody FapiaoxinxiEntity fapiaoxinxi, HttpServletRequest request) {
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(fapiaoxinxi);
+        // 调用 fapiaoxinxiService 的 updateById 方法根据 ID 更新发票信息
+        fapiaoxinxiService.updateById(fapiaoxinxi); // 全部更新
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 删除
+    // 该方法用于批量删除指定 ID 的发票信息
+     // @param ids 要删除的发票信息的 ID 数组
+     // @return 删除成功的响应结果
+
+    @RequestMapping("/delete")
+    public R delete(@RequestBody Long[] ids) {
+        // 调用 fapiaoxinxiService 的 deleteBatchIds 方法批量删除发票信息
+        fapiaoxinxiService.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));
+            }
+        }
+
+        // 创建一个 Wrapper 对象，用于构建 SQL 查询条件
+        Wrapper<FapiaoxinxiEntity> wrapper = new EntityWrapper<FapiaoxinxiEntity>();
+        if (map.get("remindstart") != null) {
+            // 设置查询条件，列值大于等于提醒开始日期
+            wrapper.ge(columnName, map.get("remindstart"));
+        }
+        if (map.get("remindend") != null) {
+            // 设置查询条件，列值小于等于提醒结束日期
+            wrapper.le(columnName, map.get("remindend"));
+        }
+
+        // 调用 fapiaoxinxiService 的 selectCount 方法统计满足条件的发票信息数量
+        int count = fapiaoxinxiService.selectCount(wrapper);
+        // 返回成功响应，并将统计数量放入响应结果中
+        return R.ok().put("count", count);
+    }
+}

src/main/java/com/controller/GongyingshangxinxiController.java

@@ -0,0 +1,277 @@
+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.GongyingshangxinxiEntity;
+import com.entity.view.GongyingshangxinxiView;
+
+import com.service.GongyingshangxinxiService;
+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("/gongyingshangxinxi")
+public class GongyingshangxinxiController {
+    // 自动注入供应商信息服务类的实例，用于处理供应商信息相关业务逻辑
+    @Autowired
+    private GongyingshangxinxiService gongyingshangxinxiService;
+
+     //后端列表
+     // 该方法用于获取供应商信息的分页列表（后端使用），支持根据供应商信息实体构建查询条件
+    // @param params 请求参数，包含分页、排序等信息
+     // @param gongyingshangxinxi 供应商信息实体，用于构建查询条件
+     // @param request HTTP 请求对象
+     // @return R 响应对象，包含操作结果和分页后的供应商信息数据
+
+    @RequestMapping("/page")
+    public R page(@RequestParam Map<String, Object> params, GongyingshangxinxiEntity gongyingshangxinxi,
+                  HttpServletRequest request) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件（当前未添加具体条件）
+        EntityWrapper<GongyingshangxinxiEntity> ew = new EntityWrapper<GongyingshangxinxiEntity>();
+        // 调用供应商信息服务类的 queryPage 方法进行分页查询，MPUtil 用于处理排序和条件查询
+        PageUtils page = gongyingshangxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, gongyingshangxinxi), params), params));
+        // 返回成功响应，并将分页数据放入响应结果中
+        return R.ok().put("data", page);
+    }
+
+
+     // 前端列表
+    // 该方法用于获取供应商信息的分页列表（前端使用），支持根据供应商信息实体构建查询条件
+     // @param params 请求参数，包含分页、排序等信息
+     // @param gongyingshangxinxi 供应商信息实体，用于构建查询条件
+     // @param request HTTP 请求对象
+     // @return R 响应对象，包含操作结果和分页后的供应商信息数据
+
+    @RequestMapping("/list")
+    public R list(@RequestParam Map<String, Object> params, GongyingshangxinxiEntity gongyingshangxinxi,
+                  HttpServletRequest request) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件（当前未添加具体条件）
+        EntityWrapper<GongyingshangxinxiEntity> ew = new EntityWrapper<GongyingshangxinxiEntity>();
+        // 调用供应商信息服务类的 queryPage 方法进行分页查询，MPUtil 用于处理排序和条件查询
+        PageUtils page = gongyingshangxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, gongyingshangxinxi), params), params));
+        // 返回成功响应，并将分页数据放入响应结果中
+        return R.ok().put("data", page);
+    }
+
+
+     // 列表
+     // 该方法用于获取满足特定条件的供应商信息列表
+     // @param gongyingshangxinxi 供应商信息实体，用于构建查询条件
+     // @return R 响应对象，包含操作结果和查询到的供应商信息列表数据
+
+    @RequestMapping("/lists")
+    public R list(GongyingshangxinxiEntity gongyingshangxinxi) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<GongyingshangxinxiEntity> ew = new EntityWrapper<GongyingshangxinxiEntity>();
+        // 设置查询条件，使所有字段相等
+        ew.allEq(MPUtil.allEQMapPre(gongyingshangxinxi, "gongyingshangxinxi"));
+        // 调用供应商信息服务类的 selectListView 方法获取列表数据
+        return R.ok().put("data", gongyingshangxinxiService.selectListView(ew));
+    }
+
+
+     // 查询
+     // 该方法用于根据供应商信息实体的条件查询单个供应商信息视图
+     // @param gongyingshangxinxi 供应商信息实体，用于构建查询条件
+    // @return R 响应对象，包含操作结果和查询到的供应商信息视图数据
+
+    @RequestMapping("/query")
+    public R query(GongyingshangxinxiEntity gongyingshangxinxi) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<GongyingshangxinxiEntity> ew = new EntityWrapper<GongyingshangxinxiEntity>();
+        // 设置查询条件，使所有字段相等
+        ew.allEq(MPUtil.allEQMapPre(gongyingshangxinxi, "gongyingshangxinxi"));
+        // 调用供应商信息服务类的 selectView 方法获取供应商信息视图
+        GongyingshangxinxiView gongyingshangxinxiView = gongyingshangxinxiService.selectView(ew);
+        // 返回成功响应，并将查询结果放入响应结果中
+        return R.ok("查询供应商信息成功").put("data", gongyingshangxinxiView);
+    }
+
+
+    //后端详情
+    // 该方法用于获取指定 ID 的供应商信息详情（后端使用）
+     // @param id 供应商信息的 ID
+     // @return R 响应对象，包含操作结果和指定 ID 的供应商信息数据
+
+    @RequestMapping("/info/{id}")
+    public R info(@PathVariable("id") Long id) {
+        // 根据 ID 调用供应商信息服务类的 selectById 方法获取供应商信息实体
+        GongyingshangxinxiEntity gongyingshangxinxi = gongyingshangxinxiService.selectById(id);
+        // 返回成功响应，并将供应商信息实体放入响应结果中
+        return R.ok().put("data", gongyingshangxinxi);
+    }
+
+
+     // 前端详情
+     // 该方法用于获取指定 ID 的供应商信息详情（前端使用）
+     // @param id 供应商信息的 ID
+     // @return R 响应对象，包含操作结果和指定 ID 的供应商信息数据
+
+    @RequestMapping("/detail/{id}")
+    public R detail(@PathVariable("id") Long id) {
+        // 根据 ID 调用供应商信息服务类的 selectById 方法获取供应商信息实体
+        GongyingshangxinxiEntity gongyingshangxinxi = gongyingshangxinxiService.selectById(id);
+        // 返回成功响应，并将供应商信息实体放入响应结果中
+        return R.ok().put("data", gongyingshangxinxi);
+    }
+
+
+     // 后端保存
+     // 该方法用于在后端保存新的供应商信息
+     // @param gongyingshangxinxi 要保存的供应商信息实体
+     // @param request HTTP 请求对象
+    // @return R 响应对象，包含操作结果
+
+    @RequestMapping("/save")
+    public R save(@RequestBody GongyingshangxinxiEntity gongyingshangxinxi, HttpServletRequest request) {
+        // 为供应商信息实体设置一个唯一的 ID，由当前时间戳和随机数组成
+        gongyingshangxinxi.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(gongyingshangxinxi);
+        // 调用供应商信息服务类的 insert 方法保存供应商信息
+        gongyingshangxinxiService.insert(gongyingshangxinxi);
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 前端保存
+     // 该方法用于在前端保存新的供应商信息
+    // @param gongyingshangxinxi 要保存的供应商信息实体
+     // @param request HTTP 请求对象
+     // @return R 响应对象，包含操作结果
+
+    @RequestMapping("/add")
+    public R add(@RequestBody GongyingshangxinxiEntity gongyingshangxinxi, HttpServletRequest request) {
+        // 为供应商信息实体设置一个唯一的 ID，由当前时间戳和随机数组成
+        gongyingshangxinxi.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(gongyingshangxinxi);
+        // 调用供应商信息服务类的 insert 方法保存供应商信息
+        gongyingshangxinxiService.insert(gongyingshangxinxi);
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 修改
+     // 该方法用于修改已有的供应商信息
+     // @param gongyingshangxinxi 要修改的供应商信息实体
+     // @param request HTTP 请求对象
+     // @return R 响应对象，包含操作结果
+
+    @RequestMapping("/update")
+    public R update(@RequestBody GongyingshangxinxiEntity gongyingshangxinxi, HttpServletRequest request) {
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(gongyingshangxinxi);
+        // 调用供应商信息服务类的 updateById 方法根据 ID 更新供应商信息
+        gongyingshangxinxiService.updateById(gongyingshangxinxi); // 全部更新
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 删除
+    //该方法用于批量删除指定 ID 的供应商信息
+     // @param ids 要删除的供应商信息的 ID 数组
+     // @return R 响应对象，包含操作结果
+
+    @RequestMapping("/delete")
+    public R delete(@RequestBody Long[] ids) {
+        // 调用供应商信息服务类的 deleteBatchIds 方法批量删除供应商信息
+        gongyingshangxinxiService.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<GongyingshangxinxiEntity> wrapper = new EntityWrapper<GongyingshangxinxiEntity>();
+        // 根据提醒开始时间和结束时间设置查询条件
+        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 = gongyingshangxinxiService.selectCount(wrapper);
+        // 返回成功响应，并将统计数量放入响应结果中
+        return R.ok().put("count", count);
+    }
+}

src/main/java/com/controller/KehuxinxiController.java

@@ -0,0 +1,297 @@
+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.KehuxinxiEntity;
+import com.entity.view.KehuxinxiView;
+
+import com.service.KehuxinxiService;
+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("/kehuxinxi")
+public class KehuxinxiController {
+    // 自动注入客户信息服务类的实例，用于处理客户信息相关的业务逻辑
+    @Autowired
+    private KehuxinxiService kehuxinxiService;
+
+
+     // 后端列表
+     // 该方法用于获取客户信息的分页列表（供后端使用），支持根据客户信息实体和登记日期范围进行查询
+     // @param params 请求参数，包含分页、排序等信息
+     // @param kehuxinxi 客户信息实体，用于构建查询条件
+     // @param dengjiriqistart 登记日期的起始时间，非必填参数，格式为 yyyy-MM-dd
+    // @param dengjiriqiend 登记日期的结束时间，非必填参数，格式为 yyyy-MM-dd
+     // @param request HTTP 请求对象
+    // @return R 响应对象，包含操作结果和分页后的客户信息数据
+
+    @RequestMapping("/page")
+    public R page(@RequestParam Map<String, Object> params, KehuxinxiEntity kehuxinxi,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date dengjiriqistart,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date dengjiriqiend,
+                  HttpServletRequest request) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<KehuxinxiEntity> ew = new EntityWrapper<KehuxinxiEntity>();
+        // 如果登记日期起始时间不为空，添加大于等于该时间的查询条件
+        if (dengjiriqistart != null)
+            ew.ge("dengjiriqi", dengjiriqistart);
+        // 如果登记日期结束时间不为空，添加小于等于该时间的查询条件
+        if (dengjiriqiend != null)
+            ew.le("dengjiriqi", dengjiriqiend);
+        // 调用客户信息服务类的 queryPage 方法进行分页查询，MPUtil 用于处理排序和条件查询
+        PageUtils page = kehuxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, kehuxinxi), params), params));
+        // 返回成功响应，并将分页数据放入响应结果中
+        return R.ok().put("data", page);
+    }
+
+
+     // 前端列表
+     // 该方法用于获取客户信息的分页列表（供前端使用），支持根据客户信息实体和登记日期范围进行查询
+     // @param params 请求参数，包含分页、排序等信息
+     // @param kehuxinxi 客户信息实体，用于构建查询条件
+     // @param dengjiriqistart 登记日期的起始时间，非必填参数，格式为 yyyy-MM-dd
+     // @param dengjiriqiend 登记日期的结束时间，非必填参数，格式为 yyyy-MM-dd
+     // @param request HTTP 请求对象
+     // @return R 响应对象，包含操作结果和分页后的客户信息数据
+
+    @RequestMapping("/list")
+    public R list(@RequestParam Map<String, Object> params, KehuxinxiEntity kehuxinxi,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date dengjiriqistart,
+                  @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date dengjiriqiend,
+                  HttpServletRequest request) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<KehuxinxiEntity> ew = new EntityWrapper<KehuxinxiEntity>();
+        // 如果登记日期起始时间不为空，添加大于等于该时间的查询条件
+        if (dengjiriqistart != null)
+            ew.ge("dengjiriqi", dengjiriqistart);
+        // 如果登记日期结束时间不为空，添加小于等于该时间的查询条件
+        if (dengjiriqiend != null)
+            ew.le("dengjiriqi", dengjiriqiend);
+        // 调用客户信息服务类的 queryPage 方法进行分页查询，MPUtil 用于处理排序和条件查询
+        PageUtils page = kehuxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, kehuxinxi), params), params));
+        // 返回成功响应，并将分页数据放入响应结果中
+        return R.ok().put("data", page);
+    }
+
+
+     // 列表
+     // 该方法用于获取满足特定条件的客户信息列表
+     // @param kehuxinxi 客户信息实体，用于构建查询条件
+     // @return R 响应对象，包含操作结果和查询到的客户信息列表数据
+
+    @RequestMapping("/lists")
+    public R list(KehuxinxiEntity kehuxinxi) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<KehuxinxiEntity> ew = new EntityWrapper<KehuxinxiEntity>();
+        // 设置查询条件，使所有字段相等
+        ew.allEq(MPUtil.allEQMapPre(kehuxinxi, "kehuxinxi"));
+        // 调用客户信息服务类的 selectListView 方法获取列表数据
+        return R.ok().put("data", kehuxinxiService.selectListView(ew));
+    }
+
+
+     // 查询
+     // 该方法用于根据客户信息实体的条件查询单个客户信息视图
+     // @param kehuxinxi 客户信息实体，用于构建查询条件
+     // @return R 响应对象，包含操作结果和查询到的客户信息视图数据
+
+    @RequestMapping("/query")
+    public R query(KehuxinxiEntity kehuxinxi) {
+        // 创建一个实体包装器，用于构建 SQL 查询条件
+        EntityWrapper<KehuxinxiEntity> ew = new EntityWrapper<KehuxinxiEntity>();
+        // 设置查询条件，使所有字段相等
+        ew.allEq(MPUtil.allEQMapPre(kehuxinxi, "kehuxinxi"));
+        // 调用客户信息服务类的 selectView 方法获取客户信息视图
+        KehuxinxiView kehuxinxiView = kehuxinxiService.selectView(ew);
+        // 返回成功响应，并将查询结果放入响应结果中
+        return R.ok("查询客户信息成功").put("data", kehuxinxiView);
+    }
+
+
+     // 后端详情
+     // 该方法用于获取指定 ID 的客户信息详情（供后端使用）
+     // @param id 客户信息的 ID
+     // @return R 响应对象，包含操作结果和指定 ID 的客户信息数据
+
+    @RequestMapping("/info/{id}")
+    public R info(@PathVariable("id") Long id) {
+        // 根据 ID 调用客户信息服务类的 selectById 方法获取客户信息实体
+        KehuxinxiEntity kehuxinxi = kehuxinxiService.selectById(id);
+        // 返回成功响应，并将客户信息实体放入响应结果中
+        return R.ok().put("data", kehuxinxi);
+    }
+
+
+     // 前端详情
+     // 该方法用于获取指定 ID 的客户信息详情（供前端使用）
+     // @param id 客户信息的 ID
+     // @return R 响应对象，包含操作结果和指定 ID 的客户信息数据
+
+    @RequestMapping("/detail/{id}")
+    public R detail(@PathVariable("id") Long id) {
+        // 根据 ID 调用客户信息服务类的 selectById 方法获取客户信息实体
+        KehuxinxiEntity kehuxinxi = kehuxinxiService.selectById(id);
+        // 返回成功响应，并将客户信息实体放入响应结果中
+        return R.ok().put("data", kehuxinxi);
+    }
+
+  //后端保存
+     //该方法用于在后端保存新的客户信息
+     // @param kehuxinxi 要保存的客户信息实体
+     // @param request HTTP 请求对象
+     // @return R 响应对象，包含操作结果
+
+    @RequestMapping("/save")
+    public R save(@RequestBody KehuxinxiEntity kehuxinxi, HttpServletRequest request) {
+        // 为客户信息实体设置一个唯一的 ID，由当前时间戳和随机数组成
+        kehuxinxi.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(kehuxinxi);
+        // 调用客户信息服务类的 insert 方法保存客户信息
+        kehuxinxiService.insert(kehuxinxi);
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     // 前端保存
+    // 该方法用于在前端保存新的客户信息
+    // @param kehuxinxi 要保存的客户信息实体
+     //@param request HTTP 请求对象
+   // @return R 响应对象，包含操作结果
+
+    @RequestMapping("/add")
+    public R add(@RequestBody KehuxinxiEntity kehuxinxi, HttpServletRequest request) {
+        // 为客户信息实体设置一个唯一的 ID，由当前时间戳和随机数组成
+        kehuxinxi.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(kehuxinxi);
+        // 调用客户信息服务类的 insert 方法保存客户信息
+        kehuxinxiService.insert(kehuxinxi);
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+   // 修改
+    // 该方法用于修改已有的客户信息
+     // @param kehuxinxi 要修改的客户信息实体
+    // @param request HTTP 请求对象
+     //@return R 响应对象，包含操作结果
+
+    @RequestMapping("/update")
+    public R update(@RequestBody KehuxinxiEntity kehuxinxi, HttpServletRequest request) {
+        // 注释掉的验证实体方法，可用于验证实体数据的合法性
+        //ValidatorUtils.validateEntity(kehuxinxi);
+        // 调用客户信息服务类的 updateById 方法根据 ID 更新客户信息
+        kehuxinxiService.updateById(kehuxinxi); // 全部更新
+        // 返回成功响应
+        return R.ok();
+    }
+
+
+     //删除
+     // 该方法用于批量删除指定 ID 的客户信息
+     // @param ids 要删除的客户信息的 ID 数组
+     // @return R 响应对象，包含操作结果
+
+    @RequestMapping("/delete")
+    public R delete(@RequestBody Long[] ids) {
+        // 调用客户信息服务类的 deleteBatchIds 方法批量删除客户信息
+        kehuxinxiService.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<KehuxinxiEntity> wrapper = new EntityWrapper<KehuxinxiEntity>();
+        // 根据提醒开始时间和结束时间设置查询条件
+        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 = kehuxinxiService.selectCount(wrapper);
+        // 返回成功响应，并将统计数量放入响应结果中
+        return R.ok().put("count", count);
+    }
+}

src/main/java/com/controller/YuangongguanliController.java

@@ -0,0 +1,392 @@
+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.YuangongguanliEntity;
+import com.entity.view.YuangongguanliView;
+
+import com.service.YuangongguanliService;
+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("/yuangongguanli")
+public class YuangongguanliController {
+	// 自动注入员工管理服务类，用于处理员工管理相关业务逻辑
+	@Autowired
+	private YuangongguanliService yuangongguanliService;
+	// 自动注入令牌服务类，用于生成和管理令牌
+	@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) {
+		// 根据管理工号查询员工管理实体
+		YuangongguanliEntity user = yuangongguanliService.selectOne(new EntityWrapper<YuangongguanliEntity>().eq("guanligonghao", username));
+		// 检查用户是否存在且密码是否匹配
+		if (user == null || !user.getMima().equals(password)) {
+			return R.error("账号或密码不正确");
+		}
+		// 生成令牌，包含用户ID、用户名、用户类型（员工管理）和角色（员工管理）
+		String token = tokenService.generateToken(user.getId(), username, "yuangongguanli", "员工管理");
+		// 返回成功响应并附带令牌
+		return R.ok().put("token", token);
+	}
+
+
+	 // 注册
+	 // 处理员工管理的注册请求
+	 // @param yuangongguanli 包含员工管理注册信息的实体对象
+	 // @return R类型响应对象，包含操作结果信息。若注册成功返回成功响应，若工号已存在返回错误响应
+
+	@IgnoreAuth
+	@RequestMapping("/register")
+	public R register(@RequestBody YuangongguanliEntity yuangongguanli) {
+		// （注释掉的）验证实体合法性的方法
+		//ValidatorUtils.validateEntity(yuangongguanli);
+		// 检查管理工号是否已被注册
+		YuangongguanliEntity user = yuangongguanliService.selectOne(new EntityWrapper<YuangongguanliEntity>().eq("guanligonghao", yuangongguanli.getGuanligonghao()));
+		if (user != null) {
+			return R.error("注册用户已存在");
+		}
+		// 生成以当前时间戳为ID
+		Long uId = new Date().getTime();
+		yuangongguanli.setId(uId);
+		// 插入员工管理信息到数据库
+		yuangongguanliService.insert(yuangongguanli);
+		// 返回注册成功的响应
+		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查询员工管理实体
+		YuangongguanliEntity user = yuangongguanliService.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) {
+		// 根据管理工号查询员工管理实体
+		YuangongguanliEntity user = yuangongguanliService.selectOne(new EntityWrapper<YuangongguanliEntity>().eq("guanligonghao", username));
+		// 检查用户是否存在
+		if (user == null) {
+			return R.error("账号不存在");
+		}
+		// 将密码重置为默认值"123456"
+		user.setMima("123456");
+		// 更新员工管理信息（密码）到数据库
+		yuangongguanliService.updateById(user);
+		// 返回密码重置成功的响应
+		return R.ok("密码已重置为：123456");
+	}
+
+
+	 // 后端列表
+	 // 获取员工管理信息的分页列表（后端使用）
+	 // @param params 包含分页、排序等参数的Map对象
+	 // @param yuangongguanli 用于构建查询条件的员工管理实体
+	 //@param request HttpServletRequest对象
+	 // @return R类型响应对象，包含分页后的员工管理信息数据。查询成功则返回带有分页数据的成功响应
+
+	@RequestMapping("/page")
+	public R page(@RequestParam Map<String, Object> params, YuangongguanliEntity yuangongguanli,
+				  HttpServletRequest request) {
+		// 创建用于构建查询条件的EntityWrapper对象
+		EntityWrapper<YuangongguanliEntity> ew = new EntityWrapper<YuangongguanliEntity>();
+		// 调用员工管理服务类的queryPage方法进行分页查询，MPUtil用于处理查询条件和排序
+		PageUtils page = yuangongguanliService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yuangongguanli), params), params));
+		// 返回包含分页数据的成功响应
+		return R.ok().put("data", page);
+	}
+
+
+	 //前端列表
+	 // 获取员工管理信息的分页列表（前端使用）
+	 // @param params 包含分页、排序等参数的Map对象
+	 // @param yuangongguanli 用于构建查询条件的员工管理实体
+	 //@param request HttpServletRequest对象
+	 //@return R类型响应对象，包含分页后的员工管理信息数据。查询成功则返回带有分页数据的成功响应
+
+	@RequestMapping("/list")
+	public R list(@RequestParam Map<String, Object> params, YuangongguanliEntity yuangongguanli,
+				  HttpServletRequest request) {
+		// 创建用于构建查询条件的EntityWrapper对象
+		EntityWrapper<YuangongguanliEntity> ew = new EntityWrapper<YuangongguanliEntity>();
+		// 调用员工管理服务类的queryPage方法进行分页查询，MPUtil用于处理查询条件和排序
+		PageUtils page = yuangongguanliService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yuangongguanli), params), params));
+		// 返回包含分页数据的成功响应
+		return R.ok().put("data", page);
+	}
+
+
+	 // 列表
+	 // 根据员工管理实体的条件获取员工管理信息列表
+	 // @param yuangongguanli 用于构建查询条件的员工管理实体
+	 //@return R类型响应对象，包含查询到的员工管理信息列表。查询成功则返回带有员工管理信息列表的成功响应
+
+	@RequestMapping("/lists")
+	public R list(YuangongguanliEntity yuangongguanli) {
+		// 创建用于构建查询条件的EntityWrapper对象
+		EntityWrapper<YuangongguanliEntity> ew = new EntityWrapper<YuangongguanliEntity>();
+		// 设置查询条件为所有属性等于员工管理实体的对应属性
+		ew.allEq(MPUtil.allEQMapPre(yuangongguanli, "yuangongguanli"));
+		// 调用员工管理服务类的selectListView方法获取员工管理信息列表
+		return R.ok().put("data", yuangongguanliService.selectListView(ew));
+	}
+
+
+	 //查询
+	 //根据员工管理实体的条件查询员工管理视图信息
+	 // @param yuangongguanli 用于构建查询条件的员工管理实体
+	 //@return R类型响应对象，包含查询到的员工管理视图信息。查询成功则返回带有员工管理视图数据的成功响应
+
+	@RequestMapping("/query")
+	public R query(YuangongguanliEntity yuangongguanli) {
+		// 创建用于构建查询条件的EntityWrapper对象
+		EntityWrapper<YuangongguanliEntity> ew = new EntityWrapper<YuangongguanliEntity>();
+		// 设置查询条件为所有属性等于员工管理实体的对应属性
+		ew.allEq(MPUtil.allEQMapPre(yuangongguanli, "yuangongguanli"));
+		// 调用员工管理服务类的selectView方法获取员工管理视图
+		YuangongguanliView yuangongguanliView = yuangongguanliService.selectView(ew);
+		// 返回包含员工管理视图信息的成功响应
+		return R.ok("查询员工管理成功").put("data", yuangongguanliView);
+	}
+
+	//后端详情
+	 // 获取指定ID的员工管理详情信息（后端使用）
+	 // @param id 员工管理记录的ID
+	 // @return R类型响应对象，包含指定ID的员工管理信息。查询成功则返回带有员工管理数据的成功响应
+
+	@RequestMapping("/info/{id}")
+	public R info(@PathVariable("id") Long id) {
+		// 根据ID查询员工管理实体
+		YuangongguanliEntity yuangongguanli = yuangongguanliService.selectById(id);
+		// 返回包含员工管理信息的成功响应
+		return R.ok().put("data", yuangongguanli);
+	}
+
+
+	 // 前端详情
+	 // 获取指定ID的员工管理详情信息（前端使用）
+	 // @param id 员工管理记录的ID
+	 //@return R类型响应对象，包含指定ID的员工管理信息。查询成功则返回带有员工管理数据的成功响应
+
+	@RequestMapping("/detail/{id}")
+	public R detail(@PathVariable("id") Long id) {
+		// 根据ID查询员工管理实体
+		YuangongguanliEntity yuangongguanli = yuangongguanliService.selectById(id);
+		// 返回包含员工管理信息的成功响应
+		return R.ok().put("data", yuangongguanli);
+	}
+
+
+	 // 后端保存
+	 // 保存新的员工管理信息（后端使用）
+	 // @param yuangongguanli 包含员工管理信息的实体对象
+	 // @param request HttpServletRequest对象
+	 // @return R类型响应对象，包含操作结果信息。若管理工号不存在冲突则保存信息并返回成功响应，否则返回错误响应
+
+	@RequestMapping("/save")
+	public R save(@RequestBody YuangongguanliEntity yuangongguanli, HttpServletRequest request) {
+		// 生成一个唯一的ID（先由时间戳和随机数组成，后改为仅时间戳）
+		yuangongguanli.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+		// （注释掉的）验证实体合法性的方法
+		//ValidatorUtils.validateEntity(yuangongguanli);
+		// 检查管理工号是否已存在
+		YuangongguanliEntity user = yuangongguanliService.selectOne(new EntityWrapper<YuangongguanliEntity>().eq("guanligonghao", yuangongguanli.getGuanligonghao()));
+		if (user != null) {
+			return R.error("用户已存在");
+		}
+		// 重新设置ID为当前时间戳
+		yuangongguanli.setId(new Date().getTime());
+		// 插入员工管理信息到数据库
+		yuangongguanliService.insert(yuangongguanli);
+		// 返回保存成功的响应
+		return R.ok();
+	}
+
+
+	 // 前端保存
+	 // 保存新的员工管理信息（前端使用）
+	 //@param yuangongguanli 包含员工管理信息的实体对象
+	 // @param request HttpServletRequest对象
+	 // @return R类型响应对象，包含操作结果信息。若管理工号不存在冲突则保存信息并返回成功响应，否则返回错误响应
+
+	@RequestMapping("/add")
+	public R add(@RequestBody YuangongguanliEntity yuangongguanli, HttpServletRequest request) {
+		// 生成一个唯一的ID（先由时间戳和随机数组成，后改为仅时间戳）
+		yuangongguanli.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+		// （注释掉的）验证实体合法性的方法
+		//ValidatorUtils.validateEntity(yuangongguanli);
+		// 检查管理工号是否已存在
+		YuangongguanliEntity user = yuangongguanliService.selectOne(new EntityWrapper<YuangongguanliEntity>().eq("guanligonghao", yuangongguanli.getGuanligonghao()));
+		if (user != null) {
+			return R.error("用户已存在");
+		}
+		// 重新设置ID为当前时间戳
+		yuangongguanli.setId(new Date().getTime());
+		// 插入员工管理信息到数据库
+		yuangongguanliService.insert(yuangongguanli);
+		// 返回保存成功的响应
+		return R.ok();
+	}
+
+
+	 // 修改
+	 //修改员工管理信息
+	 // @param yuangongguanli 包含修改后员工管理信息的实体对象
+	 // @param request HttpServletRequest对象
+	 // @return R类型响应对象，包含操作结果信息。修改成功则返回成功响应
+
+	@RequestMapping("/update")
+	public R update(@RequestBody YuangongguanliEntity yuangongguanli, HttpServletRequest request) {
+		// （注释掉的）验证实体合法性的方法
+		//ValidatorUtils.validateEntity(yuangongguanli);
+		// 根据员工管理ID更新信息到数据库
+		yuangongguanliService.updateById(yuangongguanli);
+		// 返回修改成功的响应
+		return R.ok();
+	}
+
+
+	 //删除
+	 // 批量删除员工管理信息
+	 // @param ids 要删除的员工管理记录的ID数组
+	 // @return R类型响应对象，包含操作结果信息。删除成功则返回成功响应
+
+	@RequestMapping("/delete")
+	public R delete(@RequestBody Long[] ids) {
+		// 调用员工管理服务类的deleteBatchIds方法批量删除员工管理信息
+		yuangongguanliService.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);
+
+		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<YuangongguanliEntity> wrapper = new EntityWrapper<YuangongguanliEntity>();
+		if(map.get("remindstart")!=null) {
+			wrapper.ge(columnName, map.get("remindstart"));
+		}
+		if(map.get("remindend")!=null) {
+			wrapper.le(columnName, map.get("remindend"));
+		}
+
+
+		int count = yuangongguanliService.selectCount(wrapper);
+		return R.ok().put("count", count);
+	}
+}
+
+
+

src/main/java/com/controller/ZhipiaoxinxiController.java

@@ -0,0 +1,293 @@
+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.ZhipiaoxinxiEntity;
+import com.entity.view.ZhipiaoxinxiView;
+
+import com.service.ZhipiaoxinxiService;
+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("/zhipiaoxinxi")
+public class ZhipiaoxinxiController {
+    // 自动注入ZhipiaoxinxiService实例
+    @Autowired
+    private ZhipiaoxinxiService zhipiaoxinxiService;
+
+
+     // 后端列表
+     // @param params 请求参数
+     // @param zhipiaoxinxi 支票信息实体
+     // @param kaipiaoriqistart 开票日期起始
+     //@param kaipiaoriqiend 开票日期结束
+     // @param request HttpServletRequest对象
+     // @return 包含分页数据的响应
+
+    @RequestMapping("/page")
+    public R page(@RequestParam Map<String, Object> params,ZhipiaoxinxiEntity zhipiaoxinxi,
+                  @RequestParam(required = false) @DateTimeFormat(pattern="yyyy-MM-dd") Date kaipiaoriqistart,
+                  @RequestParam(required = false) @DateTimeFormat(pattern="yyyy-MM-dd") Date kaipiaoriqiend,
+                  HttpServletRequest request){
+        // 创建一个EntityWrapper对象，用于构建查询条件
+        EntityWrapper<ZhipiaoxinxiEntity> ew = new EntityWrapper<ZhipiaoxinxiEntity>();
+        // 如果开票日期起始不为空，添加大于等于该日期的条件
+        if(kaipiaoriqistart!=null) ew.ge("kaipiaoriqi", kaipiaoriqistart);
+        // 如果开票日期结束不为空，添加小于等于该日期的条件
+        if(kaipiaoriqiend!=null) ew.le("kaipiaoriqi", kaipiaoriqiend);
+        // 调用服务层的queryPage方法进行分页查询
+        PageUtils page = zhipiaoxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, zhipiaoxinxi), params), params));
+        // 返回成功响应，并将分页数据放入响应中
+        return R.ok().put("data", page);
+    }
+
+
+     // 前端列表
+     // @param params 请求参数
+     // @param zhipiaoxinxi 支票信息实体
+     // @param kaipiaoriqistart 开票日期起始
+     // @param kaipiaoriqiend 开票日期结束
+     // @param request HttpServletRequest对象
+     // @return 包含分页数据的响应
+
+    @RequestMapping("/list")
+    public R list(@RequestParam Map<String, Object> params,ZhipiaoxinxiEntity zhipiaoxinxi,
+                  @RequestParam(required = false) @DateTimeFormat(pattern="yyyy-MM-dd") Date kaipiaoriqistart,
+                  @RequestParam(required = false) @DateTimeFormat(pattern="yyyy-MM-dd") Date kaipiaoriqiend,
+                  HttpServletRequest request){
+        // 创建一个EntityWrapper对象，用于构建查询条件
+        EntityWrapper<ZhipiaoxinxiEntity> ew = new EntityWrapper<ZhipiaoxinxiEntity>();
+        // 如果开票日期起始不为空，添加大于等于该日期的条件
+        if(kaipiaoriqistart!=null) ew.ge("kaipiaoriqi", kaipiaoriqistart);
+        // 如果开票日期结束不为空，添加小于等于该日期的条件
+        if(kaipiaoriqiend!=null) ew.le("kaipiaoriqi", kaipiaoriqiend);
+        // 调用服务层的queryPage方法进行分页查询
+        PageUtils page = zhipiaoxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, zhipiaoxinxi), params), params));
+        // 返回成功响应，并将分页数据放入响应中
+        return R.ok().put("data", page);
+    }
+
+     // 列表
+     // @param zhipiaoxinxi 支票信息实体
+     // @return 包含查询结果的响应
+
+    @RequestMapping("/lists")
+    public R list( ZhipiaoxinxiEntity zhipiaoxinxi){
+        // 创建一个EntityWrapper对象，用于构建查询条件
+        EntityWrapper<ZhipiaoxinxiEntity> ew = new EntityWrapper<ZhipiaoxinxiEntity>();
+        // 添加所有属性相等的条件
+        ew.allEq(MPUtil.allEQMapPre( zhipiaoxinxi, "zhipiaoxinxi"));
+        // 调用服务层的selectListView方法进行查询
+        return R.ok().put("data", zhipiaoxinxiService.selectListView(ew));
+    }
+
+
+     //查询
+     //@param zhipiaoxinxi 支票信息实体
+     // @return 包含查询结果的响应
+
+    @RequestMapping("/query")
+    public R query(ZhipiaoxinxiEntity zhipiaoxinxi){
+        // 创建一个EntityWrapper对象，用于构建查询条件
+        EntityWrapper< ZhipiaoxinxiEntity> ew = new EntityWrapper< ZhipiaoxinxiEntity>();
+        // 添加所有属性相等的条件
+        ew.allEq(MPUtil.allEQMapPre( zhipiaoxinxi, "zhipiaoxinxi"));
+        // 调用服务层的selectView方法进行查询
+        ZhipiaoxinxiView zhipiaoxinxiView =  zhipiaoxinxiService.selectView(ew);
+        // 返回成功响应，并将查询结果放入响应中
+        return R.ok("查询支票信息成功").put("data", zhipiaoxinxiView);
+    }
+
+
+     // 后端详情
+     // @param id 支票信息的ID
+     // @return 包含支票信息详情的响应
+
+    @RequestMapping("/info/{id}")
+    public R info(@PathVariable("id") Long id){
+        // 根据ID查询支票信息实体
+        ZhipiaoxinxiEntity zhipiaoxinxi = zhipiaoxinxiService.selectById(id);
+        // 返回成功响应，并将支票信息详情放入响应中
+        return R.ok().put("data", zhipiaoxinxi);
+    }
+
+
+    // 前端详情
+     // @param id 支票信息的ID
+     //@return 包含支票信息详情的响应
+
+    @RequestMapping("/detail/{id}")
+    public R detail(@PathVariable("id") Long id){
+        // 根据ID查询支票信息实体
+        ZhipiaoxinxiEntity zhipiaoxinxi = zhipiaoxinxiService.selectById(id);
+        // 返回成功响应，并将支票信息详情放入响应中
+        return R.ok().put("data", zhipiaoxinxi);
+    }
+
+
+     //后端保存
+     // @param zhipiaoxinxi 支票信息实体
+     // @param request HttpServletRequest对象
+     // @return 保存成功的响应
+
+    @RequestMapping("/save")
+    public R save(@RequestBody ZhipiaoxinxiEntity zhipiaoxinxi, HttpServletRequest request){
+        // 为支票信息实体设置ID，ID为当前时间戳加上一个0-999的随机数
+        zhipiaoxinxi.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
+        // 注释掉的代码，原本用于验证实体的合法性
+        //ValidatorUtils.validateEntity(zhipiaoxinxi);
+        // 调用服务层的insert方法保存支票信息
+        zhipiaoxinxiService.insert(zhipiaoxinxi);
+        // 返回保存成功的响应
+        return R.ok();
+    }
+
+
+    //前端保存
+     // @param zhipiaoxinxi 支票信息实体
+     // @param request HttpServletRequest对象
+     // @return 保存成功的响应
+
+    @RequestMapping("/add")
+    public R add(@RequestBody ZhipiaoxinxiEntity zhipiaoxinxi, HttpServletRequest request){
+        // 为支票信息实体设置ID，ID为当前时间戳加上一个0-999的随机数
+        zhipiaoxinxi.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
+        // 注释掉的代码，原本用于验证实体的合法性
+        //ValidatorUtils.validateEntity(zhipiaoxinxi);
+        // 调用服务层的insert方法保存支票信息
+        zhipiaoxinxiService.insert(zhipiaoxinxi);
+        // 返回保存成功的响应
+        return R.ok();
+    }
+
+
+     // 修改
+     // @param zhipiaoxinxi 支票信息实体
+     //@param request HttpServletRequest对象
+     // @return 修改成功的响应
+
+    @RequestMapping("/update")
+    public R update(@RequestBody ZhipiaoxinxiEntity zhipiaoxinxi, HttpServletRequest request){
+        // 注释掉的代码，原本用于验证实体的合法性
+        //ValidatorUtils.validateEntity(zhipiaoxinxi);
+        // 调用服务层的updateById方法更新支票信息
+        zhipiaoxinxiService.updateById(zhipiaoxinxi);//全部更新
+        // 返回修改成功的响应
+        return R.ok();
+    }
+
+
+     // 删除
+     // @param ids 要删除的支票信息的ID数组
+     // @return 删除成功的响应
+
+    @RequestMapping("/delete")
+    public R delete(@RequestBody Long[] ids){
+        // 调用服务层的deleteBatchIds方法批量删除支票信息
+        zhipiaoxinxiService.deleteBatchIds(Arrays.asList(ids));
+        // 返回删除成功的响应
+        return R.ok();
+    }
+
+
+    // 提醒接口
+    // @param columnName 提醒的列名
+     // @param request HttpServletRequest对象
+     // @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对象，用于格式化日期
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+            // 创建Calendar对象，用于处理日期
+            Calendar c = Calendar.getInstance();
+            Date remindStartDate = null;
+            Date remindEndDate = null;
+            // 如果提醒起始日期不为空
+            if(map.get("remindstart")!=null) {
+                // 将提醒起始天数转换为整数
+                Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
+                // 设置Calendar对象的时间为当前时间
+                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());
+                // 设置Calendar对象的时间为当前时间
+                c.setTime(new Date());
+                // 在当前时间上加上提醒结束天数
+                c.add(Calendar.DAY_OF_MONTH,remindEnd);
+                // 获取提醒结束日期
+                remindEndDate = c.getTime();
+                // 将格式化后的提醒结束日期放入请求参数中
+                map.put("remindend", sdf.format(remindEndDate));
+            }
+        }
+
+        // 创建一个Wrapper对象，用于构建查询条件
+        Wrapper<ZhipiaoxinxiEntity> wrapper = new EntityWrapper<ZhipiaoxinxiEntity>();
+        // 如果提醒起始日期不为空，添加大于等于该日期的条件
+        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 = zhipiaoxinxiService.selectCount(wrapper);
+        // 返回成功响应，并将提醒数量放入响应中
+        return R.ok().put("count", count);
+    }
+}

src/main/java/com/dao/BumenfenleiDao.java

@@ -0,0 +1,74 @@
+package com.dao;
+
+import com.entity.BumenfenleiEntity;
+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.BumenfenleiVO;
+import com.entity.view.BumenfenleiView;
+
+
+ // 部门分类数据访问接口，继承自MyBatis-Plus的BaseMapper接口，
+ //用于定义与部门分类实体（BumenfenleiEntity）相关的数据访问方法。
+ // 借助MyBatis-Plus的BaseMapper，已经具备了一些基本的CRUD（增删改查）操作能力，
+ //而本接口在此基础上定义了一些自定义的查询方法。
+ //@author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+public interface BumenfenleiDao extends BaseMapper<BumenfenleiEntity> {
+
+
+	// 根据查询条件包装器查询部门分类值对象（VO）的列表。
+	 // 值对象（VO）通常是为了特定业务场景而封装的，可能包含实体类的部分属性或经过处理后的属性。
+	 // @param wrapper 用于构建查询条件的包装器，通过设置条件筛选出符合要求的部门分类数据，
+	 //               并以值对象（VO）的形式返回。
+	 // @param ("ew ")使用@Param注解指定参数名称为"ew"，
+	 //           这在MyBatis映射器中用于明确参数的标识，方便在SQL映射文件中引用该参数来构建查询条件。
+	 // @return 符合查询条件的部门分类值对象（VO）列表，可用于业务层进行数据处理和展示。
+
+	List<BumenfenleiVO> selectListVO(@Param("ew") Wrapper<BumenfenleiEntity> wrapper);
+
+
+	 // 根据查询条件包装器查询单个部门分类值对象（VO）。
+	 //@param wrapper 用于构建查询条件的包装器，通过设置精确的条件筛选出唯一的部门分类数据，
+	 //                并以值对象（VO）的形式返回。
+	 // @param ("ew") 使用@Param注解指定参数名称为"ew"，
+	 //          这在MyBatis映射器中用于明确参数的标识，方便在SQL映射文件中引用该参数来构建查询条件。
+	 // @return 符合查询条件的单个部门分类值对象（VO），如果没有找到符合条件的数据，则可能返回null。
+
+	BumenfenleiVO selectVO(@Param("ew") Wrapper<BumenfenleiEntity> wrapper);
+
+
+	 // 根据查询条件包装器查询部门分类视图的列表。
+	 // 视图（View）可能是对实体数据进行了特定的组装或处理，以满足不同的展示需求。
+	 // @param wrapper 用于构建查询条件的包装器，通过设置条件筛选出符合要求的部门分类视图数据。
+	 //@param ("ew") 使用@Param注解指定参数名称为"ew"，
+	 //           这在MyBatis映射器中用于明确参数的标识，方便在SQL映射文件中引用该参数来构建查询条件。
+	 // @return 符合查询条件的部门分类视图列表，可用于业务层进行数据展示或进一步处理。
+
+	List<BumenfenleiView> selectListView(@Param("ew") Wrapper<BumenfenleiEntity> wrapper);
+
+
+	 // 根据分页信息和查询条件包装器查询部门分类视图的列表。
+	 // 此方法提供了分页查询的功能，结合分页信息和查询条件来获取数据。
+	 // @param page 分页信息对象，包含了当前页码、每页数量等信息，用于实现分页查询。
+	 //@param wrapper 用于构建查询条件的包装器，通过设置条件筛选出符合要求的部门分类视图数据。
+	 //@param ("ew") 使用@Param注解指定参数名称为"ew"，
+	 //          这在MyBatis映射器中用于明确参数的标识，方便在SQL映射文件中引用该参数来构建查询条件。
+	 // @return 符合查询条件的部门分类视图列表，可用于业务层进行数据展示或进一步处理，且进行了分页处理。
+
+	List<BumenfenleiView> selectListView(Pagination page, @Param("ew") Wrapper<BumenfenleiEntity> wrapper);
+
+
+	 //根据查询条件包装器查询单个部门分类视图。
+	 // @param wrapper 用于构建查询条件的包装器，通过设置精确的条件筛选出唯一的部门分类视图数据。
+	 // @param ("ew") 使用@Param注解指定参数名称为"ew"，
+	 //           这在MyBatis映射器中用于明确参数的标识，方便在SQL映射文件中引用该参数来构建查询条件。
+	// @return 符合查询条件的单个部门分类视图，如果没有找到符合条件的数据，则可能返回null。
+
+	BumenfenleiView selectView(@Param("ew") Wrapper<BumenfenleiEntity> wrapper);
+}

src/main/java/com/dao/FapiaoxinxiDao.java

@@ -0,0 +1,61 @@
+package com.dao;
+
+import com.entity.FapiaoxinxiEntity;
+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.FapiaoxinxiVO;
+import com.entity.view.FapiaoxinxiView;
+
+
+ // 发票信息
+ // 此接口用于操作发票信息相关的数据，继承了 MyBatis-Plus 的 BaseMapper 接口，具备基本的增删改查功能。
+ // @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+public interface FapiaoxinxiDao extends BaseMapper<FapiaoxinxiEntity> {
+
+
+	 // 根据查询条件 wrapper 查询发票信息的 VO（值对象）列表。
+	 // VO 通常用于封装需要展示给前端或传递给其他层的数据，可能包含了部分字段的组合或计算结果。
+	 // @param wrapper 用于构建查询条件的包装器，可包含如等于、大于、小于等各种查询条件。
+	 // @return 符合查询条件的发票信息 VO 列表。
+
+	List<FapiaoxinxiVO> selectListVO(@Param("ew") Wrapper<FapiaoxinxiEntity> wrapper);
+
+
+	 // 根据查询条件 wrapper 查询单个发票信息的 VO。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个发票信息 VO，如果没有匹配的记录则返回 null。
+
+	FapiaoxinxiVO selectVO(@Param("ew") Wrapper<FapiaoxinxiEntity> wrapper);
+
+
+	 // 根据查询条件 wrapper 查询发票信息的视图列表。
+	 //视图通常是对数据库表进行特定查询和处理后得到的虚拟表，这里的视图对象可能包含了一些经过处理或关联查询后的数据。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的发票信息视图列表。
+
+	List<FapiaoxinxiView> selectListView(@Param("ew") Wrapper<FapiaoxinxiEntity> wrapper);
+
+
+	 //根据分页信息 page 和查询条件 wrapper 查询发票信息的视图列表。
+	 // 该方法支持分页查询，可用于在大量数据中按页获取发票信息。
+	 // @param page 分页对象，包含了当前页码、每页显示数量等分页信息。
+	// @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的当前页发票信息视图列表。
+
+	List<FapiaoxinxiView> selectListView(Pagination page, @Param("ew") Wrapper<FapiaoxinxiEntity> wrapper);
+
+
+	 //根据查询条件 wrapper 查询单个发票信息的视图。
+	//@param wrapper 用于构建查询条件的包装器。
+	 //@return 符合查询条件的单个发票信息视图，如果没有匹配的记录则返回 null。
+
+	FapiaoxinxiView selectView(@Param("ew") Wrapper<FapiaoxinxiEntity> wrapper);
+
+}

src/main/java/com/dao/GongyingshangxinxiDao.java

@@ -0,0 +1,59 @@
+package com.dao;
+
+import com.entity.GongyingshangxinxiEntity;
+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.GongyingshangxinxiVO;
+import com.entity.view.GongyingshangxinxiView;
+
+
+ //供应商信息
+ // 该接口主要用于与数据库中供应商信息表进行交互，继承自 MyBatis-Plus 的 BaseMapper 接口，可使用其提供的基本 CRUD 操作。
+ //@author
+// @date 2021-04-24 15:19:31
+
+public interface GongyingshangxinxiDao extends BaseMapper<GongyingshangxinxiEntity> {
+
+
+	 // 根据指定的查询条件查询供应商信息值对象（VO）列表。
+	 // VO 通常用于封装特定业务场景下需要的数据，可避免直接暴露实体类的所有字段。
+	 //@param wrapper 用于构建查询条件的包装器，可包含各种条件（如等于、大于、小于等）。
+	 // @return 符合查询条件的供应商信息 VO 列表。
+
+	List<GongyingshangxinxiVO> selectListVO(@Param("ew") Wrapper<GongyingshangxinxiEntity> wrapper);
+
+
+	 // 根据指定的查询条件查询单个供应商信息值对象（VO）。
+	 //@param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的单个供应商信息 VO，若未找到则返回 null。
+
+	GongyingshangxinxiVO selectVO(@Param("ew") Wrapper<GongyingshangxinxiEntity> wrapper);
+
+
+	 // 根据指定的查询条件查询供应商信息视图对象列表。
+	 //视图对象通常是对实体类进行加工处理后得到的，用于满足特定展示需求。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 //@return 符合查询条件的供应商信息视图对象列表。
+
+	List<GongyingshangxinxiView> selectListView(@Param("ew") Wrapper<GongyingshangxinxiEntity> wrapper);
+
+
+	 // 根据分页信息和查询条件查询供应商信息视图对象列表。
+	 //支持分页查询，便于处理大量数据。
+	 // @param page 分页对象，包含当前页码、每页记录数等信息。
+	 // @param wrapper 用于构建查询条件的包装器。
+	// @return 当前页符合查询条件的供应商信息视图对象列表。
+
+	List<GongyingshangxinxiView> selectListView(Pagination page, @Param("ew") Wrapper<GongyingshangxinxiEntity> wrapper);
+
+
+	 //根据指定的查询条件查询单个供应商信息视图对象。
+	 //@param wrapper 用于构建查询条件的包装器。
+	 //@return 符合查询条件的单个供应商信息视图对象，若未找到则返回 null。
+
+	GongyingshangxinxiView selectView(@Param("ew") Wrapper<GongyingshangxinxiEntity> wrapper);
+}

src/main/java/com/dao/KehuxinxiDao.java

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

src/main/java/com/dao/YuangongguanliDao.java

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

src/main/java/com/dao/ZhipiaoxinxiDao.java

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

src/main/java/com/entity/BumenfenleiEntity.java

@@ -0,0 +1,112 @@
+package com.entity;
+
+// 导入 MyBatis-Plus 注解，用于指定主键
+import com.baomidou.mybatisplus.annotations.TableId;
+// 导入 MyBatis-Plus 注解，用于指定数据库表名
+import com.baomidou.mybatisplus.annotations.TableName;
+// 导入验证注解，用于验证字符串不为空字符串
+import javax.validation.constraints.NotBlank;
+// 导入验证注解，用于验证集合或数组不为空
+import javax.validation.constraints.NotEmpty;
+// 导入验证注解，用于验证对象不为 null
+import javax.validation.constraints.NotNull;
+// 导入 Jackson 注解，用于忽略 JSON 序列化和反序列化时的某些属性
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+// 导入反射调用方法时可能抛出的异常类
+import java.lang.reflect.InvocationTargetException;
+// 导入可序列化接口，使该类的对象可以进行序列化和反序列化操作
+import java.io.Serializable;
+// 导入日期类，用于表示日期和时间
+import java.util.Date;
+// 导入列表类，用于表示一组对象
+import java.util.List;
+// 导入 Spring 框架的日期格式化注解
+import org.springframework.format.annotation.DateTimeFormat;
+// 导入 Jackson 注解，用于指定日期在 JSON 中的格式化方式
+import com.fasterxml.jackson.annotation.JsonFormat;
+// 导入 Apache Commons BeanUtils 工具类，用于对象属性的复制
+import org.apache.commons.beanutils.BeanUtils;
+// 导入 MyBatis-Plus 注解，用于指定字段的填充策略
+import com.baomidou.mybatisplus.annotations.TableField;
+// 导入 MyBatis-Plus 枚举，用于指定字段的填充策略
+import com.baomidou.mybatisplus.enums.FieldFill;
+// 导入 MyBatis-Plus 枚举，用于指定主键的生成类型
+import com.baomidou.mybatisplus.enums.IdType;
+
+// 部门分类
+ // 数据库通用操作实体类（普通增删改查）
+ // @author
+ // @email
+ // @date 2021-04-24 15:19:31
+
+// 使用 TableName 注解指定该实体类对应的数据库表名为 "bumenfenlei"
+@TableName("bumenfenlei")
+// 定义泛型实体类，用于接收不同类型的对象并进行属性复制
+public class BumenfenleiEntity<T> implements Serializable {
+	// 定义序列化版本号，用于在反序列化时验证类的版本一致性
+	private static final long serialVersionUID = 1L;
+
+	// 无参构造函数，用于创建一个空的 BumenfenleiEntity 对象
+	public BumenfenleiEntity() {
+	}
+
+	// 有参构造函数，接受一个泛型对象 t，将其属性复制到当前对象
+	public BumenfenleiEntity(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/FapiaoxinxiEntity.java

@@ -0,0 +1,194 @@
+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("fapiaoxinxi")
+public class FapiaoxinxiEntity<T> implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+
+	public FapiaoxinxiEntity() {
+		
+	}
+	
+	public FapiaoxinxiEntity(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 fapiaobianhao;
+	
+	// 客户姓名
+
+					
+	private String kehuxingming;
+	
+	// 商品名称
+
+					
+	private String shangpinmingcheng;
+	
+	// 商品单价
+
+					
+	private Integer shangpindanjia;
+	
+	//商品数量
+
+					
+	private Integer shangpinshuliang;
+	
+	//总金额
+
+					
+	private String zongjine;
+	
+	// 开票日期
+
+				
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd")
+	@DateTimeFormat 		
+	private Date kaipiaoriqi;
+	
+	//备注
+
+					
+	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 setFapiaobianhao(String fapiaobianhao) {
+		this.fapiaobianhao = fapiaobianhao;
+	}
+	// 获取：发票编号
+
+	public String getFapiaobianhao() {
+		return fapiaobianhao;
+	}
+	// 设置：客户姓名
+
+	public void setKehuxingming(String kehuxingming) {
+		this.kehuxingming = kehuxingming;
+	}
+	// 获取：客户姓名
+
+	public String getKehuxingming() {
+		return kehuxingming;
+	}
+	//设置：商品名称
+
+	public void setShangpinmingcheng(String shangpinmingcheng) {
+		this.shangpinmingcheng = shangpinmingcheng;
+	}
+	//获取：商品名称
+
+	public String getShangpinmingcheng() {
+		return shangpinmingcheng;
+	}
+	//设置：商品单价
+
+	public void setShangpindanjia(Integer shangpindanjia) {
+		this.shangpindanjia = shangpindanjia;
+	}
+	// 获取：商品单价
+
+	public Integer getShangpindanjia() {
+		return shangpindanjia;
+	}
+	// 设置：商品数量
+
+	public void setShangpinshuliang(Integer shangpinshuliang) {
+		this.shangpinshuliang = shangpinshuliang;
+	}
+	// 获取：商品数量
+
+	public Integer getShangpinshuliang() {
+		return shangpinshuliang;
+	}
+	// 设置：总金额
+
+	public void setZongjine(String zongjine) {
+		this.zongjine = zongjine;
+	}
+	//获取：总金额
+
+	public String getZongjine() {
+		return zongjine;
+	}
+	// 设置：开票日期
+
+	public void setKaipiaoriqi(Date kaipiaoriqi) {
+		this.kaipiaoriqi = kaipiaoriqi;
+	}
+	// 获取：开票日期
+
+	public Date getKaipiaoriqi() {
+		return kaipiaoriqi;
+	}
+	// 设置：备注
+
+	public void setBeizhu(String beizhu) {
+		this.beizhu = beizhu;
+	}
+	//获取：备注
+
+	public String getBeizhu() {
+		return beizhu;
+	}
+
+}

src/main/java/com/entity/GongyingshangxinxiEntity.java

@@ -0,0 +1,194 @@
+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("gongyingshangxinxi")
+public class GongyingshangxinxiEntity<T> implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+
+	public GongyingshangxinxiEntity() {
+		
+	}
+	
+	public GongyingshangxinxiEntity(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 gongyingshangxingming;
+	
+	// 公司名称
+
+					
+	private String gongsimingcheng;
+	
+	//公司地址
+
+					
+	private String gongsidizhi;
+	
+	// 供应产品
+
+					
+	private String gongyingchanpin;
+	
+	// 联系电话
+
+					
+	private String lianxidianhua;
+	
+	//合作时长
+
+					
+	private String hezuoshizhang;
+	
+	// 备注
+
+					
+	private String beizhu;
+	
+	//登记日期
+
+				
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd")
+	@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 setGongyingshangxingming(String gongyingshangxingming) {
+		this.gongyingshangxingming = gongyingshangxingming;
+	}
+	// 获取：供应商姓名
+
+	public String getGongyingshangxingming() {
+		return gongyingshangxingming;
+	}
+	// 设置：公司名称
+
+	public void setGongsimingcheng(String gongsimingcheng) {
+		this.gongsimingcheng = gongsimingcheng;
+	}
+	// 获取：公司名称
+
+	public String getGongsimingcheng() {
+		return gongsimingcheng;
+	}
+	// 设置：公司地址
+
+	public void setGongsidizhi(String gongsidizhi) {
+		this.gongsidizhi = gongsidizhi;
+	}
+	// 获取：公司地址
+
+	public String getGongsidizhi() {
+		return gongsidizhi;
+	}
+	//设置：供应产品
+
+	public void setGongyingchanpin(String gongyingchanpin) {
+		this.gongyingchanpin = gongyingchanpin;
+	}
+	// 获取：供应产品
+
+	public String getGongyingchanpin() {
+		return gongyingchanpin;
+	}
+	//设置：联系电话
+
+	public void setLianxidianhua(String lianxidianhua) {
+		this.lianxidianhua = lianxidianhua;
+	}
+	// 获取：联系电话
+
+	public String getLianxidianhua() {
+		return lianxidianhua;
+	}
+	//设置：合作时长
+
+	public void setHezuoshizhang(String hezuoshizhang) {
+		this.hezuoshizhang = hezuoshizhang;
+	}
+	//获取：合作时长
+
+	public String getHezuoshizhang() {
+		return hezuoshizhang;
+	}
+	// 设置：备注
+
+	public void setBeizhu(String beizhu) {
+		this.beizhu = beizhu;
+	}
+	// 获取：备注
+
+	public String getBeizhu() {
+		return beizhu;
+	}
+	//设置：登记日期
+
+	public void setDengjiriqi(Date dengjiriqi) {
+		this.dengjiriqi = dengjiriqi;
+	}
+	// 获取：登记日期
+
+	public Date getDengjiriqi() {
+		return dengjiriqi;
+	}
+
+}

src/main/java/com/entity/KehuxinxiEntity.java

@@ -0,0 +1,194 @@
+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("kehuxinxi")
+public class KehuxinxiEntity<T> implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+
+	public KehuxinxiEntity() {
+		
+	}
+	
+	public KehuxinxiEntity(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 kehuxingming;
+	
+	// 公司名称
+
+					
+	private String gongsimingcheng;
+	
+	// 公司地址
+
+					
+	private String gongsidizhi;
+	
+	//合作项目
+
+					
+	private String hezuoxiangmu;
+	
+	//合作时长
+
+					
+	private String hezuoshizhang;
+	
+	// 联系电话
+
+					
+	private String lianxidianhua;
+	
+	// 备注
+
+					
+	private String beizhu;
+	
+	// 登记日期
+
+				
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd")
+	@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 setKehuxingming(String kehuxingming) {
+		this.kehuxingming = kehuxingming;
+	}
+	// 获取：客户姓名
+
+	public String getKehuxingming() {
+		return kehuxingming;
+	}
+	// 设置：公司名称
+
+	public void setGongsimingcheng(String gongsimingcheng) {
+		this.gongsimingcheng = gongsimingcheng;
+	}
+	// 获取：公司名称
+
+	public String getGongsimingcheng() {
+		return gongsimingcheng;
+	}
+	// 设置：公司地址
+
+	public void setGongsidizhi(String gongsidizhi) {
+		this.gongsidizhi = gongsidizhi;
+	}
+	// 获取：公司地址
+
+	public String getGongsidizhi() {
+		return gongsidizhi;
+	}
+	// 设置：合作项目
+
+	public void setHezuoxiangmu(String hezuoxiangmu) {
+		this.hezuoxiangmu = hezuoxiangmu;
+	}
+	// 获取：合作项目
+
+	public String getHezuoxiangmu() {
+		return hezuoxiangmu;
+	}
+	// 设置：合作时长
+
+	public void setHezuoshizhang(String hezuoshizhang) {
+		this.hezuoshizhang = hezuoshizhang;
+	}
+	// 获取：合作时长
+
+	public String getHezuoshizhang() {
+		return hezuoshizhang;
+	}
+	// 设置：联系电话
+
+	public void setLianxidianhua(String lianxidianhua) {
+		this.lianxidianhua = lianxidianhua;
+	}
+	// 获取：联系电话
+
+	public String getLianxidianhua() {
+		return lianxidianhua;
+	}
+	// 设置：备注
+
+	public void setBeizhu(String beizhu) {
+		this.beizhu = beizhu;
+	}
+	// 获取：备注
+
+	public String getBeizhu() {
+		return beizhu;
+	}
+	// 设置：登记日期
+
+	public void setDengjiriqi(Date dengjiriqi) {
+		this.dengjiriqi = dengjiriqi;
+	}
+	// 获取：登记日期
+
+	public Date getDengjiriqi() {
+		return dengjiriqi;
+	}
+
+}

src/main/java/com/entity/YuangongguanliEntity.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("yuangongguanli")
+public class YuangongguanliEntity<T> implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+
+	public YuangongguanliEntity() {
+		
+	}
+	
+	public YuangongguanliEntity(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 guanligonghao;
+	
+	// 密码
+
+					
+	private String mima;
+	
+	// 管理姓名
+
+					
+	private String guanlixingming;
+	
+	// 性别
+
+					
+	private String xingbie;
+	
+	// 职位
+
+					
+	private String zhiwei;
+	
+	// 手机
+
+					
+	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 setGuanligonghao(String guanligonghao) {
+		this.guanligonghao = guanligonghao;
+	}
+	// 获取：管理工号
+
+	public String getGuanligonghao() {
+		return guanligonghao;
+	}
+	// 设置：密码
+
+	public void setMima(String mima) {
+		this.mima = mima;
+	}
+	//获取：密码
+
+	public String getMima() {
+		return mima;
+	}
+	// 设置：管理姓名
+
+	public void setGuanlixingming(String guanlixingming) {
+		this.guanlixingming = guanlixingming;
+	}
+	//获取：管理姓名
+
+	public String getGuanlixingming() {
+		return guanlixingming;
+	}
+	// 设置：性别
+
+	public void setXingbie(String xingbie) {
+		this.xingbie = xingbie;
+	}
+	//获取：性别
+
+	public String getXingbie() {
+		return xingbie;
+	}
+	// 设置：职位
+
+	public void setZhiwei(String zhiwei) {
+		this.zhiwei = zhiwei;
+	}
+	//获取：职位
+
+	public String getZhiwei() {
+		return zhiwei;
+	}
+	//设置：手机
+
+	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/ZhipiaoxinxiEntity.java

@@ -0,0 +1,163 @@
+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("zhipiaoxinxi")
+public class ZhipiaoxinxiEntity<T> implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+
+	public ZhipiaoxinxiEntity() {
+		
+	}
+	
+	public ZhipiaoxinxiEntity(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 zhipiaohao;
+	
+	// 收款单位
+
+	private String shoukuandanwei;
+	
+	// 金额
+
+					
+	private Integer jine;
+	
+	// 用途
+
+					
+	private String yongtu;
+	
+	//备注
+
+					
+	private String beizhu;
+	
+	// 开票日期
+
+				
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd")
+	@DateTimeFormat 		
+	private Date kaipiaoriqi;
+	
+	
+	@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 setZhipiaohao(String zhipiaohao) {
+		this.zhipiaohao = zhipiaohao;
+	}
+	// 获取：支票号
+
+	public String getZhipiaohao() {
+		return zhipiaohao;
+	}
+	// 设置：收款单位
+
+	public void setShoukuandanwei(String shoukuandanwei) {
+		this.shoukuandanwei = shoukuandanwei;
+	}
+	//获取：收款单位
+
+	public String getShoukuandanwei() {
+		return shoukuandanwei;
+	}
+	//设置：金额
+
+	public void setJine(Integer jine) {
+		this.jine = jine;
+	}
+	// 获取：金额
+
+	public Integer getJine() {
+		return jine;
+	}
+	//设置：用途
+
+	public void setYongtu(String yongtu) {
+		this.yongtu = yongtu;
+	}
+	//获取：用途
+
+	public String getYongtu() {
+		return yongtu;
+	}
+	//设置：备注
+
+	public void setBeizhu(String beizhu) {
+		this.beizhu = beizhu;
+	}
+	//获取：备注
+
+	public String getBeizhu() {
+		return beizhu;
+	}
+	//设置：开票日期
+
+	public void setKaipiaoriqi(Date kaipiaoriqi) {
+		this.kaipiaoriqi = kaipiaoriqi;
+	}
+	//获取：开票日期
+
+	public Date getKaipiaoriqi() {
+		return kaipiaoriqi;
+	}
+
+}

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

@@ -0,0 +1,25 @@
+package com.entity.model;
+
+import com.entity.BumenfenleiEntity;
+
+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 BumenfenleiModel  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 				
+}

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

@@ -0,0 +1,178 @@
+package com.entity.model;
+
+import com.entity.FapiaoxinxiEntity;
+
+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名称
+// @email
+ // @date 2021-04-24 15:19:31
+
+public class FapiaoxinxiModel  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+
+	 // 客户姓名
+
+	
+	private String kehuxingming;
+		
+
+	 // 商品名称
+
+	
+	private String shangpinmingcheng;
+		
+
+	 //商品单价
+
+	
+	private Integer shangpindanjia;
+		
+
+	 // 商品数量
+
+	
+	private Integer shangpinshuliang;
+		
+
+	 //总金额
+
+	
+	private String zongjine;
+		
+
+	 // 开票日期
+		
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 
+	private Date kaipiaoriqi;
+		
+
+	// 备注
+
+	
+	private String beizhu;
+				
+	
+
+	 // 设置：客户姓名
+
+	 
+	public void setKehuxingming(String kehuxingming) {
+		this.kehuxingming = kehuxingming;
+	}
+	
+
+	 // 获取：客户姓名
+
+	public String getKehuxingming() {
+		return kehuxingming;
+	}
+				
+	
+
+	 // 设置：商品名称
+
+	public void setShangpinmingcheng(String shangpinmingcheng) {
+		this.shangpinmingcheng = shangpinmingcheng;
+	}
+	
+
+	 // 获取：商品名称
+
+	public String getShangpinmingcheng() {
+		return shangpinmingcheng;
+	}
+				
+	
+
+	 // 设置：商品单价
+
+	 
+	public void setShangpindanjia(Integer shangpindanjia) {
+		this.shangpindanjia = shangpindanjia;
+	}
+	
+
+	 // 获取：商品单价
+
+	public Integer getShangpindanjia() {
+		return shangpindanjia;
+	}
+				
+	
+
+	//设置：商品数量
+
+	 
+	public void setShangpinshuliang(Integer shangpinshuliang) {
+		this.shangpinshuliang = shangpinshuliang;
+	}
+	
+
+	 // 获取：商品数量
+
+	public Integer getShangpinshuliang() {
+		return shangpinshuliang;
+	}
+				
+	
+
+	 // 设置：总金额
+
+	 
+	public void setZongjine(String zongjine) {
+		this.zongjine = zongjine;
+	}
+	
+
+	 //获取：总金额
+
+	public String getZongjine() {
+		return zongjine;
+	}
+				
+	
+
+	 // 设置：开票日期
+
+	 
+	public void setKaipiaoriqi(Date kaipiaoriqi) {
+		this.kaipiaoriqi = kaipiaoriqi;
+	}
+	
+
+	 //获取：开票日期
+
+	public Date getKaipiaoriqi() {
+		return kaipiaoriqi;
+	}
+				
+	
+
+	 // 设置：备注
+
+	 
+	public void setBeizhu(String beizhu) {
+		this.beizhu = beizhu;
+	}
+	
+
+	 // 获取：备注
+
+	public String getBeizhu() {
+		return beizhu;
+	}
+			
+}

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

@@ -0,0 +1,178 @@
+package com.entity.model;
+
+import com.entity.GongyingshangxinxiEntity;
+
+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 GongyingshangxinxiModel  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+
+	 //公司名称
+
+	
+	private String gongsimingcheng;
+		
+
+	 // 公司地址
+
+	
+	private String gongsidizhi;
+		
+
+	 //供应产品
+
+	
+	private String gongyingchanpin;
+		
+
+	 // 联系电话
+
+	
+	private String lianxidianhua;
+		
+
+	//合作时长
+
+	
+	private String hezuoshizhang;
+		
+
+	 //备注
+
+	
+	private String beizhu;
+		
+
+	 //登记日期
+
+		
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 
+	private Date dengjiriqi;
+				
+	
+
+	 //设置：公司名称
+
+	 
+	public void setGongsimingcheng(String gongsimingcheng) {
+		this.gongsimingcheng = gongsimingcheng;
+	}
+	
+	// 获取：公司名称
+
+	public String getGongsimingcheng() {
+		return gongsimingcheng;
+	}
+				
+	
+
+	 //设置：公司地址
+
+	 
+	public void setGongsidizhi(String gongsidizhi) {
+		this.gongsidizhi = gongsidizhi;
+	}
+	
+
+	 // 获取：公司地址
+
+	public String getGongsidizhi() {
+		return gongsidizhi;
+	}
+				
+	
+
+	 // 设置：供应产品
+
+	 
+	public void setGongyingchanpin(String gongyingchanpin) {
+		this.gongyingchanpin = gongyingchanpin;
+	}
+	
+
+	 // 获取：供应产品
+
+	public String getGongyingchanpin() {
+		return gongyingchanpin;
+	}
+				
+	
+
+	 //设置：联系电话
+
+	 
+	public void setLianxidianhua(String lianxidianhua) {
+		this.lianxidianhua = lianxidianhua;
+	}
+	
+
+	 // 获取：联系电话
+
+	public String getLianxidianhua() {
+		return lianxidianhua;
+	}
+				
+
+	 // 设置：合作时长
+
+	 
+	public void setHezuoshizhang(String hezuoshizhang) {
+		this.hezuoshizhang = hezuoshizhang;
+	}
+	
+
+	 // 获取：合作时长
+
+	public String getHezuoshizhang() {
+		return hezuoshizhang;
+	}
+				
+	
+
+	 // 设置：备注
+
+	public void setBeizhu(String beizhu) {
+		this.beizhu = beizhu;
+	}
+	
+
+	 // 获取：备注
+
+	public String getBeizhu() {
+		return beizhu;
+	}
+				
+	
+
+	 // 设置：登记日期
+
+	 
+	public void setDengjiriqi(Date dengjiriqi) {
+		this.dengjiriqi = dengjiriqi;
+	}
+	
+
+	 // 获取：登记日期
+
+	public Date getDengjiriqi() {
+		return dengjiriqi;
+	}
+			
+}

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

@@ -0,0 +1,160 @@
+package com.entity.model;
+
+import com.entity.KehuxinxiEntity;
+
+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 KehuxinxiModel  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	// 公司名称
+
+	
+	private String gongsimingcheng;
+		
+	//公司地址
+
+	
+	private String gongsidizhi;
+		
+	// 合作项目
+
+	
+	private String hezuoxiangmu;
+		
+	// 合作时长
+
+	
+	private String hezuoshizhang;
+		
+	// 联系电话
+
+	
+	private String lianxidianhua;
+		
+	//备注
+
+	
+	private String beizhu;
+		
+	//登记日期
+
+		
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 
+	private Date dengjiriqi;
+				
+	
+	//设置：公司名称
+
+	 
+	public void setGongsimingcheng(String gongsimingcheng) {
+		this.gongsimingcheng = gongsimingcheng;
+	}
+	
+	// 获取：公司名称
+
+	public String getGongsimingcheng() {
+		return gongsimingcheng;
+	}
+				
+	
+	//设置：公司地址
+
+	 
+	public void setGongsidizhi(String gongsidizhi) {
+		this.gongsidizhi = gongsidizhi;
+	}
+	
+	//获取：公司地址
+
+	public String getGongsidizhi() {
+		return gongsidizhi;
+	}
+				
+	
+	//设置：合作项目
+
+	 
+	public void setHezuoxiangmu(String hezuoxiangmu) {
+		this.hezuoxiangmu = hezuoxiangmu;
+	}
+	
+	//获取：合作项目
+
+	public String getHezuoxiangmu() {
+		return hezuoxiangmu;
+	}
+				
+	
+	// 设置：合作时长
+
+	 
+	public void setHezuoshizhang(String hezuoshizhang) {
+		this.hezuoshizhang = hezuoshizhang;
+	}
+	
+	//获取：合作时长
+
+	public String getHezuoshizhang() {
+		return hezuoshizhang;
+	}
+				
+	
+	// 设置：联系电话
+
+	 
+	public void setLianxidianhua(String lianxidianhua) {
+		this.lianxidianhua = lianxidianhua;
+	}
+	
+	//获取：联系电话
+
+	public String getLianxidianhua() {
+		return lianxidianhua;
+	}
+				
+	
+	//设置：备注
+
+	 
+	public void setBeizhu(String beizhu) {
+		this.beizhu = beizhu;
+	}
+	
+	// 获取：备注
+
+	public String getBeizhu() {
+		return beizhu;
+	}
+				
+	
+	//设置：登记日期
+
+	 
+	public void setDengjiriqi(Date dengjiriqi) {
+		this.dengjiriqi = dengjiriqi;
+	}
+	
+	// 获取：登记日期
+
+	public Date getDengjiriqi() {
+		return dengjiriqi;
+	}
+			
+}

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

@@ -0,0 +1,157 @@
+package com.entity.model;
+
+import com.entity.YuangongguanliEntity;
+
+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 YuangongguanliModel  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	// 密码
+
+	
+	private String mima;
+		
+	// 管理姓名
+
+	
+	private String guanlixingming;
+		
+	// 性别
+
+	
+	private String xingbie;
+		
+	// 职位
+
+	
+	private String zhiwei;
+		
+	//手机
+
+	
+	private String shouji;
+		
+	//邮箱
+
+	
+	private String youxiang;
+		
+	//身份证
+
+	
+	private String shenfenzheng;
+				
+	
+	//设置：密码
+
+	 
+	public void setMima(String mima) {
+		this.mima = mima;
+	}
+	
+	//获取：密码
+
+	public String getMima() {
+		return mima;
+	}
+				
+	
+	// 设置：管理姓名
+
+	 
+	public void setGuanlixingming(String guanlixingming) {
+		this.guanlixingming = guanlixingming;
+	}
+	
+	//获取：管理姓名
+
+	public String getGuanlixingming() {
+		return guanlixingming;
+	}
+				
+	
+	// 设置：性别
+
+	 
+	public void setXingbie(String xingbie) {
+		this.xingbie = xingbie;
+	}
+	
+	// 获取：性别
+
+	public String getXingbie() {
+		return xingbie;
+	}
+				
+	
+	// 设置：职位
+
+	 
+	public void setZhiwei(String zhiwei) {
+		this.zhiwei = zhiwei;
+	}
+	
+	// 获取：职位
+
+	public String getZhiwei() {
+		return zhiwei;
+	}
+				
+	
+	//设置：手机
+
+	 
+	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/ZhipiaoxinxiModel.java

@@ -0,0 +1,120 @@
+package com.entity.model;
+
+import com.entity.ZhipiaoxinxiEntity;
+
+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 ZhipiaoxinxiModel  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	// 收款单位
+
+	
+	private String shoukuandanwei;
+		
+	//金额
+
+	
+	private Integer jine;
+		
+	// 用途
+
+	private String yongtu;
+		
+	//备注
+
+	
+	private String beizhu;
+		
+	// 开票日期
+
+		
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 
+	private Date kaipiaoriqi;
+				
+	
+	// 设置：收款单位
+
+	 
+	public void setShoukuandanwei(String shoukuandanwei) {
+		this.shoukuandanwei = shoukuandanwei;
+	}
+	
+	// 获取：收款单位
+
+	public String getShoukuandanwei() {
+		return shoukuandanwei;
+	}
+				
+	
+	// 设置：金额
+
+	 
+	public void setJine(Integer jine) {
+		this.jine = jine;
+	}
+	
+	// 获取：金额
+
+	public Integer getJine() {
+		return jine;
+	}
+				
+	
+	// 设置：用途
+
+	 
+	public void setYongtu(String yongtu) {
+		this.yongtu = yongtu;
+	}
+	
+	// 获取：用途
+
+	public String getYongtu() {
+		return yongtu;
+	}
+				
+	
+	//设置：备注
+
+	 
+	public void setBeizhu(String beizhu) {
+		this.beizhu = beizhu;
+	}
+	
+	//获取：备注
+
+	public String getBeizhu() {
+		return beizhu;
+	}
+				
+	
+	// 设置：开票日期
+
+	 
+	public void setKaipiaoriqi(Date kaipiaoriqi) {
+		this.kaipiaoriqi = kaipiaoriqi;
+	}
+	
+	// 获取：开票日期
+
+	public Date getKaipiaoriqi() {
+		return kaipiaoriqi;
+	}
+			
+}

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

@@ -0,0 +1,42 @@
+package com.entity.view;
+
+import com.entity.BumenfenleiEntity;
+
+import com.baomidou.mybatisplus.annotations.TableName;
+import org.apache.commons.beanutils.BeanUtils;
+import java.lang.reflect.InvocationTargetException;
+
+import java.io.Serializable;
+
+//部门分类
+ // 后端返回视图实体辅助类
+// （通常后端关联的表或者自定义的字段需要返回使用）
+ // @author
+// @email
+// @date 2021-04-24 15:19:31
+
+@TableName("bumenfenlei")
+public class BumenfenleiView extends BumenfenleiEntity implements Serializable {
+	// 序列化版本号，用于保证序列化和反序列化过程中类的版本一致性
+	private static final long serialVersionUID = 1L;
+
+	// 无参构造函数，用于创建一个空的 BumenfenleiView 对象
+
+	public BumenfenleiView() {
+	}
+
+	// 有参构造函数，用于根据 BumenfenleiEntity 对象创建 BumenfenleiView 对象
+	 // @param bumenfenleiEntity 部门分类实体对象
+
+	public BumenfenleiView(BumenfenleiEntity bumenfenleiEntity) {
+		try {
+			// 使用 BeanUtils.copyProperties 方法将 bumenfenleiEntity 的属性复制到当前对象
+			// 这样可以方便地将 BumenfenleiEntity 对象的属性值传递给 BumenfenleiView 对象
+			BeanUtils.copyProperties(this, bumenfenleiEntity);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			// 当复制属性过程中出现非法访问异常或者调用目标方法异常时，打印异常堆栈信息
+			// 这里需要根据实际情况进行更完善的异常处理，例如记录日志等
+			e.printStackTrace();
+		}
+	}
+}

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

@@ -0,0 +1,48 @@
+package com.entity.view;
+
+// 引入发票信息实体类，该类可能包含发票信息的基本属性和方法
+import com.entity.FapiaoxinxiEntity;
+
+// 引入 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
+
+// 指定该视图实体类对应数据库中的 "fapiaoxinxi" 表
+@TableName("fapiaoxinxi")
+// 继承自 FapiaoxinxiEntity 类，同时实现 Serializable 接口，便于对象的序列化和反序列化
+public class FapiaoxinxiView extends FapiaoxinxiEntity implements Serializable {
+	// 序列化版本号，用于确保在反序列化时类的版本一致性
+	private static final long serialVersionUID = 1L;
+
+	//无参构造函数，用于创建一个空的 FapiaoxinxiView 对象
+
+	public FapiaoxinxiView() {
+	}
+
+	//有参构造函数，根据传入的 FapiaoxinxiEntity 对象创建 FapiaoxinxiView 对象
+	// @param fapiaoxinxiEntity 发票信息实体对象
+
+	public FapiaoxinxiView(FapiaoxinxiEntity fapiaoxinxiEntity) {
+		try {
+			// 使用 BeanUtils.copyProperties 方法将传入的 fapiaoxinxiEntity 对象的属性复制到当前对象
+			// 这样可以避免手动逐个复制属性，提高代码的可维护性
+			BeanUtils.copyProperties(this, fapiaoxinxiEntity);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			// 当复制属性过程中出现非法访问异常或者反射调用目标方法异常时，打印异常堆栈信息
+			// 这里只是简单打印，实际应用中可以考虑记录日志或者抛出自定义异常进行更完善的处理
+			e.printStackTrace();
+		}
+	}
+}

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

@@ -0,0 +1,44 @@
+package com.entity.view;
+
+// 导入供应商信息实体类，后续用于继承和属性复制操作
+import com.entity.GongyingshangxinxiEntity;
+
+// 导入 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
+
+// 使用注解指定该视图类对应的数据库表名为 "gongyingshangxinxi"
+@TableName("gongyingshangxinxi")
+// 该类继承自供应商信息实体类，并实现了可序列化接口
+public class GongyingshangxinxiView extends GongyingshangxinxiEntity implements Serializable {
+	// 定义序列化版本号，用于在反序列化时验证类的版本一致性
+	private static final long serialVersionUID = 1L;
+
+	// 无参构造函数，用于创建 GongyingshangxinxiView 类的实例
+	public GongyingshangxinxiView() {
+	}
+
+	// 有参构造函数，接受一个供应商信息实体类对象作为参数
+	public GongyingshangxinxiView(GongyingshangxinxiEntity gongyingshangxinxiEntity) {
+		try {
+			// 使用 BeanUtils 的 copyProperties 方法将传入的供应商信息实体类对象的属性复制到当前视图类对象中
+			BeanUtils.copyProperties(this, gongyingshangxinxiEntity);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			// 如果在属性复制过程中发生非法访问异常或调用目标方法异常，打印异常堆栈信息
+			// 在实际应用中，可能需要更完善的异常处理机制，如记录日志等
+			e.printStackTrace();
+		}
+	}
+}

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

@@ -0,0 +1,48 @@
+package com.entity.view;
+
+// 导入客户信息实体类，该类包含了客户信息的基本属性和方法
+import com.entity.KehuxinxiEntity;
+
+// 导入 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 注解指定该视图实体类对应的数据库表名为 "kehuxinxi"
+@TableName("kehuxinxi")
+// 继承自 KehuxinxiEntity 类，同时实现 Serializable 接口
+public class KehuxinxiView extends KehuxinxiEntity implements Serializable {
+	// 定义序列化版本号，用于在反序列化时验证类的版本一致性
+	private static final long serialVersionUID = 1L;
+
+	// 无参构造函数，用于创建一个空的 KehuxinxiView 对象
+
+	public KehuxinxiView() {
+	}
+
+	// 有参构造函数，根据传入的 KehuxinxiEntity 对象创建 KehuxinxiView 对象
+	// @param kehuxinxiEntity 客户信息实体对象
+
+	public KehuxinxiView(KehuxinxiEntity kehuxinxiEntity) {
+		try {
+			// 使用 BeanUtils.copyProperties 方法将传入的 kehuxinxiEntity 对象的属性复制到当前对象
+			// 这样可以方便地将实体类的属性值传递给视图类
+			BeanUtils.copyProperties(this, kehuxinxiEntity);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			// 当出现非法访问异常或反射调用目标方法异常时，打印异常堆栈信息
+			// 在实际应用中，可以考虑将异常信息记录到日志文件中，以便后续排查问题
+			e.printStackTrace();
+		}
+	}
+}

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

@@ -0,0 +1,48 @@
+package com.entity.view;
+
+// 导入员工管理实体类，该类可能包含员工管理相关的属性和方法
+import com.entity.YuangongguanliEntity;
+
+// 导入 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 注解指定该视图实体类对应的数据库表名为 "yuangongguanli"
+@TableName("yuangongguanli")
+// 继承自 YuangongguanliEntity 类，同时实现 Serializable 接口
+public class YuangongguanliView extends YuangongguanliEntity implements Serializable {
+	// 定义序列化版本号，用于在反序列化时验证类的版本一致性
+	private static final long serialVersionUID = 1L;
+
+	// 无参构造函数，用于创建一个空的 YuangongguanliView 对象
+
+	public YuangongguanliView() {
+	}
+
+	// 有参构造函数，根据传入的 YuangongguanliEntity 对象创建 YuangongguanliView 对象
+	//@param yuangongguanliEntity 员工管理实体对象
+
+	public YuangongguanliView(YuangongguanliEntity yuangongguanliEntity) {
+		try {
+			// 使用 BeanUtils.copyProperties 方法将传入的 yuangongguanliEntity 对象的属性复制到当前对象
+			// 这样可以避免手动逐个复制属性，提高代码的可维护性
+			BeanUtils.copyProperties(this, yuangongguanliEntity);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			// 当复制属性过程中出现非法访问异常（如访问私有属性）或反射调用目标方法异常（如方法不存在）时
+			// 打印异常堆栈信息，方便开发者定位问题。在实际项目中，建议将异常信息记录到日志文件中
+			e.printStackTrace();
+		}
+	}
+}

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

@@ -0,0 +1,48 @@
+package com.entity.view;
+
+// 导入支票信息实体类，该类封装了支票信息相关的属性和操作
+import com.entity.ZhipiaoxinxiEntity;
+
+// 导入 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 注解指定该视图实体类对应的数据库表名为 "zhipiaoxinxi"
+@TableName("zhipiaoxinxi")
+// 继承自 ZhipiaoxinxiEntity 类，同时实现 Serializable 接口
+public class ZhipiaoxinxiView extends ZhipiaoxinxiEntity implements Serializable {
+	// 定义序列化版本号，用于在反序列化时验证类的版本一致性
+	private static final long serialVersionUID = 1L;
+
+	// 无参构造函数，用于创建一个空的 ZhipiaoxinxiView 对象
+
+	public ZhipiaoxinxiView() {
+	}
+
+	//有参构造函数，根据传入的 ZhipiaoxinxiEntity 对象创建 ZhipiaoxinxiView 对象
+	// @param zhipiaoxinxiEntity 支票信息实体对象
+
+	public ZhipiaoxinxiView(ZhipiaoxinxiEntity zhipiaoxinxiEntity) {
+		try {
+			// 使用 BeanUtils.copyProperties 方法将传入的 zhipiaoxinxiEntity 对象的属性复制到当前对象
+			// 避免手动逐个复制属性，提高代码的可维护性
+			BeanUtils.copyProperties(this, zhipiaoxinxiEntity);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			// 当复制属性过程中出现非法访问异常（如访问私有属性）或反射调用目标方法异常（如方法不存在）时
+			// 打印异常堆栈信息，方便开发者定位问题。在实际项目中，可将异常信息记录到日志文件中
+			e.printStackTrace();
+		}
+	}
+}

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

@@ -0,0 +1,25 @@
+package com.entity.vo;
+
+import com.entity.BumenfenleiEntity;
+
+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 BumenfenleiVO  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 				
+}

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

@@ -0,0 +1,158 @@
+package com.entity.vo;
+
+import com.entity.FapiaoxinxiEntity;
+
+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 FapiaoxinxiVO  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	// 客户姓名
+
+	
+	private String kehuxingming;
+		
+	// 商品名称
+
+	
+	private String shangpinmingcheng;
+		
+	// 商品单价
+
+	private Integer shangpindanjia;
+		
+	// 商品数量
+
+	
+	private Integer shangpinshuliang;
+		
+	// 总金额
+
+	
+	private String zongjine;
+		
+	// 开票日期
+
+		
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 
+	private Date kaipiaoriqi;
+		
+	//备注
+
+	
+	private String beizhu;
+				
+	
+	// 设置：客户姓名
+
+	 
+	public void setKehuxingming(String kehuxingming) {
+		this.kehuxingming = kehuxingming;
+	}
+	
+	//获取：客户姓名
+
+	public String getKehuxingming() {
+		return kehuxingming;
+	}
+				
+	
+	// 设置：商品名称
+
+	 
+	public void setShangpinmingcheng(String shangpinmingcheng) {
+		this.shangpinmingcheng = shangpinmingcheng;
+	}
+	
+	// 获取：商品名称
+
+	public String getShangpinmingcheng() {
+		return shangpinmingcheng;
+	}
+				
+	
+	//设置：商品单价
+
+	 
+	public void setShangpindanjia(Integer shangpindanjia) {
+		this.shangpindanjia = shangpindanjia;
+	}
+	
+	//获取：商品单价
+
+	public Integer getShangpindanjia() {
+		return shangpindanjia;
+	}
+				
+	
+	// 设置：商品数量
+
+	 
+	public void setShangpinshuliang(Integer shangpinshuliang) {
+		this.shangpinshuliang = shangpinshuliang;
+	}
+	
+	// 获取：商品数量
+
+	public Integer getShangpinshuliang() {
+		return shangpinshuliang;
+	}
+				
+	
+	// 设置：总金额
+
+	 
+	public void setZongjine(String zongjine) {
+		this.zongjine = zongjine;
+	}
+	
+	//获取：总金额
+
+	public String getZongjine() {
+		return zongjine;
+	}
+				
+	
+	//设置：开票日期
+
+	 
+	public void setKaipiaoriqi(Date kaipiaoriqi) {
+		this.kaipiaoriqi = kaipiaoriqi;
+	}
+	
+	// 获取：开票日期
+
+	public Date getKaipiaoriqi() {
+		return kaipiaoriqi;
+	}
+				
+	
+	//设置：备注
+
+	 
+	public void setBeizhu(String beizhu) {
+		this.beizhu = beizhu;
+	}
+	
+	//获取：备注
+
+	public String getBeizhu() {
+		return beizhu;
+	}
+			
+}

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

@@ -0,0 +1,158 @@
+package com.entity.vo;
+
+import com.entity.GongyingshangxinxiEntity;
+
+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;
+ 
+
+//供应商信息
+// 手机端接口返回实体辅助类
+ //（主要作用去除一些不必要的字段）
+// @email
+ // @date 2021-04-24 15:19:31
+
+public class GongyingshangxinxiVO  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	// 公司名称
+
+	
+	private String gongsimingcheng;
+		
+	//公司地址
+
+	
+	private String gongsidizhi;
+		
+	//供应产品
+
+	
+	private String gongyingchanpin;
+		
+	//联系电话
+
+	
+	private String lianxidianhua;
+		
+	//合作时长
+
+	
+	private String hezuoshizhang;
+		
+	//备注
+
+	
+	private String beizhu;
+		
+	// 登记日期
+
+		
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 
+	private Date dengjiriqi;
+				
+	
+	// 设置：公司名称
+
+	 
+	public void setGongsimingcheng(String gongsimingcheng) {
+		this.gongsimingcheng = gongsimingcheng;
+	}
+	
+	// 获取：公司名称
+
+	public String getGongsimingcheng() {
+		return gongsimingcheng;
+	}
+				
+	
+	// 设置：公司地址
+
+	 
+	public void setGongsidizhi(String gongsidizhi) {
+		this.gongsidizhi = gongsidizhi;
+	}
+	
+	//获取：公司地址
+
+	public String getGongsidizhi() {
+		return gongsidizhi;
+	}
+				
+	
+	//设置：供应产品
+
+	 
+	public void setGongyingchanpin(String gongyingchanpin) {
+		this.gongyingchanpin = gongyingchanpin;
+	}
+	
+	// 获取：供应产品
+
+	public String getGongyingchanpin() {
+		return gongyingchanpin;
+	}
+				
+	
+	//设置：联系电话
+
+	 
+	public void setLianxidianhua(String lianxidianhua) {
+		this.lianxidianhua = lianxidianhua;
+	}
+	
+	//获取：联系电话
+
+	public String getLianxidianhua() {
+		return lianxidianhua;
+	}
+				
+	
+	// 设置：合作时长
+
+	 
+	public void setHezuoshizhang(String hezuoshizhang) {
+		this.hezuoshizhang = hezuoshizhang;
+	}
+	
+	//获取：合作时长
+
+	public String getHezuoshizhang() {
+		return hezuoshizhang;
+	}
+				
+	
+	//设置：备注
+
+	 
+	public void setBeizhu(String beizhu) {
+		this.beizhu = beizhu;
+	}
+	
+	//获取：备注
+
+	public String getBeizhu() {
+		return beizhu;
+	}
+				
+	
+	// 设置：登记日期
+
+	 
+	public void setDengjiriqi(Date dengjiriqi) {
+		this.dengjiriqi = dengjiriqi;
+	}
+	
+	// 获取：登记日期
+
+	public Date getDengjiriqi() {
+		return dengjiriqi;
+	}
+			
+}

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

@@ -0,0 +1,158 @@
+package com.entity.vo;
+
+import com.entity.KehuxinxiEntity;
+
+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 KehuxinxiVO  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	// 公司名称
+
+	private String gongsimingcheng;
+		
+	//公司地址
+
+	
+	private String gongsidizhi;
+		
+	// 合作项目
+
+	
+	private String hezuoxiangmu;
+		
+	//合作时长
+
+	
+	private String hezuoshizhang;
+		
+	// 联系电话
+
+	
+	private String lianxidianhua;
+		
+	// 备注
+
+	
+	private String beizhu;
+		
+	// 登记日期
+
+		
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 
+	private Date dengjiriqi;
+				
+	
+	// 设置：公司名称
+
+	 
+	public void setGongsimingcheng(String gongsimingcheng) {
+		this.gongsimingcheng = gongsimingcheng;
+	}
+	
+	// 获取：公司名称
+
+	public String getGongsimingcheng() {
+		return gongsimingcheng;
+	}
+				
+	
+	// 设置：公司地址
+
+	 
+	public void setGongsidizhi(String gongsidizhi) {
+		this.gongsidizhi = gongsidizhi;
+	}
+	
+	//获取：公司地址
+
+	public String getGongsidizhi() {
+		return gongsidizhi;
+	}
+				
+	
+	//设置：合作项目
+
+	 
+	public void setHezuoxiangmu(String hezuoxiangmu) {
+		this.hezuoxiangmu = hezuoxiangmu;
+	}
+	
+	//获取：合作项目
+
+	public String getHezuoxiangmu() {
+		return hezuoxiangmu;
+	}
+				
+	
+	//设置：合作时长
+
+	 
+	public void setHezuoshizhang(String hezuoshizhang) {
+		this.hezuoshizhang = hezuoshizhang;
+	}
+	
+	// 获取：合作时长
+
+	public String getHezuoshizhang() {
+		return hezuoshizhang;
+	}
+				
+	
+	// 设置：联系电话
+
+	 
+	public void setLianxidianhua(String lianxidianhua) {
+		this.lianxidianhua = lianxidianhua;
+	}
+	
+	//获取：联系电话
+
+	public String getLianxidianhua() {
+		return lianxidianhua;
+	}
+				
+	
+	//设置：备注
+
+	 
+	public void setBeizhu(String beizhu) {
+		this.beizhu = beizhu;
+	}
+	
+	// 获取：备注
+
+	public String getBeizhu() {
+		return beizhu;
+	}
+				
+	
+	// 设置：登记日期
+
+	 
+	public void setDengjiriqi(Date dengjiriqi) {
+		this.dengjiriqi = dengjiriqi;
+	}
+	
+	// 获取：登记日期
+
+	public Date getDengjiriqi() {
+		return dengjiriqi;
+	}
+			
+}

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

@@ -0,0 +1,157 @@
+package com.entity.vo;
+
+import com.entity.YuangongguanliEntity;
+
+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 YuangongguanliVO  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	// 密码
+
+	
+	private String mima;
+		
+	// 管理姓名
+
+	
+	private String guanlixingming;
+		
+	// 性别
+
+	
+	private String xingbie;
+		
+	// 职位
+
+	
+	private String zhiwei;
+		
+	// 手机
+
+	
+	private String shouji;
+		
+	// 邮箱
+
+	
+	private String youxiang;
+		
+	//身份证
+
+	
+	private String shenfenzheng;
+				
+	
+	// 设置：密码
+
+	 
+	public void setMima(String mima) {
+		this.mima = mima;
+	}
+	
+	// 获取：密码
+
+	public String getMima() {
+		return mima;
+	}
+				
+	
+	// 设置：管理姓名
+
+	 
+	public void setGuanlixingming(String guanlixingming) {
+		this.guanlixingming = guanlixingming;
+	}
+	
+	// 获取：管理姓名
+
+	public String getGuanlixingming() {
+		return guanlixingming;
+	}
+				
+	
+	// 设置：性别
+
+	 
+	public void setXingbie(String xingbie) {
+		this.xingbie = xingbie;
+	}
+	
+	// 获取：性别
+
+	public String getXingbie() {
+		return xingbie;
+	}
+				
+	
+	// 设置：职位
+
+	 
+	public void setZhiwei(String zhiwei) {
+		this.zhiwei = zhiwei;
+	}
+	
+	// 获取：职位
+
+	public String getZhiwei() {
+		return zhiwei;
+	}
+				
+	
+	// 设置：手机
+
+	 
+	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/ZhipiaoxinxiVO.java

@@ -0,0 +1,120 @@
+package com.entity.vo;
+
+import com.entity.ZhipiaoxinxiEntity;
+
+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 ZhipiaoxinxiVO  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	// 收款单位
+
+	
+	private String shoukuandanwei;
+		
+	// 金额
+
+	
+	private Integer jine;
+		
+	// 用途
+
+	
+	private String yongtu;
+		
+	// 备注
+
+	
+	private String beizhu;
+		
+	// 开票日期
+
+		
+	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	@DateTimeFormat 
+	private Date kaipiaoriqi;
+				
+	
+	// 设置：收款单位
+
+	 
+	public void setShoukuandanwei(String shoukuandanwei) {
+		this.shoukuandanwei = shoukuandanwei;
+	}
+	
+	// 获取：收款单位
+
+	public String getShoukuandanwei() {
+		return shoukuandanwei;
+	}
+				
+	
+	// 设置：金额
+
+	 
+	public void setJine(Integer jine) {
+		this.jine = jine;
+	}
+	
+	// 获取：金额
+
+	public Integer getJine() {
+		return jine;
+	}
+				
+	
+	// 设置：用途
+
+	 
+	public void setYongtu(String yongtu) {
+		this.yongtu = yongtu;
+	}
+	
+	// 获取：用途
+
+	public String getYongtu() {
+		return yongtu;
+	}
+				
+	
+	// 设置：备注
+
+	 
+	public void setBeizhu(String beizhu) {
+		this.beizhu = beizhu;
+	}
+	
+	// 获取：备注
+
+	public String getBeizhu() {
+		return beizhu;
+	}
+				
+	
+	// 设置：开票日期
+
+	 
+	public void setKaipiaoriqi(Date kaipiaoriqi) {
+		this.kaipiaoriqi = kaipiaoriqi;
+	}
+	
+	// 获取：开票日期
+
+	public Date getKaipiaoriqi() {
+		return kaipiaoriqi;
+	}
+			
+}

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

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

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

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

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

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

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

@@ -0,0 +1,97 @@
+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.BumenfenleiDao;
+import com.entity.BumenfenleiEntity;
+import com.service.BumenfenleiService;
+import com.entity.vo.BumenfenleiVO;
+import com.entity.view.BumenfenleiView;
+
+//此服务类用于实现部门分类的业务逻辑，是 BumenfenleiService 接口的具体实现。
+ // 它继承自 MyBatis-Plus 的 ServiceImpl 类，借助 MyBatis-Plus 简化数据库操作。
+
+@Service("bumenfenleiService")
+public class BumenfenleiServiceImpl extends ServiceImpl<BumenfenleiDao, BumenfenleiEntity> implements BumenfenleiService {
+
+	//根据传入的参数查询部门分类实体的分页数据。
+	// @param params 包含查询参数与分页信息的 Map，用于指定查询条件和分页要求。
+	 // @return 封装了分页数据的 PageUtils 对象，便于后续处理和展示。
+
+	@Override
+	public PageUtils queryPage(Map<String, Object> params) {
+		// 依据传入的参数构建分页对象，该对象将用于指定分页查询的具体要求。
+		Page<BumenfenleiEntity> page = this.selectPage(
+				new Query<BumenfenleiEntity>(params).getPage(),
+				// 创建一个空的查询条件包装器，这里不设置额外的查询条件。
+				new EntityWrapper<BumenfenleiEntity>()
+		);
+		// 将分页查询结果封装到 PageUtils 对象中并返回。
+		return new PageUtils(page);
+	}
+
+	// 根据传入的参数和查询条件包装器，查询部门分类视图的分页数据。
+	 //@param params  包含查询参数与分页信息的 Map，用于指定查询条件和分页要求。
+	 // @param wrapper 查询条件包装器，用于构建复杂的查询条件。
+	// @return 封装了分页数据的 PageUtils 对象，便于后续处理和展示。
+
+	@Override
+	public PageUtils queryPage(Map<String, Object> params, Wrapper<BumenfenleiEntity> wrapper) {
+		// 根据传入的参数创建部门分类视图的分页对象。
+		Page<BumenfenleiView> page = new Query<BumenfenleiView>(params).getPage();
+		// 调用基础映射器的方法，根据分页对象和查询条件包装器查询视图列表，并将结果设置到分页对象中。
+		page.setRecords(baseMapper.selectListView(page, wrapper));
+		// 将分页查询结果封装到 PageUtils 对象中并返回。
+		PageUtils pageUtil = new PageUtils(page);
+		return pageUtil;
+	}
+
+	// 根据查询条件包装器查询部门分类值对象（VO）列表。
+	 // @param wrapper 查询条件包装器，用于构建复杂的查询条件。
+	 // @return 符合查询条件的部门分类值对象（VO）列表。
+
+	@Override
+	public List<BumenfenleiVO> selectListVO(Wrapper<BumenfenleiEntity> wrapper) {
+		// 调用基础映射器的方法，根据查询条件包装器查询部门分类值对象（VO）列表并返回。
+		return baseMapper.selectListVO(wrapper);
+	}
+
+	// 根据查询条件包装器查询单个部门分类值对象（VO）。
+	 // @param wrapper 查询条件包装器，用于构建复杂的查询条件。
+	// @return 符合查询条件的单个部门分类值对象（VO），若未找到则可能返回 null。
+
+	@Override
+	public BumenfenleiVO selectVO(Wrapper<BumenfenleiEntity> wrapper) {
+		// 调用基础映射器的方法，根据查询条件包装器查询单个部门分类值对象（VO）并返回。
+		return baseMapper.selectVO(wrapper);
+	}
+
+	// 根据查询条件包装器查询部门分类视图列表。
+	 // @param wrapper 查询条件包装器，用于构建复杂的查询条件。
+	 // @return 符合查询条件的部门分类视图列表。
+
+	@Override
+	public List<BumenfenleiView> selectListView(Wrapper<BumenfenleiEntity> wrapper) {
+		// 调用基础映射器的方法，根据查询条件包装器查询部门分类视图列表并返回。
+		return baseMapper.selectListView(wrapper);
+	}
+
+	// 根据查询条件包装器查询单个部门分类视图。
+	 // @param wrapper 查询条件包装器，用于构建复杂的查询条件。
+	// @return 符合查询条件的单个部门分类视图，若未找到则可能返回 null。
+
+	@Override
+	public BumenfenleiView selectView(Wrapper<BumenfenleiEntity> wrapper) {
+		// 调用基础映射器的方法，根据查询条件包装器查询单个部门分类视图并返回。
+		return baseMapper.selectView(wrapper);
+	}
+}

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

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

src/main/java/com/service/impl/GongyingshangxinxiServiceImpl.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.GongyingshangxinxiDao;
+import com.entity.GongyingshangxinxiEntity;
+import com.service.GongyingshangxinxiService;
+import com.entity.vo.GongyingshangxinxiVO;
+import com.entity.view.GongyingshangxinxiView;
+
+//供应商信息服务的实现类，实现了 GongyingshangxinxiService 接口，
+// 继承自 MyBatis-Plus 的 ServiceImpl 类，借助 MyBatis-Plus 提供的通用 CRUD 方法操作数据库。
+// 主要负责处理供应商信息的分页查询、条件查询等业务逻辑。
+
+@Service("gongyingshangxinxiService")
+public class GongyingshangxinxiServiceImpl extends ServiceImpl<GongyingshangxinxiDao, GongyingshangxinxiEntity> implements GongyingshangxinxiService {
+
+	// 根据传入的参数进行分页查询供应商信息实体数据。
+	 //@param params 包含分页和查询条件的参数 Map，常见参数如页码、每页数量等。
+	 // @return 封装了分页信息和查询结果的 PageUtils 对象，方便前端展示和处理分页数据。
+
+	@Override
+	public PageUtils queryPage(Map<String, Object> params) {
+		// 根据传入的参数创建分页对象，用于指定分页查询的要求，如页码、每页数量等。
+		Page<GongyingshangxinxiEntity> page = this.selectPage(
+				// 调用 Query 工具类的方法，根据传入的参数生成对应的分页对象。
+				new Query<GongyingshangxinxiEntity>(params).getPage(),
+				// 创建一个空的实体包装器，不设置具体的查询条件，表示查询所有数据。
+				new EntityWrapper<GongyingshangxinxiEntity>()
+		);
+		// 将分页查询得到的结果封装到 PageUtils 对象中并返回。
+		return new PageUtils(page);
+	}
+
+	//根据传入的参数和查询条件包装器进行分页查询供应商信息视图数据。
+	// @param params  包含分页和查询条件的参数 Map。
+	 // @param wrapper 用于构建查询条件的包装器，可设置如 where 子句等条件。
+	 // @return 封装了分页信息和查询结果的 PageUtils 对象。
+
+	@Override
+	public PageUtils queryPage(Map<String, Object> params, Wrapper<GongyingshangxinxiEntity> wrapper) {
+		// 根据传入的参数创建供应商信息视图的分页对象。
+		Page<GongyingshangxinxiView> page = new Query<GongyingshangxinxiView>(params).getPage();
+		// 调用基础映射器的方法，根据分页对象和查询条件包装器查询视图列表，并将结果设置到分页对象中。
+		page.setRecords(baseMapper.selectListView(page, wrapper));
+		// 将分页查询得到的结果封装到 PageUtils 对象中并返回。
+		PageUtils pageUtil = new PageUtils(page);
+		return pageUtil;
+	}
+
+	//根据查询条件包装器查询供应商信息值对象（VO）列表。
+	 // @param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的供应商信息值对象（VO）列表。
+
+	@Override
+	public List<GongyingshangxinxiVO> selectListVO(Wrapper<GongyingshangxinxiEntity> wrapper) {
+		// 调用基础映射器的方法，根据查询条件包装器查询供应商信息值对象（VO）列表并返回。
+		return baseMapper.selectListVO(wrapper);
+	}
+
+	// 根据查询条件包装器查询单个供应商信息值对象（VO）。
+	//@param wrapper 用于构建查询条件的包装器。
+	//@return 符合查询条件的单个供应商信息值对象（VO），若未找到则可能返回 null。
+
+	@Override
+	public GongyingshangxinxiVO selectVO(Wrapper<GongyingshangxinxiEntity> wrapper) {
+		// 调用基础映射器的方法，根据查询条件包装器查询单个供应商信息值对象（VO）并返回。
+		return baseMapper.selectVO(wrapper);
+	}
+
+	// 根据查询条件包装器查询供应商信息视图列表。
+	 //@param wrapper 用于构建查询条件的包装器。
+	 // @return 符合查询条件的供应商信息视图列表。
+
+	@Override
+	public List<GongyingshangxinxiView> selectListView(Wrapper<GongyingshangxinxiEntity> wrapper) {
+		// 调用基础映射器的方法，根据查询条件包装器查询供应商信息视图列表并返回。
+		return baseMapper.selectListView(wrapper);
+	}
+
+	// 根据查询条件包装器查询单个供应商信息视图。
+	// @param wrapper 用于构建查询条件的包装器。
+	// @return 符合查询条件的单个供应商信息视图，若未找到则可能返回 null。
+
+	@Override
+	public GongyingshangxinxiView selectView(Wrapper<GongyingshangxinxiEntity> wrapper) {
+		// 调用基础映射器的方法，根据查询条件包装器查询单个供应商信息视图并返回。
+		return baseMapper.selectView(wrapper);
+	}
+}

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

src/main/java/com/service/impl/YuangongguanliServiceImpl.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.YuangongguanliDao;
+import com.entity.YuangongguanliEntity;
+import com.service.YuangongguanliService;
+import com.entity.vo.YuangongguanliVO;
+import com.entity.view.YuangongguanliView;
+
+// 员工管理服务的实现类，实现了 YuangongguanliService 接口，
+ // 继承自 MyBatis-Plus 的 ServiceImpl 类，用于处理员工管理相关的业务逻辑。
+ // 通过依赖注入的方式使用 YuangongguanliDao 来访问和操作数据库中的员工管理数据。
+
+@Service("yuangongguanliService")
+public class YuangongguanliServiceImpl extends ServiceImpl<YuangongguanliDao, YuangongguanliEntity> implements YuangongguanliService {
+
+	//根据传入的参数进行分页查询员工管理实体数据。
+	 // @param params 包含分页和查询条件的参数 Map，例如：页码、每页数量、员工姓名、部门等。
+	 //@return 封装了分页信息（如总页数、当前页数、每页记录数、总记录数等）和查询结果（员工管理实体列表）的 PageUtils 对象，
+	//       方便在业务层或展示层进行处理和展示分页数据。
+
+	@Override
+	public PageUtils queryPage(Map<String, Object> params) {
+		// 根据传入的参数创建一个分页对象，用于指定分页查询的相关设置，如页码和每页数量等。
+		Page<YuangongguanliEntity> page = this.selectPage(
+				// 调用 Query 工具类的方法，根据传入的参数生成对应的分页对象。
+				new Query<YuangongguanliEntity>(params).getPage(),
+				// 创建一个空的实体包装器，这里不设置具体的查询条件，即查询所有的员工管理实体。
+				new EntityWrapper<YuangongguanliEntity>()
+		);
+		// 将分页查询得到的结果封装到 PageUtils 对象中并返回，以便后续使用。
+		return new PageUtils(page);
+	}
+
+	//根据传入的参数和查询条件包装器进行分页查询员工管理视图数据。
+	 // @param params  包含分页和查询条件的参数 Map，与上面的 queryPage 方法中的 params 类似，
+	 //               可用于指定分页和一些通用的查询条件。
+	 // @param wrapper 用于构建具体查询条件的包装器，例如可以设置 where 子句等条件来筛选特定的员工管理数据。
+	 //@return 封装了分页信息和查询结果（员工管理视图列表）的 PageUtils 对象。
+
+	@Override
+	public PageUtils queryPage(Map<String, Object> params, Wrapper<YuangongguanliEntity> wrapper) {
+		// 根据传入的参数创建员工管理视图的分页对象。
+		Page<YuangongguanliView> page = new Query<YuangongguanliView>(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<YuangongguanliVO> selectListVO(Wrapper<YuangongguanliEntity> wrapper) {
+		// 调用基础映射器的方法，根据查询条件包装器查询员工管理值对象（VO）列表并返回。
+		return baseMapper.selectListVO(wrapper);
+	}
+
+	// 根据查询条件包装器查询单个员工管理值对象（VO）。
+	 // @param wrapper 用于构建查询条件的包装器，通过设置精确的条件筛选出唯一的员工管理数据，
+	 //               并以值对象（VO）的形式返回。
+	 // @return 符合查询条件的单个员工管理值对象（VO），如果没有找到符合条件的数据，则可能返回 null。
+
+	@Override
+	public YuangongguanliVO selectVO(Wrapper<YuangongguanliEntity> wrapper) {
+		// 调用基础映射器的方法，根据查询条件包装器查询单个员工管理值对象（VO）并返回。
+		return baseMapper.selectVO(wrapper);
+	}
+
+	//根据查询条件包装器查询员工管理视图的列表。
+	 // @param wrapper 用于构建查询条件的包装器，通过设置条件筛选出符合要求的员工管理视图数据。
+	 //@return 符合查询条件的员工管理视图列表，用于在业务层进行数据展示或进一步处理。
+
+	@Override
+	public List<YuangongguanliView> selectListView(Wrapper<YuangongguanliEntity> wrapper) {
+		// 调用基础映射器的方法，根据查询条件包装器查询员工管理视图列表并返回。
+		return baseMapper.selectListView(wrapper);
+	}
+
+	// 根据查询条件包装器查询单个员工管理视图。
+	 // @param wrapper 用于构建查询条件的包装器，通过设置精确的条件筛选出唯一的员工管理视图数据。
+	 // @return 符合查询条件的单个员工管理视图，如果没有找到符合条件的数据，则可能返回 null。
+
+	@Override
+	public YuangongguanliView selectView(Wrapper<YuangongguanliEntity> wrapper) {
+		// 调用基础映射器的方法，根据查询条件包装器查询单个员工管理视图并返回。
+		return baseMapper.selectView(wrapper);
+	}
+}

src/main/java/com/service/impl/ZhipiaoxinxiServiceImpl.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.ZhipiaoxinxiDao;
+import com.entity.ZhipiaoxinxiEntity;
+import com.service.ZhipiaoxinxiService;
+import com.entity.vo.ZhipiaoxinxiVO;
+import com.entity.view.ZhipiaoxinxiView;
+
+//支票信息服务的实现类，实现了 ZhipiaoxinxiService 接口，
+ //继承自 MyBatis-Plus 的 ServiceImpl 类，用于处理支票信息相关的业务逻辑。
+ //通过依赖注入的方式使用 ZhipiaoxinxiDao 来访问和操作数据库中的支票信息数据。
+
+@Service("zhipiaoxinxiService")
+public class ZhipiaoxinxiServiceImpl extends ServiceImpl<ZhipiaoxinxiDao, ZhipiaoxinxiEntity> implements ZhipiaoxinxiService {
+
+	//根据传入的参数进行分页查询支票信息实体数据。
+	 //@param params 包含分页和查询条件的参数 Map，例如：页码、每页数量、支票编号、开票日期等。
+	 // @return 封装了分页信息（如总页数、当前页数、每页记录数、总记录数等）和查询结果（支票信息实体列表）的 PageUtils 对象，
+	 //        方便在业务层或展示层进行处理和展示分页数据。
+
+	@Override
+	public PageUtils queryPage(Map<String, Object> params) {
+		// 根据传入的参数创建一个分页对象，用于指定分页查询的相关设置，如页码和每页数量等。
+		Page<ZhipiaoxinxiEntity> page = this.selectPage(
+				// 调用 Query 工具类的方法，根据传入的参数生成对应的分页对象。
+				new Query<ZhipiaoxinxiEntity>(params).getPage(),
+				// 创建一个空的实体包装器，这里不设置具体的查询条件，即查询所有的支票信息实体。
+				new EntityWrapper<ZhipiaoxinxiEntity>()
+		);
+		// 将分页查询得到的结果封装到 PageUtils 对象中并返回，以便后续使用。
+		return new PageUtils(page);
+	}
+
+	//根据传入的参数和查询条件包装器进行分页查询支票信息视图数据。
+	 //@param params  包含分页和查询条件的参数 Map，与上面的 queryPage 方法中的 params 类似，
+	 //               可用于指定分页和一些通用的查询条件。
+	 // @param wrapper 用于构建具体查询条件的包装器，例如可以设置 where 子句等条件来筛选特定的支票信息数据。
+	 //@return 封装了分页信息和查询结果（支票信息视图列表）的 PageUtils 对象。
+
+	@Override
+	public PageUtils queryPage(Map<String, Object> params, Wrapper<ZhipiaoxinxiEntity> wrapper) {
+		// 根据传入的参数创建支票信息视图的分页对象。
+		Page<ZhipiaoxinxiView> page = new Query<ZhipiaoxinxiView>(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<ZhipiaoxinxiVO> selectListVO(Wrapper<ZhipiaoxinxiEntity> wrapper) {
+		// 调用基础映射器的方法，根据查询条件包装器查询支票信息值对象（VO）列表并返回。
+		return baseMapper.selectListVO(wrapper);
+	}
+
+	// 根据查询条件包装器查询单个支票信息值对象（VO）。
+	 // @param wrapper 用于构建查询条件的包装器，通过设置精确的条件筛选出唯一的支票信息数据，
+	 //               并以值对象（VO）的形式返回。
+	 // @return 符合查询条件的单个支票信息值对象（VO），如果没有找到符合条件的数据，则可能返回 null。
+
+	@Override
+	public ZhipiaoxinxiVO selectVO(Wrapper<ZhipiaoxinxiEntity> wrapper) {
+		// 调用基础映射器的方法，根据查询条件包装器查询单个支票信息值对象（VO）并返回。
+		return baseMapper.selectVO(wrapper);
+	}
+
+	// 根据查询条件包装器查询支票信息视图的列表。
+	//@param wrapper 用于构建查询条件的包装器，通过设置条件筛选出符合要求的支票信息视图数据。
+	 //@return 符合查询条件的支票信息视图列表，用于在业务层进行数据展示或进一步处理。
+
+	@Override
+	public List<ZhipiaoxinxiView> selectListView(Wrapper<ZhipiaoxinxiEntity> wrapper) {
+		// 调用基础映射器的方法，根据查询条件包装器查询支票信息视图列表并返回。
+		return baseMapper.selectListView(wrapper);
+	}
+
+	// 根据查询条件包装器查询单个支票信息视图。
+	 // @param wrapper 用于构建查询条件的包装器，通过设置精确的条件筛选出唯一的支票信息视图数据。
+	 // @return 符合查询条件的单个支票信息视图，如果没有找到符合条件的数据，则可能返回 null。
+
+	@Override
+	public ZhipiaoxinxiView selectView(Wrapper<ZhipiaoxinxiEntity> wrapper) {
+		// 调用基础映射器的方法，根据查询条件包装器查询单个支票信息视图并返回。
+		return baseMapper.selectView(wrapper);
+	}
+}