第一次提交

ChatController.java

@@ -0,0 +1,351 @@
+package com.controller;
+
+import java.math.BigDecimal;
+import java.text.SimpleDateFormat;
+import java.text.ParseException;
+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 java.io.IOException;
+
+import com.utils.ValidatorUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Transactional;
+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.ChatEntity;
+import com.entity.view.ChatView;
+
+import com.service.ChatService;
+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 2023-02-21 09:46:06
+ */
+@RestController
+@RequestMapping("/chat")
+public class ChatController {
+
+    // 自动注入ChatService实例，用于处理与聊天相关的业务逻辑
+    @Autowired
+    private ChatService chatService;
+
+    /**
+     * 后端列表
+     * 用于获取聊天记录列表，根据不同用户角色（管理员或普通用户）进行数据筛选
+     * @param params 包含查询参数的Map，例如分页参数、筛选条件等
+     * @param chat ChatEntity对象，可能包含一些额外的查询条件
+     * @param request HttpServletRequest对象，用于获取当前会话信息
+     * @return R类型的结果，包含查询到的聊天记录列表数据及相关状态信息
+     */
+    @RequestMapping("/page")
+    public R page(@RequestParam Map<String, Object> params, ChatEntity chat,
+            HttpServletRequest request) {
+        // 如果当前用户不是管理员角色，设置查询条件，只查询当前用户的聊天记录
+        if (!request.getSession().getAttribute("role").toString().equals("管理员")) {
+            
+            chat.setUserid((Long) request.getSession().getAttribute("userId"));
+        }
+
+        // 创建一个EntityWrapper对象，用于构建MyBatis Plus的查询条件
+        EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>();
+
+        // 调用chatService的queryPage方法进行分页查询，传入构建好的查询条件和参数
+        PageUtils page = chatService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, chat), params), params));
+        // 将查询结果设置到请求属性中，可能用于在后续的视图渲染中使用
+        request.setAttribute("data", page);
+        // 返回包含查询结果的R对象，通常R对象用于统一封装返回结果的状态和数据
+        return R.ok().put("data", page);
+    }
+
+    /**
+     * 前端列表
+     * 功能与后端列表类似，但可能在前端展示时有不同的处理或用途
+     * @param params 包含查询参数的Map，例如分页参数、筛选条件等
+     * @param chat ChatEntity对象，可能包含一些额外的查询条件
+     * @param request HttpServletRequest对象，用于获取当前会话信息
+     * @return R类型的结果，包含查询到的聊天记录列表数据及相关状态信息
+     */
+    @RequestMapping("/list")
+    public R list(@RequestParam Map<String, Object> params, ChatEntity chat,
+            HttpServletRequest request) {
+        // 如果当前用户不是管理员角色,设置查询条件，只查询当前用户的聊天记录
+        if (!request.getSession().getAttribute("role").toString().equals("管理员")) {
+            
+            chat.setUserid((Long) request.getSession().getAttribute("userId"));
+        }
+
+        // 创建一个EntityWrapper对象，用于构建MyBatis Plus的查询条件
+        EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>();
+
+        // 调用chatService的queryPage方法进行分页查询，传入构建好的查询条件和参数
+        PageUtils page = chatService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, chat), params), params));
+        // 将查询结果设置到请求属性中，可能用于在后续的视图渲染中使用
+        request.setAttribute("data", page);
+        // 返回包含查询结果的R对象，通常R对象用于统一封装返回结果的状态和数据
+        return R.ok().put("data", page);
+    }
+
+    /**
+     * 列表
+     * 用于获取聊天记录列表，根据传入的ChatEntity对象构建查询条件
+     * @param chat ChatEntity对象，包含查询条件信息
+     * @return R类型的结果，包含查询到的聊天记录列表数据及相关状态信息
+     */
+    @RequestMapping("/lists")
+    public R list(ChatEntity chat) {
+        // 创建一个EntityWrapper对象，用于构建MyBatis Plus的查询条件
+        EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>();
+        // 根据传入的ChatEntity对象构建等值查询条件
+        ew.allEq(MPUtil.allEQMapPre(chat, "chat"));
+        // 调用chatService的selectListView方法进行查询，并返回结果
+        return R.ok().put("data", chatService.selectListView(ew));
+    }
+
+    /**
+     * 查询
+     * 用于查询特定条件的在线咨询记录，并返回详细信息视图
+     * @param chat ChatEntity对象，包含查询条件信息
+     * @return R类型的结果，包含查询到的在线咨询详细信息视图及相关状态信息
+     */
+    @RequestMapping("/query")
+    public R query(ChatEntity chat) {
+        // 创建一个EntityWrapper对象，用于构建MyBatis Plus的查询条件
+        EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>();
+        // 根据传入的ChatEntity对象构建等值查询条件
+        ew.allEq(MPUtil.allEQMapPre(chat, "chat"));
+        // 调用chatService的selectView方法进行查询，获取ChatView对象（可能是包含详细信息的视图对象）
+        ChatView chatView = chatService.selectView(ew);
+        // 返回包含查询结果的R对象，以及提示信息和查询到的详细信息视图
+        return R.ok("查询在线咨询成功").put("data", chatView);
+    }
+
+    /**
+     * 后端详情
+     * 用于获取指定ID的聊天记录详细信息
+     * @param id 聊天记录的ID
+     * @return R类型的结果，包含查询到的聊天记录详细信息及相关状态信息
+     */
+    @RequestMapping("/info/{id}")
+    public R info(@PathVariable("id") Long id) {
+        // 调用chatService的selectById方法，根据ID查询聊天记录
+        ChatEntity chat = chatService.selectById(id);
+        // 返回包含查询结果的R对象
+        return R.ok().put("data", chat);
+    }
+
+    /**
+     * 前端详情
+     * 功能与后端详情类似，但可能在前端展示时有不同的处理或用途，且此方法标注了@IgnoreAuth，表示忽略权限验证
+     * @param id 聊天记录的ID
+     * @return R类型的结果，包含查询到的聊天记录详细信息及相关状态信息
+     */
+    @IgnoreAuth
+    @RequestMapping("/detail/{id}")
+    public R detail(@PathVariable("id") Long id) {
+        // 调用chatService的selectById方法，根据ID查询聊天记录
+        ChatEntity chat = chatService.selectById(id);
+        // 返回包含查询结果的R对象
+        return R.ok().put("data", chat);
+    }
+
+    /**
+     * 后端保存
+     * 用于保存新的聊天记录，包括设置一些默认值和根据聊天内容更新相关状态
+     * @param chat 包含聊天记录信息的ChatEntity对象
+     * @param request HttpServletRequest对象，用于获取当前会话信息
+     * @return R类型的结果，用于表示保存操作的结果状态
+     */
+    @RequestMapping("/save")
+    public R save(@RequestBody ChatEntity chat, HttpServletRequest request) {
+        // 设置聊天记录的ID，由当前时间戳加上一个随机数生成
+        chat.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // 此处原本可能用于验证ChatEntity对象的合法性，但被注释掉了
+        //ValidatorUtils.validateEntity(chat);
+        // 如果聊天记录的提问内容不为空
+        if (StringUtils.isNotBlank(chat.getAsk())) {
+            // 更新当前用户的未回复状态为0，表示有新提问
+            chatService.updateForSet("isreply=0", new EntityWrapper<ChatEntity>().eq("userid", request.getSession().getAttribute("userId")));
+            // 设置聊天记录的用户ID为当前用户ID
+            chat.setUserid((Long) request.getSession().getAttribute("userId"));
+            // 设置回复状态为1，表示已提问等待回复
+            chat.setIsreply(1);
+        }
+        // 如果聊天记录的回复内容不为空
+        if (StringUtils.isNotBlank(chat.getReply())) {
+            // 更新当前用户（提问用户）的未回复状态为0，表示有新回复
+            chatService.updateForSet("isreply=0", new EntityWrapper<ChatEntity>().eq("userid", chat.getUserid()));
+            // 设置聊天记录的管理员ID为当前用户ID（可能表示回复的管理员）
+            chat.setAdminid((Long) request.getSession().getAttribute("userId"));
+        }
+
+        // 调用chatService的insert方法插入新的聊天记录
+        chatService.insert(chat);
+        // 返回表示保存成功的R对象
+        return R.ok();
+    }
+
+    /**
+     * 前端保存
+     * 功能与后端保存类似，但可能在前端保存时有不同的处理或用途
+     * @param chat 包含聊天记录信息的ChatEntity对象
+     * @param request HttpServletRequest对象，用于获取当前会话信息
+     * @return R类型的结果，用于表示保存操作的结果状态
+     */
+    @RequestMapping("/add")
+    public R add(@RequestBody ChatEntity chat, HttpServletRequest request) {
+        // 设置聊天记录的ID，由当前时间戳加上一个随机数生成
+        chat.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        
+        
+        // 设置聊天记录的用户ID为当前用户ID
+        chat.setUserid((Long) request.getSession().getAttribute("userId"));
+        // 如果聊天记录的提问内容不为空
+        if (StringUtils.isNotBlank(chat.getAsk())) {
+            // 更新当前用户的未回复状态为0，表示有新提问
+            chatService.updateForSet("isreply=0", new EntityWrapper<ChatEntity>().eq("userid", request.getSession().getAttribute("userId")));
+            // 设置聊天记录的用户ID为当前用户ID
+            chat.setUserid((Long) request.getSession().getAttribute("UserId"));
+            // 设置回复状态为1，表示已提问等待回复
+            chat.setIsreply(1);
+        }
+        // 如果聊天记录的回复内容不为空
+        if (StringUtils.isNotBlank(chat.getReply())) {
+            // 更新当前用户（提问用户）的未回复状态为0，表示有新回复
+            chatService.updateForSet("isreply=0", new EntityWrapper<ChatEntity>().eq("userid", chat.getUserid()));
+            // 设置聊天记录的管理员ID为当前用户ID（可能表示回复的管理员）
+            chat.setAdminid((Long) request.getSession().getAttribute("UserId"));
+        }
+
+        // 调用chatService的insert方法插入新的聊天记录
+        chatService.insert(chat);
+        // 返回表示保存成功的R对象
+        return R.ok();
+    }
+
+    /**
+     * 修改
+     * 用于修改已存在的聊天记录
+     * @param chat 包含修改后聊天记录信息的ChatEntity对象
+     * @param request HttpServletRequest对象，可能用于获取一些额外信息（此处未体现具体用途）
+     * @return R类型的结果，用于表示修改操作的结果状态
+     */
+    @RequestMapping("/update")
+    @Transactional
+    public R update(@RequestBody ChatEntity chat, HttpServletRequest request) {
+        // 此处原本可能用于验证ChatEntity对象的合法性，但被注释掉了
+        //ValidatorUtils.validateEntity(chat);
+        // 调用chatService的updateById方法，根据ID更新聊天记录
+        chatService.updateById(chat); //全部更新
+        // 返回表示修改成功的R对象
+        return R.ok();
+    }
+
+    /**
+     * 删除
+     * 用于删除指定ID的聊天记录
+     * @param ids 包含要删除聊天记录ID的数组
+     * @return R类型的结果，用于表示删除操作的结果状态
+     */
+    @RequestMapping("/delete")
+    public R delete(@RequestBody Long[] ids) {
+        // 调用chatService的deleteBatchIds方法，批量删除指定ID的聊天记录
+        chatService.deleteBatchIds(Arrays.asList(ids));
+        // 返回表示删除成功的R对象
+        return R.ok();
+    }
+
+    /**
+     * 提醒接口
+     * 根据指定的列名、类型以及其他查询条件，统计符合条件的聊天记录数量
+     * @param columnName 要进行条件判断的列名
+     * @param request HttpServletRequest对象，用于获取当前会话信息等
+     * @param type 提醒类型，可能用于区分不同的统计逻辑
+     * @param map 包含其他查询条件的Map，例如时间范围等
+     * @return R类型的结果，包含统计到的符合条件的聊天记录数量及相关状态信息
+     */
+    @RequestMapping("/remind/{columnName}/{type}")
+    public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
+            @PathVariable("type") String type, @RequestParam Map<String, Object> map) {
+        // 将列名和类型添加到查询条件Map中
+        map.put("column", columnName);
+        map.put("type", type);
+
+        // 如果提醒类型为2
+        if (type.equals("2")) {
+            // 创建SimpleDateFormat对象，用于日期格式化
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+            // 获取Calendar实例，用于日期计算
+            Calendar c = Calendar.getInstance();
+            Date remindStartDate = null;
+            Date remindEndDate = null;
+            // 如果查询条件Map中包含remindstart（开始提醒时间）
+            if (map.get("remindstart")!= null) {
+                // 将remindstart转换为整数，表示要添加的天数
+                Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
+                // 设置当前日期为基础日期
+                c.setTime(new Date());
+                // 根据提醒开始天数添加到当前日期上
+                c.add(Calendar.DAY_OF_MONTH, remindStart);
+                // 获取计算后的提醒开始日期
+                remindStartDate = c.getTime();
+                // 将提醒开始日期格式化为指定格式，并更新到查询条件Map中
+                map.put("remindstart", sdf.format(remindStartDate));
+            }
+            // 如果查询条件Map中包含remindend（结束提醒时间）
+            if (map.get("remindend")!= null) {
+                // 将remindend转换为整数，表示要添加的天数
+                Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
+                // 设置当前日期为基础日期
+                c.setTime(new Date());
+                // 根据提醒结束天数添加到当前日期上
+                c.add(Calendar.DAY_OF_MONTH, remindEnd);
+                // 获取计算后的提醒结束日期
+                remindEndDate = c.getTime();
+                // 将提醒结束日期格式化为指定格式，并更新到查询条件Map中
+                map.put("remindend", sdf.format(remindEndDate));
+            }
+        }
+
+        // 创建一个EntityWrapper对象，用于构建MyBatis Plus的查询条件
+        Wrapper<ChatEntity> wrapper = new EntityWrapper<ChatEntity>();
+        // 如果查询条件Map中包含remindstart（开始提醒时间），添加大于等于条件到查询条件中
+        if (map.get("remindstart")!= null) {
+            wrapper.ge(columnName, map.get("remindstart"));
+        }
+        // 如果查询条件Map中包含remindend（结束提醒时间），添加小于等于条件到查询条件中
+        if (map.get("remindend")!= null) {
+            wrapper.le(columnName, map.get("remindend"));
+        }
+
+        // 调用chatService的selectCount方法，根据构建好的查询条件统计符合条件的聊天记录数量
+        int count = chatService.selectCount(wrapper);
+        // 返回包含统计结果的R对象
+        return R.ok().put("count", count);
+    }
+
+}

ChatDao.java

@@ -0,0 +1,35 @@
+package com.dao;
+
+import com.entity.ChatEntity;
+import com.baomidou.mybatisplus.mapper.BaseMapper;
+import java.util.List;
+import java.util.Map;
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.plugins.pagination.Pagination;
+
+import org.apache.ibatis.annotations.Param;
+import com.entity.vo.ChatVO;
+import com.entity.view.ChatView;
+
+
+/**
+ * 在线咨询
+ * 
+ * @author 
+ * @email 
+ * @date 2023-02-21 09:46:06
+ */
+public interface ChatDao extends BaseMapper<ChatEntity> {
+	
+	List<ChatVO> selectListVO(@Param("ew") Wrapper<ChatEntity> wrapper);//根据给定的条件包装器（Wrapper）查询并返回符合条件的ChatVO列表
+	
+	ChatVO selectVO(@Param("ew") Wrapper<ChatEntity> wrapper);//根据给定的条件包装器（Wrapper）查询并返回符合条件的ChatView列表
+	
+	List<ChatView> selectListView(@Param("ew") Wrapper<ChatEntity> wrapper);
+
+	List<ChatView> selectListView(Pagination page,@Param("ew") Wrapper<ChatEntity> wrapper);
+	
+	ChatView selectView(@Param("ew") Wrapper<ChatEntity> wrapper);
+	
+
+}

ChatModel.java

@@ -0,0 +1,111 @@
+package com.entity.model;
+
+import com.entity.ChatEntity;
+
+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 2023-02-21 09:46:06
+ */
+public class ChatModel  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	/**
+	 * 管理员id
+	 */
+	
+	private Long adminid;
+		
+	/**
+	 * 提问
+	 */
+	
+	private String ask;
+		
+	/**
+	 * 回复
+	 */
+	
+	private String reply;
+		
+	/**
+	 * 是否回复
+	 */
+	
+	private Integer isreply;
+				
+	
+	/**
+	 * 设置：管理员id
+	 */
+	 
+	public void setAdminid(Long adminid) {
+		this.adminid = adminid;
+	}
+	
+	/**
+	 * 获取：管理员id
+	 */
+	public Long getAdminid() {
+		return adminid;
+	}
+				
+	
+	/**
+	 * 设置：提问
+	 */
+	 
+	public void setAsk(String ask) {
+		this.ask = ask;
+	}
+	
+	/**
+	 * 获取：提问
+	 */
+	public String getAsk() {
+		return ask;
+	}
+				
+	
+	/**
+	 * 设置：回复
+	 */
+	 
+	public void setReply(String reply) {
+		this.reply = reply;
+	}
+	
+	/**
+	 * 获取：回复
+	 */
+	public String getReply() {
+		return reply;
+	}
+				
+	
+	/**
+	 * 设置：是否回复
+	 */
+	 
+	public void setIsreply(Integer isreply) {
+		this.isreply = isreply;
+	}
+	
+	/**
+	 * 获取：是否回复
+	 */
+	public Integer getIsreply() {
+		return isreply;
+	}
+			
+}

CommonController.java

@@ -0,0 +1,313 @@
+package com.controller;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.servlet.http.HttpServletRequest;
+
+import org.apache.commons.lang3.StringUtils;
+import org.json.JSONObject;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import com.annotation.IgnoreAuth;
+import com.baidu.aip.face.AipFace;
+import com.baidu.aip.face.MatchRequest;
+import com.baidu.aip.util.Base64Util;
+import com.baomidou.mybatisplus.mapper.EntityWrapper;
+import com.entity.ConfigEntity;
+// 导入相关的服务类和工具类
+import com.service.CommonService;
+import com.service.ConfigService;
+import com.utils.BaiduUtil;
+import com.utils.FileUtil;
+import com.utils.R;
+import com.utils.CommonUtil;
+
+/**
+ * 通用接口
+ * 该类作为一个Spring的RestController，提供了一系列通用的接口方法，用于处理不同类型的业务逻辑，
+ * 如获取数据选项、根据条件获取记录、修改数据状态、统计数据等操作。
+ */
+@RestController
+public class CommonController {
+
+    // 自动注入CommonService，用于处理通用的业务逻辑
+    @Autowired
+    private CommonService commonService;
+
+    // 定义百度AI人脸识别客户端对象，初始化为null
+    private static AipFace client = null;
+
+    // 自动注入ConfigService，可能用于获取配置相关信息
+    @Autowired
+    private ConfigService configService;
+
+    /**
+     * 获取table表中的column列表（联动接口）
+     * 根据传入的表名、列名以及一些可选的条件参数，获取指定表中指定列的列表数据，可能用于下拉框等联动选择场景。
+     *
+     * @param tableName      表名
+     * @param columnName     列名
+     * @param conditionColumn 可选的条件列名，用于进一步筛选数据
+     * @param conditionValue 可选的条件值，与conditionColumn配合使用来筛选数据
+     * @param level          可选的层级参数，可能用于表示数据的层次结构相关的筛选
+     * @param parent         可选的父级参数，可能用于表示数据的父子关系相关的筛选
+     * @return 返回包含获取到的列列表数据的R对象，R对象通常用于封装返回结果信息
+     */
+    @RequestMapping("/option/{tableName}/{columnName}")
+    @IgnoreAuth
+    public R getOption(@PathVariable("tableName") String tableName, @PathVariable("tableName") String columnName,
+                       @RequestParam(required = false) String conditionColumn,
+                       @RequestParam(required = false) String conditionValue, String level, String parent) {
+        // 创建一个用于存储参数的Map对象
+        Map<String, Object> params = new HashMap<String, Object>();
+        params.put("table", tableName);
+        params.put("column", columnName);
+        if (StringUtils.isNotBlank(level)) {
+            params.put("level", level);
+        }
+        if (StringUtils.isNotBlank(parent)) {
+            params.put("parent", parent);
+        }
+        if (StringUtils.isNotBlank(conditionColumn)) {
+            params.put("conditionColumn", conditionColumn);
+        }
+        if (StringUtils.isNotBlank(conditionValue)) {
+            params.put("conditionValue", conditionValue);
+        }
+
+        // 调用commonService的getOption方法获取数据列表
+        List<String> data = commonService.getOption(params);
+
+        // 返回包含数据列表的R对象，结果状态为成功
+        return R.ok().put("data", data);
+    }
+
+    /**
+     * 根据table中的column获取单条记录
+     * 根据传入的表名、列名以及指定的列值，从指定表中获取满足条件的单条记录数据。
+     *
+     * @param tableName    表名
+     * @param columnName   列名
+     * @param columnValue  用于筛选的列值，根据该值在指定列中查找匹配的记录
+     * @return 返回包含获取到的单条记录数据的R对象
+     */
+    @RequestMapping("/follow/{tableName}/{columnName}")
+    @IgnoreAuth
+    public R getFollowByOption(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName,
+                               @RequestParam String columnValue) {
+        // 创建一个用于存储参数的Map对象
+        Map<String, Object> params = new HashMap<String, Object>();
+        params.put("table", tableName);
+        params.put("column", columnName);
+        params.put("columnValue", columnValue);
+
+        // 调用commonService的getFollowByOption方法获取单条记录数据
+        Map<String, Object> result = commonService.getFollowByOption(params);
+
+        // 返回包含单条记录数据的R对象，结果状态为成功
+        return R.ok().put("data", result);
+    }
+
+    /**
+     * 修改table表的sfsh状态
+     * 根据传入的表名和一个包含修改信息的Map对象，调用commonService的sh方法来修改指定表的sfsh状态。
+     *
+     * @param tableName 表名
+     * @param map       包含修改信息的Map对象，具体内容由调用方确定，通常包含要修改的字段和对应的值等信息
+     * @return 返回表示修改操作成功的R对象
+     */
+    @RequestMapping("/sh/{tableName}")
+    public R sh(@PathVariable("tableName") String tableName, @RequestBody Map<String, Object> map) {
+        map.put("table", tableName);
+        commonService.sh(map);
+        return R.ok();
+    }
+
+    /**
+     * 获取需要提醒的记录数
+     * 根据传入的表名、列名、类型以及一个包含其他条件的Map对象，计算并获取满足条件的需要提醒的记录数量。
+     * 当类型为2时，会根据传入的提醒开始时间和结束时间进行日期范围的计算和筛选。
+     *
+     * @param tableName    表名
+     * @param columnName   列名
+     * @param type         类型参数，1表示数字类型的提醒条件，2表示日期类型的提醒条件
+     * @param map          包含其他条件的Map对象，如提醒开始时间、提醒结束时间等（当type为2时相关）
+     * @return 返回包含需要提醒的记录数的R对象
+     */
+    @RequestMapping("/remind/{tableName}/{columnName}/{type}")
+    @IgnoreAuth
+    public R remindCount(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName,
+                         @PathVariable("type") String type, @RequestParam Map<String, Object> map) {
+        map.put("table", tableName);
+        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 recommendEnd = Integer.parseInt(map.get("remindend").toString());
+                c.setTime(new Date());
+                c.add(Calendar.DAY_OF_MONTH, recommendEnd);
+                remindEndDate = c.getTime();
+                map.put("remindend", sdf.format(remindEndDate));
+            }
+        }
+
+        // 调用commonService的remindCount方法获取需要提醒的记录数
+        int count = commonService.remindCount(map);
+
+        // 返回包含记录数的R对象，结果状态为成功
+        return R.ok().put("count", count);
+    }
+
+    /**
+     * 单列求和
+     * 根据传入的表名和列名，调用commonService的selectCal方法对指定表中的指定列进行求和操作，并返回结果。
+     *
+     * @param tableName    表名
+     * @param columnName   列名
+     * @return 返回包含求和结果的R对象
+     */
+    @RequestMapping("/cal/{tableName}/{columnName}")
+    @IgnoreAuth
+    public R cal(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName) {
+        Map<String, Object> params = new HashMap<String, Object>();
+        params.put("table", tableName);
+        params.put("column", columnName);
+
+        // 调用commonService的selectCal方法进行求和操作并获取结果
+        Map<String, Object> result = commonService.selectCal(params);
+
+        // 返回包含求和结果的R对象，结果状态为成功
+        return R.ok().put("data", result);
+    }
+
+    /**
+     * 分组统计
+     * 根据传入的表名和列名，调用commonService的selectGroup方法对指定表中的指定列进行分组统计操作，
+     * 并对结果中的日期类型数据进行格式化处理后返回。
+     *
+     * @param tableName    表名
+    ， @param columnName   列名
+     * @return 返回包含分组统计结果的R对象
+     */
+    @RequestMapping("/group/{tableName}/{columnName}")
+    @IgnoreAuth
+    public R group(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName) {
+        Map<String, Object> params = new HashMap<String, Object>();
+        params.put("table", tableName);
+        params.put("column", columnName);
+
+        // 调用commonService的selectGroup方法进行分组统计操作并获取结果
+        List<Map<String, Object>> result = commonService.selectGroup(params);
+
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+        for (Map<String, Object> m : result) {
+            for (String k : m.keySet()) {
+                if (m.get(k) instanceof Date) {
+                    m.put(k, sdf.format((Date) m.get(k)));
+                }
+            }
+        }
+
+        // 返回包含分组统计结果的R对象，结果状态为成功
+        return R.ok().put("data", result);
+    }
+
+    /**
+     * （按值统计）
+     * 根据传入的表名、x列名和y列名，调用commonService的selectValue方法对指定表中的指定列进行按值统计操作，
+     * 并对结果中的日期类型数据进行格式化处理后返回。
+     *
+     * @param tableName    表名
+     * @param yColumnName   用于统计的y列名
+     * @param xColumnName   用于分组的x列名
+     * @return 返回包含按值统计结果的R对象
+     */
+    @RequestMapping("/value/{tableName}/{xColumnName}/{yColumnName}")
+    @IgnoreAuth
+    public R value(@PathVariable("tableName") String tableName, @PathVariable("yColumnName") String yColumnName,
+                   @PathVariable("xColumnName") String xColumnName) {
+        Map<String, Object> params = new HashMap<String, Object>();
+        params.put("table", tableName);
+        params.put("xColumn", xColumnName);
+        params.put("yColumn", yColumnName);
+
+        // 调用commonService的selectValue方法进行按值统计操作并获取结果
+        List<Map<String, Object> > result = commonService.selectValue(params);
+
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+        for (Map<String, Object> m : result) {
+            for (String k : m.keySet()) {
+                if (m.get(k) instanceof Date) {
+                    m.put(k, sdf.format((Date) m.get(k)));
+                }
+            }
+        }
+
+        // 返回包含按值统计结果的R对象，结果状态为成功
+        return R.ok().put("data", result);
+    }
+
+    /**
+     * （按值统计）时间统计类型
+     * 根据传入的表名、x列名、y列名和时间统计类型，调用commonService的selectTimeStatValue方法对指定表中的指定列进行按值统计操作，
+     * 并对结果中的日期类型数据进行格式化处理后返回。
+     *
+     * @param tableName    表名
+     * @param yColumnName   用于统计的y列名
+     * @param xColumnName   用于分组的x列名
+     * @param timeStatType 时间统计类型参数
+     * @return 返回包含按值统计结果的R对象
+     */
+    @RequestMapping("/value/{tableName}/{xColumnName}/{yColumnName}/{timeStatType}")
+    @IgnoreAuth
+    public R valueDay(@PathVariable("tableName") String tableName, @PathVariable("yColumnName") String yColumnName,
+                      @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType) {
+        Map<String, Object> params = new HashMap<String, Object>();
+        params.put("table", tableName);
+        params.put("xColumn", xColumnName);
+        params.put("yColumn", yColumnName);
+        params.put("timeStatType", timeStatType);
+
+        // 调用commonService的selectTimeStatValue方法进行按值统计操作并获取结果
+        List<Map<String, Object> > result = commonService.selectTimeStatValue(params);
+
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+        for (Map<String, Object> m : result) {
+            for (String k : m.keySet()) {
+                if (m.get(k) instanceof Date) {
+                    m.put(k, sdf.format((Date) m.get(k)));
+                }
+            }
+        }
+
+        // 返回包含按值统计结果的R对象，结果状态为成功
+        return R.ok().put("data", result);
+    }
+
+}

CommonDao.java

@@ -0,0 +1,73 @@
+
+package com.dao;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 通用接口，定义了一组用于数据库操作的方法。
+ */
+public interface CommonDao {
+    
+    /**
+     * 根据给定的参数获取选项列表。
+     * @param params 包含查询条件的参数映射
+     * @return 返回一个字符串列表，表示查询结果
+     */
+    List<String> getOption(Map<String, Object> params);
+    
+    /**
+     * 根据给定的参数获取关注信息。
+     * @param params 包含查询条件的参数映射
+     * @return 返回一个包含关注信息的映射
+     */
+    Map<String, Object> getFollowByOption(Map<String, Object> params);
+    
+    /**
+     * 根据给定的参数获取另一种形式的关注信息列表。
+     * @param params 包含查询条件的参数映射
+     * @return 返回一个字符串列表，表示查询结果
+     */
+    List<String> getFollowByOption2(Map<String, Object> params);
+    
+    /**
+     * 执行某种操作（具体操作未明确）。
+     * @param params 包含操作所需参数的映射
+     */
+    void sh(Map<String, Object> params);
+    
+    /**
+     * 计算提醒的数量。
+     * @param params 包含查询条件的参数映射
+     * @return 返回提醒的数量
+     */
+    int remindCount(Map<String, Object> params);
+    
+    /**
+     * 根据给定的参数进行某种计算。
+     * @param params 包含计算所需参数的映射
+     * @return 返回一个包含计算结果的映射
+     */
+    Map<String, Object> selectCal(Map<String, Object> params);
+    
+    /**
+     * 根据给定的参数分组查询。
+     * @param params 包含查询条件的参数映射
+     * @return 返回一个包含分组查询结果的映射列表
+     */
+    List<Map<String, Object>> selectGroup(Map<String, Object> params);
+    
+    /**
+     * 根据给定的参数查询值。
+     * @param params 包含查询条件的参数映射
+     * @return 返回一个包含查询结果的映射列表
+     */
+    List<Map<String, Object>> selectValue(Map<String, Object> params);
+    
+    /**
+     * 根据给定的参数查询时间统计值。
+     * @param params 包含查询条件的参数映射
+     * @return 返回一个包含时间统计值的映射列表
+     */
+    List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params);
+}

README.md

@@ -1,2 +0,0 @@
-# j2ee
-

YonghuController.java

@@ -0,0 +1,401 @@
+package com.controller;
+
+import java.math.BigDecimal;
+import java.text.SimpleDateFormat;
+import java.text.ParseException;
+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 java.io.IOException;
+
+import com.utils.ValidatorUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Transactional;
+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.YonghuEntity;
+import com.entity.view.YonghuView;
+
+import com.service.YonghuService;
+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 2023-02-21 09:46:06
+ */
+@RestController
+@RequestMapping("/yonghu")
+public class YonghuController {
+
+    // 自动注入用户服务类，用于处理与用户相关的业务逻辑
+    @Autowired
+    private YonghuService yonghuService;
+
+    // 自动注入令牌服务类，用于生成和管理用户令牌
+    @Autowired
+    private TokenService tokenService;
+
+    /**
+     * 用户登录方法
+     * @param username 用户名
+     * @param password 密码
+     * @param captcha 验证码（此处未在代码中看到对验证码的实际验证逻辑）
+     * @param request Http请求对象
+     * @return 返回包含登录结果信息的R对象，若登录成功则包含生成的令牌
+     */
+    @IgnoreAuth
+    @RequestMapping(value = "/login")
+    public R login(String username, String password, String captcha, HttpServletRequest request) {
+        // 根据用户名查询用户实体
+        YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", username));
+        if (u == null ||!u.getMima().equals(password)) {
+            // 若用户不存在或密码不匹配，返回错误信息
+            return R.error("账号或密码不正确");
+        }
+        // 生成用户令牌
+        String token = tokenService.generateToken(u.getId(), username, "yonghu", "用户");
+        return R.ok().put("token", token);
+    }
+
+    /**
+     * 用户注册方法
+     * @param yonghu 包含用户注册信息的YonghuEntity对象
+     * @return 返回包含注册结果信息的R对象
+     */
+    @IgnoreAuth
+    @RequestMapping("/register")
+    public R register(@RequestBody YonghuEntity yonghu) {
+        // 此处原本应有对用户实体的验证逻辑，但被注释掉了
+        //ValidatorUtils.validateEntity(yonghu);
+        // 根据用户名查询是否已存在该用户
+        YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", yonghu.getZhanghao()));
+        if (u!= null) {
+            // 若用户已存在，返回错误信息
+            return R.error("注册用户已存在");
+        }
+        // 设置用户ID为当前时间戳
+        Long uId = new Date().getTime();
+        yonghu.setId(uId);
+        // 插入新用户信息到数据库
+        yonghuService.insert(yonghu);
+        return R.ok();
+    }
+
+    /**
+     * 用户退出方法
+     * @param request Http请求对象
+     * @return 返回包含退出成功信息的R对象
+     */
+    @RequestMapping("/logout")
+    public R logout(HttpServletRequest request) {
+        // 使当前会话失效，实现用户退出
+        request.getSession().invalidate();
+        return R.ok("退出成功");
+    }
+
+    /**
+     * 获取当前用户的会话信息方法
+     * @param request Http请求对象
+     * @return 返回包含当前用户信息的R对象
+     */
+    @RequestMapping("/session")
+    public R getCurrUser(HttpServletRequest request) {
+        // 从会话中获取用户ID
+        Long id = (Long) request.getSession().getAttribute("userId");
+        // 根据用户ID查询用户实体
+        YonghuEntity u = yonghuService.selectById(id);
+        return R.ok().put("data", u);
+    }
+
+    /**
+     * 用户密码重置方法
+     * @param username 用户名
+     * @param request Http请求对象
+     * @return 返回包含密码重置结果信息的R对象
+     */
+    @IgnoreAuth
+    @RequestMapping(value = "/resetPass")
+    public R resetPass(String username, HttpServletRequest request) {
+        // 根据用户名查询用户实体
+        YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", username));
+        if (u == null) {
+            // 若用户不存在，返回错误信息
+            return R.error("账号不存在");
+        }
+        // 将用户密码重置为"123456"
+        u.setMima("123456");
+        // 更新用户信息到数据库
+        yonghuService.updateById(u);
+        return R.ok("密码已重置为：123456");
+    }
+
+    /**
+     * 获取用户列表（后端）方法
+     * @param params 查询参数的Map对象
+     * @param yonghu YonghuEntity对象，可能用于条件筛选等
+     * @param request Http请求对象
+     * @return 返回包含用户列表分页信息的R对象
+     */
+    @RequestMapping("/page")
+    public R page(@RequestParam Map<String, Object> params, YonghuEntity yonghu,
+                   HttpServletRequest request) {
+        // 创建用于构建查询条件的EntityWrapper对象
+        EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
+
+        // 调用服务类的方法进行分页查询，并进行排序、条件筛选等操作
+        PageUtils page = yonghuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yonghu), params), params));
+        request.setAttribute("data", page);
+        return R.ok().put("data", page);
+    }
+
+    /**
+     * 获取用户列表（前端）方法
+     * 与page方法类似，只是多了@IgnoreAuth注解，可能表示前端访问此接口无需认证
+     * @param params 查询参数的Map对象
+     * @param yonghu YonghuEntity对象，可能用于条件筛选等
+     * @param request Http请求对象
+     * @return 返回包含用户列表分页信息的R对象
+     */
+    @IgnoreAuth
+    @RequestMapping("/list")
+    public R list(@RequestParam Map<String, Object> params, YonghuEntity yonghu,
+                   HttpServletRequest request) {
+        EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
+
+        PageUtils page = yonghuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yonghu), params), params));
+        request.setAttribute("data", page);
+        return R.ok().put("data", page);
+    }
+
+    /**
+     * 获取用户列表方法（另一种实现方式，可能用于特定场景）
+     * @param yonghu YonghuEntity对象，用于构建查询条件
+     * @return 返回包含用户列表信息的R对象
+     */
+    @RequestMapping("/lists")
+    public R list(YonghuEntity yonghu) {
+        EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
+        ew.allEq(MPUtil.allEQMapPre(yonghu, "yonghu"));
+        return R.ok().put("data", yonghuService.selectListView(ew));
+    }
+
+    /**
+     * 查询单个用户信息方法
+     * @param yonghu YonghuEntity对象，用于构建查询条件
+     * @return 返回包含查询到的用户视图信息的R对象
+     */
+    @RequestMapping("/query")
+    public R query(YonghuEntity yonghu) {
+        EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
+        ew.allEq(MPUtil.allEQMapPre(yonghu, "yonghu"));
+        YonghuView yonghuView = yonghuService.selectView(ew);
+        return R.ok("查询用户成功").put("data", yonghuView);
+    }
+
+    /**
+     * 获取用户详细信息（后端）方法
+     * @param id 用户ID
+     * @return 返回包含用户详细信息的R对象
+     */
+    @RequestMapping("/info/{id}")
+    public R info(@PathVariable("id") Long id) {
+        YonghuEntity yonghu = yonghuService.selectById(id);
+        return R.ok().put("data", yonghu);
+    }
+
+    /**
+     * 获取用户详细信息（前端）方法
+     * 与info方法类似，多了@IgnoreAuth注解，可能表示前端访问此接口无需认证
+     * @param id 用户ID
+     * @return 返回包含用户详细信息的R对象
+     */
+    @IgnoreAuth
+    @RequestMapping("/detail/{id}")
+    public R detail(@PathVariable("id") Long id) {
+        YonghuEntity yonghu = yonghuService.selectById(id);
+        return R.ok().put("data", yonghu);
+    }
+
+    /**
+     * 保存用户信息（后端）方法
+     * @param yonghu 包含用户信息的YonghuEntity对象
+     * @param request Http请求对象
+     * @return 返回包含保存结果信息的R对象
+     */
+    @RequestMapping("/save")
+    public R save(@RequestBody YonghuEntity yonghu, HttpServletRequest request) {
+        // 设置用户ID为当前时间戳加上一个随机数
+        yonghu.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // 此处原本应有对用户实体的验证逻辑，但被注释掉了
+        //ValidatorUtils.validateEntity(yonghu);
+        YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", yonghu.getZhanghao()));
+        if (u!= null) {
+            // 若用户已存在，返回错误信息
+            return R.error("用户已存在");
+        }
+
+        yonghu.setId(new Date().getTime());
+        yonghuService.insert(yonghu);
+        return R.ok();
+    }
+
+    /**
+     * 保存用户信息（前端）方法
+     * 与save方法类似，可能在前端页面操作保存用户信息时调用
+     * @param yonghu 包含用户信息的YonghuEntity对象
+     * @param request Http请求对象
+     * @return 返回包含保存结果信息的R对象
+     */
+    @RequestMapping("/add")
+    public R add(@RequestBody YonghuEntity yonghu, HttpServletRequest request) {
+        yonghu.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // 此处原本应有对用户实体的验证逻辑，但被注释掉了
+        //ValidatorUtils.validateEntity(yonghu);
+        YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", yonghu.getZhanghao()));
+        if (u!= null) {
+            // 若用户已存在，返回错误信息
+            return R.error("用户已存在");
+        }
+
+        yonghu.setId(new Date().getTime());
+        yonghuService.insert(yonghu);
+        return R.ok();
+    }
+
+    /**
+     * 更新用户信息方法
+     * @param yonghu 包含更新后用户信息的YonghuEntity对象
+     * @param request Http请求对象
+     * @return 返回包含更新结果信息的R对象
+     */
+    @RequestMapping("/update")
+    @Transactional
+    public R update(@RequestBody YonghuEntity yonghu, HttpServletRequest request) {
+        // 此处原本应有对用户实体的验证逻辑，但被注释掉了
+        //ValidatorUtils.validateEntity(yonghu);
+        yonghuService.updateById(yonghu); // 全部更新
+        return R.ok();
+    }
+
+    /**
+     * 删除用户信息方法
+     * @param ids 要删除的用户ID数组
+     * @return 返回包含删除结果信息的R对象
+     */
+    @RequestMapping("/delete")
+    public R delete(@RequestBody Long[] ids) {
+        yonghuService.deleteBatchIds(Arrays.asList(ids));
+        return R.ok();
+    }
+
+    /**
+     * 提醒接口方法，根据指定条件统计符合要求的用户数量
+     * @param columnName 用于筛选的列名
+     * @param request Http请求对象
+     * @param type 类型参数，可能用于区分不同的提醒逻辑
+     * @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.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<YonghuEntity> wrapper = new EntityWrapper<YonghuEntity>();
+        if (map.get("remindstart")!= null) {
+            wrapper.ge(columnName, map.get("remindstart"));
+        }
+        if (map.get("remindend")!= null) {
+            wrapper.le(columnName, map.get("remindend"));
+        }
+
+        int count = yonghuService.selectCount(wrapper);
+        return R.ok().put("count", count);
+    }
+
+    /**
+     * （按值统计）方法，根据指定的列进行统计并返回结果
+     * @param yColumnName 用于统计的列名（纵坐标相关）
+     * @param xColumnName 用于分组的列名（横坐标相关）
+    * @param request Http请求对象
+     * @return 返回包含统计结果的R对象
+     */
+    @RequestMapping("/value/{xColumnName}/{yColumnName}")
+    public R value(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, HttpServletRequest request) {
+        Map<String, Object> params = new HashMap<String, Object>();
+        params.put("xColumn", xColumnName);
+        params.put("yColumn", yColumnName);
+        EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
+        List<Map<String, Object>> result = yonghuService.selectValue(params, ew);
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+        for (Map<String, Object> m : result) {
+            for (String k : m.keySet()) {
+                if (m.get(k) instanceof Date) {
+                    m.put(k, sdf.format((Date) m.get(k)));
+                }
+            }
+        }
+        return R.ok().put("data", result);
+    }
+
+    /**
+     * （按值统计）时间统计类型方法，根据指定的列和时间统计类型进行统计并返回结果
+     * @param yColumnName 用于统计的列名（纵坐标相关）
+     * @param xColumnName 用于分组的列名（横坐标相关）
+     * @param timeStatType 时间统计类型参数
+     * @param request Http请求对象
+     * @return 返回包含统计结果的R对象
+     */
+    @RequestMapping("/value/{xColumnName}/{yColumnName}/{timeStatType}")
+    public R valueDay(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType, HttpServletRequest request) {
+        Map<String, Object> params = new HashMap<String, Object>();
+        params.put("xColumn", xColumnName);
+        params.put("yColumn", yColumnName);
+        params.put("timeStatType", timeStatType);
+        EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
+        List<Map<String, Object>> result

YonghuDao.java

@@ -0,0 +1,42 @@
+package com.dao;
+
+import com.entity.YonghuEntity;
+import com.baomidou.mybatisplus.mapper.BaseMapper;
+import java.util.List;
+import java.util.Map;
+import com.baomidou.mybatisplus.mapper.Wrapper;
+import com.baomidou.mybatisplus.plugins.pagination.Pagination;
+import org.apache.ibatis.annotations.Param;
+import com.entity.vo.YonghuVO;
+import com.entity.view.YonghuView;
+
+/**
+ * 用户数据访问对象接口，继承自MyBatis-Plus的BaseMapper。
+ * 提供对用户实体（YonghuEntity）的数据库操作方法。
+ */
+public interface YonghuDao extends BaseMapper<YonghuEntity> {
+    
+    // 根据条件查询用户视图对象列表
+    List<YonghuVO> selectListVO(@Param("ew") Wrapper<YonghuEntity> wrapper);
+    
+    // 根据条件查询单个用户视图对象
+    YonghuVO selectVO(@Param("ew") Wrapper<YonghuEntity> wrapper);
+    
+    // 根据条件查询用户视图对象列表
+    List<YonghuView> selectListView(@Param("ew") Wrapper<YonghuEntity> wrapper);
+
+    // 根据分页信息和条件查询用户视图对象列表
+    List<YonghuView> selectListView(Pagination page, @Param("ew") Wrapper<YonghuEntity> wrapper);
+    
+    // 根据条件查询单个用户视图对象
+    YonghuView selectView(@Param("ew") Wrapper<YonghuEntity> wrapper);
+    
+    // 根据参数和条件查询值映射列表
+    List<Map<String, Object>> selectValue(@Param("params") Map<String, Object> params, @Param("ew") Wrapper<YonghuEntity> wrapper);
+
+    // 根据参数和条件查询时间统计值映射列表
+    List<Map<String, Object>> selectTimeStatValue(@Param("params") Map<String, Object> params, @Param("ew") Wrapper<YonghuEntity> wrapper);
+    
+    // 根据参数和条件分组查询映射列表
+    List<Map<String, Object>> selectGroup(@Param("params") Map<String, Object> params, @Param("ew") Wrapper<YonghuEntity> wrapper);
+}

YonghuModel.java

@@ -0,0 +1,156 @@
+package com.entity.model;
+
+import com.entity.YonghuEntity;
+
+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;
+ 
+
+/**
+ * 用户
+ * 接收传参的实体类  
+  * 取自ModelAndView 的model名称
+ * @author 
+ * @email 
+ * @date 2023-02-21 09:46:06
+ */
+public class YonghuModel  implements Serializable {
+	private static final long serialVersionUID = 1L;
+
+	 			
+	/**
+	 * 密码
+	 */
+	
+	private String mima;
+		
+	/**
+	 * 姓名
+	 */
+	
+	private String xingming;
+		
+	/**
+	 * 性别
+	 */
+	
+	private String xingbie;
+		
+	/**
+	 * 邮箱
+	 */
+	
+	private String youxiang;
+		
+	/**
+	 * 手机号码
+	 */
+	
+	private String shoujihaoma;
+		
+	/**
+	 * 头像
+	 */
+	
+	private String touxiang;
+				
+	
+	/**
+	 * 设置：密码
+	 */
+	 
+	public void setMima(String mima) {
+		this.mima = mima;
+	}
+	
+	/**
+	 * 获取：密码
+	 */
+	public String getMima() {
+		return mima;
+	}
+				
+	
+	/**
+	 * 设置：姓名
+	 */
+	 
+	public void setXingming(String xingming) {
+		this.xingming = xingming;
+	}
+	
+	/**
+	 * 获取：姓名
+	 */
+	public String getXingming() {
+		return xingming;
+	}
+				
+	
+	/**
+	 * 设置：性别
+	 */
+	 
+	public void setXingbie(String xingbie) {
+		this.xingbie = xingbie;
+	}
+	
+	/**
+	 * 获取：性别
+	 */
+	public String getXingbie() {
+		return xingbie;
+	}
+				
+	
+	/**
+	 * 设置：邮箱
+	 */
+	 
+	public void setYouxiang(String youxiang) {
+		this.youxiang = youxiang;
+	}
+	
+	/**
+	 * 获取：邮箱
+	 */
+	public String getYouxiang() {
+		return youxiang;
+	}
+				
+	
+	/**
+	 * 设置：手机号码
+	 */
+	 
+	public void setShoujihaoma(String shoujihaoma) {
+		this.shoujihaoma = shoujihaoma;
+	}
+	
+	/**
+	 * 获取：手机号码
+	 */
+	public String getShoujihaoma() {
+		return shoujihaoma;
+	}
+				
+	
+	/**
+	 * 设置：头像
+	 */
+	 
+	public void setTouxiang(String touxiang) {
+		this.touxiang = touxiang;
+	}
+	
+	/**
+	 * 获取：头像
+	 */
+	public String getTouxiang() {
+		return touxiang;
+	}
+			
+}