Skip to content

X
xinrenli
Commit 2e2b1c14 by 郑云飞
Options

Changes

parent 91cf74a2
Showing with 6342 additions and 2305 deletions
ruoyi-admin/src/main/java/com/ruoyi/RuoYiApplication.java
......@@ -10,7 +10,7 @@ import org.springframework.context.annotation.ComponentScan;
*
* @author ruoyi
*/
@ComponentScan({"com.ruoyi.*", "com.yongqi.*"})
@ComponentScan({"com.yongqi.*"})
@SpringBootApplication
public class RuoYiApplication {
......
ruoyi-admin/src/main/resources/application-dev.yml
......@@ -167,3 +167,35 @@ sms:
signName: 测试
# 腾讯专用
sdkAppId:
wx:
pay:
appId: wx312fb4fecd3ee803 #微信公众号或者小程序等的appid
mchId: #微信支付商户号
mchKey: #微信支付商户密钥
subAppId: #服务商模式下的子商户公众账号ID
subMchId: #服务商模式下的子商户号
keyPath: # p12证书的位置，可以指定绝对路径，也可以指定类路径（以classpath:开头）
# mp:
# useRedis: false
# redisConfig:
# host: cluster1.prd.jianghuxx.com
# port: 6319
# password: jhxx@2022
# timeout: 10
# configs:
# - appId: 1111 # 第一个公众号的appid
# secret: 1111 # 公众号的appsecret
# token: 111 # 接口配置里的Token值
# aesKey: 111 # 接口配置里的EncodingAESKey值
# - appId: 2222 # 第二个公众号的appid，以下同上
# secret: 1111
# token: 111
# aesKey: 111
miniapp:
configs:
- appid: wx312fb4fecd3ee803 #微信小程序的appid
secret: d35e4d7307d60619b407f803f76368c1 #微信小程序的Secret
token: #微信小程序消息服务器配置的token
aesKey: #微信小程序消息服务器配置的EncodingAESKey
msgDataFormat: JSON
ruoyi-admin/src/main/resources/application.yml
......@@ -142,7 +142,7 @@ security:
mybatis-plus:
# 不支持多包, 如有需要可在注解配置 或 提升扫包等级
# 例如 com.**.**.mapper
mapperPackage: com.**.**.mapper
mapperPackage: com.ruoyi.**.mapper
# 对应的 XML 文件位置
mapperLocations: classpath*:mapper/**/*Mapper.xml
# 实体扫描，多个package用逗号或者分号分隔
......
ruoyi-generator/src/main/resources/generator.yml
# 代码生成
gen:
gen:
# 作者
author: ruoyi
author: zyf
# 默认生成包路径 system 需改成自己的模块名称 如 system monitor tool
packageName: com.ruoyi.system
packageName: com.yongqi.xinrenli
# 自动去除表前缀，默认是false
autoRemovePre: false
# 表前缀（生成类名不会包含表前缀，多个用逗号分隔）
tablePrefix: sys_
\ No newline at end of file
tablePrefix: sys_
xinrenli/pom.xml
......@@ -39,6 +39,30 @@
<!-- <artifactId>tencentcloud-sdk-java-sms</artifactId>-->
<!-- </dependency>-->
<!-- 微信小程序 -->
<dependency>
<groupId>com.github.binarywang</groupId>
<artifactId>weixin-java-miniapp</artifactId>
<version>4.4.0</version>
</dependency>
<!-- 微信公众号 -->
<dependency>
<groupId>com.github.binarywang</groupId>
<artifactId>weixin-java-mp</artifactId>
<version>4.4.0</version>
</dependency>
<!-- 微信支付 -->
<dependency>
<groupId>com.github.binarywang</groupId>
<artifactId>weixin-java-pay</artifactId>
<version>4.4.0</version>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.3.0</version>
</dependency>
</dependencies>
</project>
xinrenli/src/main/java/com/yongqi/xinrenli/admin/controller/ArticleController.java deleted 100644 → 0
package com.yongqi.xinrenli.admin.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 文章表 前端控制器
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@RestController
@RequestMapping("/article")
public class ArticleController {
}
xinrenli/src/main/java/com/yongqi/xinrenli/admin/controller/CouponController.java deleted 100644 → 0
package com.yongqi.xinrenli.admin.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 优惠卷表 前端控制器
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@RestController
@RequestMapping("/coupon")
public class CouponController {
}
xinrenli/src/main/java/com/yongqi/xinrenli/admin/controller/OrderController.java deleted 100644 → 0
package com.yongqi.xinrenli.admin.controller;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import com.ruoyi.common.core.validate.QueryGroup;
import com.yongqi.xinrenli.domain.bo.OrderBo;
import com.yongqi.xinrenli.domain.vo.OrderVo;
import com.yongqi.xinrenli.service.IOrderService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* <p>
* 订单表 前端控制器
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Slf4j
@RestController
@RequestMapping("/order")
public class OrderController {
@Autowired
IOrderService iOrderService;
/**
* 用户发布需求订单
*
* @param orderBo
* @return
*/
@ResponseBody
@PostMapping("/publishOrder")
public R publishOrder(@RequestBody @Validated(AddGroup.class) OrderBo orderBo) {
log.info("wanglei-orderBo:{}", orderBo);
if (iOrderService.isAllEmpty(orderBo)) {
return R.fail("图片，视频，语音必传一项");
}
boolean flag = iOrderService.addOrder(orderBo);
if (!flag) {
return R.fail("发布失败，请稍后重试");
}
return R.ok("发布成功");
}
/**
* 查看订单详情 根据id查询
*
* @param id
* @return
*/
@ResponseBody
@GetMapping("/getOrderDetailById/{id}")
public R<OrderVo> getOrderDetailById(@PathVariable Long id) {
if (id == null) {
return R.ok("查询失败，id为空");
}
OrderVo orderVo = iOrderService.getOrderById(id);
if (orderVo == null) {
return R.ok("查询失败，请稍后重试");
}
return R.ok("查询成功", orderVo);
}
/**
* 条件分页查询
*
* @param orderBo
* @return
*/
@ResponseBody
@GetMapping("/getOrderByPage")
public R<Page> getOrderByPage(@RequestBody @Validated(QueryGroup.class) OrderBo orderBo) {
Page<OrderVo> orderVo = iOrderService.getOrderByPage(orderBo);
if (orderVo == null) {
return R.ok("查询失败，请稍后重试");
}
return R.ok("查询成功", orderVo);
}
/**
* 修改订单
*
* @param orderBo
* @return
*/
@ResponseBody
@PutMapping("/updateOrder")
public R updateOrder(@RequestBody @Validated(EditGroup.class) OrderBo orderBo) {
if (iOrderService.isAllEmpty(orderBo)) {
return R.fail("图片，视频，语音必传一项");
}
boolean flag = iOrderService.updateOrder(orderBo);
if (!flag) {
return R.fail("修改失败，请稍后重试");
}
return R.ok("修改成功");
}
/**
* 取消订单
*
* @param id
* @return
*/
@ResponseBody
@DeleteMapping("/cancelOrderById/{id}")
public R cancelOrderById(@PathVariable Long id) {
if (id == null) {
return R.ok("取消失败，id为空");
}
boolean flag = iOrderService.cancelOrderById(id);
if (!flag) {
return R.ok("取消订单失败，请稍后重试");
}
return R.ok("取消订单成功");
}
/**
* 测试连通用
*
* @return
*/
@ResponseBody
@GetMapping("/test")
public String test() {
return "test_success";
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/admin/controller/UserCommentController.java deleted 100644 → 0
package com.yongqi.xinrenli.admin.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 用户评论表 前端控制器
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@RestController
@RequestMapping("/user-comment")
public class UserCommentController {
}
xinrenli/src/main/java/com/yongqi/xinrenli/admin/controller/UserFeedbackController.java deleted 100644 → 0
package com.yongqi.xinrenli.admin.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 用户反馈表 前端控制器
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@RestController
@RequestMapping("/user-feedback")
public class UserFeedbackController {
}
xinrenli/src/main/java/com/yongqi/xinrenli/admin/controller/WxUserController.java deleted 100644 → 0
package com.yongqi.xinrenli.admin.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 微信用户 前端控制器
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@RestController
@RequestMapping("/wx-user")
public class WxUserController {
}
xinrenli/src/main/java/com/yongqi/xinrenli/builder/AbstractBuilder.java 0 → 100644
package com.yongqi.xinrenli.builder;
import me.chanjar.weixin.mp.api.WxMpService;
import me.chanjar.weixin.mp.bean.message.WxMpXmlMessage;
import me.chanjar.weixin.mp.bean.message.WxMpXmlOutMessage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @author <a href="https://github.com/binarywang">Binary Wang</a>
*/
public abstract class AbstractBuilder {
protected final Logger logger = LoggerFactory.getLogger(getClass());
public abstract WxMpXmlOutMessage build(String content,
WxMpXmlMessage wxMessage, WxMpService service);
}
xinrenli/src/main/java/com/yongqi/xinrenli/builder/ImageBuilder.java 0 → 100644
package com.yongqi.xinrenli.builder;
import me.chanjar.weixin.mp.api.WxMpService;
import me.chanjar.weixin.mp.bean.message.WxMpXmlMessage;
import me.chanjar.weixin.mp.bean.message.WxMpXmlOutImageMessage;
import me.chanjar.weixin.mp.bean.message.WxMpXmlOutMessage;
/**
* @author <a href="https://github.com/binarywang">Binary Wang</a>
*/
public class ImageBuilder extends AbstractBuilder {
@Override
public WxMpXmlOutMessage build(String content, WxMpXmlMessage wxMessage,
WxMpService service) {
WxMpXmlOutImageMessage m = WxMpXmlOutMessage.IMAGE().mediaId(content)
.fromUser(wxMessage.getToUser()).toUser(wxMessage.getFromUser())
.build();
return m;
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/builder/TextBuilder.java 0 → 100644
package com.yongqi.xinrenli.builder;
import me.chanjar.weixin.mp.api.WxMpService;
import me.chanjar.weixin.mp.bean.message.WxMpXmlMessage;
import me.chanjar.weixin.mp.bean.message.WxMpXmlOutMessage;
import me.chanjar.weixin.mp.bean.message.WxMpXmlOutTextMessage;
/**
* @author <a href="https://github.com/binarywang">Binary Wang</a>
*/
public class TextBuilder extends AbstractBuilder {
@Override
public WxMpXmlOutMessage build(String content, WxMpXmlMessage wxMessage,
WxMpService service) {
WxMpXmlOutTextMessage m = WxMpXmlOutMessage.TEXT().content(content)
.fromUser(wxMessage.getToUser()).toUser(wxMessage.getFromUser())
.build();
return m;
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/config/WxMaConfiguration.java 0 → 100644
package com.yongqi.xinrenli.config;
import cn.binarywang.wx.miniapp.api.WxMaService;
import cn.binarywang.wx.miniapp.api.impl.WxMaServiceImpl;
import cn.binarywang.wx.miniapp.bean.WxMaKefuMessage;
import cn.binarywang.wx.miniapp.bean.WxMaSubscribeMessage;
import cn.binarywang.wx.miniapp.config.impl.WxMaDefaultConfigImpl;
import cn.binarywang.wx.miniapp.config.impl.WxMaRedisConfigImpl;
import cn.binarywang.wx.miniapp.message.WxMaMessageHandler;
import cn.binarywang.wx.miniapp.message.WxMaMessageRouter;
import com.google.common.collect.Lists;
import lombok.extern.slf4j.Slf4j;
import me.chanjar.weixin.common.bean.result.WxMediaUploadResult;
import me.chanjar.weixin.common.error.WxErrorException;
import me.chanjar.weixin.common.error.WxRuntimeException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.JedisPool;
import java.io.File;
import java.util.List;
import java.util.stream.Collectors;
/**
* @author <a href="https://github.com/binarywang">Binary Wang</a>
*/
@Slf4j
@Configuration
@EnableConfigurationProperties(WxMaProperties.class)
public class WxMaConfiguration {
private final WxMaProperties properties;
@Autowired
public WxMaConfiguration(WxMaProperties properties) {
this.properties = properties;
}
@Bean
public WxMaService wxMaService() {
List<WxMaProperties.Config> configs = this.properties.getConfigs();
if (configs == null) {
throw new WxRuntimeException("大哥，拜托先看下项目首页的说明（readme文件），添加下相关配置，注意别配错了！");
}
WxMaService maService = new WxMaServiceImpl();
maService.setMultiConfigs(
configs.stream()
.map(a -> {
WxMaDefaultConfigImpl config = new WxMaDefaultConfigImpl();
// WxMaDefaultConfigImpl config = new WxMaRedisConfigImpl(new JedisPool());
// 使用上面的配置时，需要同时引入jedis-lock的依赖，否则会报类无法找到的异常
config.setAppid(a.getAppid());
config.setSecret(a.getSecret());
config.setToken(a.getToken());
config.setAesKey(a.getAesKey());
config.setMsgDataFormat(a.getMsgDataFormat());
return config;
}).collect(Collectors.toMap(WxMaDefaultConfigImpl::getAppid, a -> a, (o, n) -> o)));
return maService;
}
@Bean
public WxMaMessageRouter wxMaMessageRouter(WxMaService wxMaService) {
final WxMaMessageRouter router = new WxMaMessageRouter(wxMaService);
router
.rule().handler(logHandler).next()
.rule().async(false).content("订阅消息").handler(subscribeMsgHandler).end()
.rule().async(false).content("文本").handler(textHandler).end()
.rule().async(false).content("图片").handler(picHandler).end()
.rule().async(false).content("二维码").handler(qrcodeHandler).end();
return router;
}
private final WxMaMessageHandler subscribeMsgHandler = (wxMessage, context, service, sessionManager) -> {
service.getMsgService().sendSubscribeMsg(WxMaSubscribeMessage.builder()
.templateId("此处更换为自己的模板id")
.data(Lists.newArrayList(
new WxMaSubscribeMessage.MsgData("keyword1", "339208499")))
.toUser(wxMessage.getFromUser())
.build());
return null;
};
private final WxMaMessageHandler logHandler = (wxMessage, context, service, sessionManager) -> {
log.info("收到消息：" + wxMessage.toString());
service.getMsgService().sendKefuMsg(WxMaKefuMessage.newTextBuilder().content("收到信息为：" + wxMessage.toJson())
.toUser(wxMessage.getFromUser()).build());
return null;
};
private final WxMaMessageHandler textHandler = (wxMessage, context, service, sessionManager) -> {
service.getMsgService().sendKefuMsg(WxMaKefuMessage.newTextBuilder().content("回复文本消息")
.toUser(wxMessage.getFromUser()).build());
return null;
};
private final WxMaMessageHandler picHandler = (wxMessage, context, service, sessionManager) -> {
try {
WxMediaUploadResult uploadResult = service.getMediaService()
.uploadMedia("image", "png",
ClassLoader.getSystemResourceAsStream("tmp.png"));
service.getMsgService().sendKefuMsg(
WxMaKefuMessage
.newImageBuilder()
.mediaId(uploadResult.getMediaId())
.toUser(wxMessage.getFromUser())
.build());
} catch (WxErrorException e) {
e.printStackTrace();
}
return null;
};
private final WxMaMessageHandler qrcodeHandler = (wxMessage, context, service, sessionManager) -> {
try {
final File file = service.getQrcodeService().createQrcode("123", 430);
WxMediaUploadResult uploadResult = service.getMediaService().uploadMedia("image", file);
service.getMsgService().sendKefuMsg(
WxMaKefuMessage
.newImageBuilder()
.mediaId(uploadResult.getMediaId())
.toUser(wxMessage.getFromUser())
.build());
} catch (WxErrorException e) {
e.printStackTrace();
}
return null;
};
}
xinrenli/src/main/java/com/yongqi/xinrenli/config/WxMaProperties.java 0 → 100644
package com.yongqi.xinrenli.config;
import java.util.List;
import org.springframework.boot.context.properties.ConfigurationProperties;
import lombok.Data;
/**
* @author <a href="https://github.com/binarywang">Binary Wang</a>
*/
@Data
@ConfigurationProperties(prefix = "wx.miniapp")
public class WxMaProperties {
private List<Config> configs;
@Data
public static class Config {
/**
* 设置微信小程序的appid
*/
private String appid;
/**
* 设置微信小程序的Secret
*/
private String secret;
/**
* 设置微信小程序消息服务器配置的token
*/
private String token;
/**
* 设置微信小程序消息服务器配置的EncodingAESKey
*/
private String aesKey;
/**
* 消息格式，XML或者JSON
*/
private String msgDataFormat;
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/config/WxMpConfiguration.java 0 → 100644
//package com.yongqi.xinrenli.config;
//
//
//import com.yongqi.xinrenli.handler.*;
//import lombok.AllArgsConstructor;
//import me.chanjar.weixin.common.redis.JedisWxRedisOps;
//import me.chanjar.weixin.mp.api.WxMpMessageRouter;
//import me.chanjar.weixin.mp.api.WxMpService;
//import me.chanjar.weixin.mp.api.impl.WxMpServiceImpl;
//import me.chanjar.weixin.mp.config.impl.WxMpDefaultConfigImpl;
//import me.chanjar.weixin.mp.config.impl.WxMpRedisConfigImpl;
//import org.springframework.boot.context.properties.EnableConfigurationProperties;
//import org.springframework.context.annotation.Bean;
//import org.springframework.context.annotation.Configuration;
//import redis.clients.jedis.JedisPool;
//import redis.clients.jedis.JedisPoolConfig;
//
//import java.util.List;
//import java.util.stream.Collectors;
//
//import static me.chanjar.weixin.common.api.WxConsts.EventType;
//import static me.chanjar.weixin.common.api.WxConsts.EventType.SUBSCRIBE;
//import static me.chanjar.weixin.common.api.WxConsts.EventType.UNSUBSCRIBE;
//import static me.chanjar.weixin.common.api.WxConsts.XmlMsgType;
//import static me.chanjar.weixin.common.api.WxConsts.XmlMsgType.EVENT;
//import static me.chanjar.weixin.mp.constant.WxMpEventConstants.CustomerService.*;
//import static me.chanjar.weixin.mp.constant.WxMpEventConstants.POI_CHECK_NOTIFY;
//
///**
// * wechat mp configuration
// *
// * @author <a href="https://github.com/binarywang">Binary Wang</a>
// */
//@AllArgsConstructor
//@Configuration
//@EnableConfigurationProperties(WxMpProperties.class)
//public class WxMpConfiguration {
// private final LogHandler logHandler;
// private final NullHandler nullHandler;
// private final KfSessionHandler kfSessionHandler;
// private final StoreCheckNotifyHandler storeCheckNotifyHandler;
// private final LocationHandler locationHandler;
// private final MenuHandler menuHandler;
// private final MsgHandler msgHandler;
// private final UnsubscribeHandler unsubscribeHandler;
// private final SubscribeHandler subscribeHandler;
// private final ScanHandler scanHandler;
// private final WxMpProperties properties;
//
// @Bean
// public WxMpService wxMpService() {
// // 代码里 getConfigs()处报错的同学，请注意仔细阅读项目说明，你的IDE需要引入lombok插件！！！！
// final List<WxMpProperties.MpConfig> configs = this.properties.getConfigs();
// if (configs == null) {
// throw new RuntimeException("大哥，拜托先看下项目首页的说明（readme文件），添加下相关配置，注意别配错了！");
// }
//
// WxMpService service = new WxMpServiceImpl();
// service.setMultiConfigStorages(configs
// .stream().map(a -> {
// WxMpDefaultConfigImpl configStorage;
// if (this.properties.isUseRedis()) {
// final WxMpProperties.RedisConfig redisConfig = this.properties.getRedisConfig();
// JedisPoolConfig poolConfig = new JedisPoolConfig();
// JedisPool jedisPool = new JedisPool(poolConfig, redisConfig.getHost(), redisConfig.getPort(),
// redisConfig.getTimeout(), redisConfig.getPassword());
// configStorage = new WxMpRedisConfigImpl(new JedisWxRedisOps(jedisPool), a.getAppId());
// } else {
// configStorage = new WxMpDefaultConfigImpl();
// }
//
// configStorage.setAppId(a.getAppId());
// configStorage.setSecret(a.getSecret());
// configStorage.setToken(a.getToken());
// configStorage.setAesKey(a.getAesKey());
// return configStorage;
// }).collect(Collectors.toMap(WxMpDefaultConfigImpl::getAppId, a -> a, (o, n) -> o)));
// return service;
// }
//
// @Bean
// public WxMpMessageRouter messageRouter(WxMpService wxMpService) {
// final WxMpMessageRouter newRouter = new WxMpMessageRouter(wxMpService);
//
// // 记录所有事件的日志 （异步执行）
// newRouter.rule().handler(this.logHandler).next();
//
// // 接收客服会话管理事件
// newRouter.rule().async(false).msgType(EVENT).event(KF_CREATE_SESSION)
// .handler(this.kfSessionHandler).end();
// newRouter.rule().async(false).msgType(EVENT).event(KF_CLOSE_SESSION)
// .handler(this.kfSessionHandler).end();
// newRouter.rule().async(false).msgType(EVENT).event(KF_SWITCH_SESSION)
// .handler(this.kfSessionHandler).end();
//
// // 门店审核事件
// newRouter.rule().async(false).msgType(EVENT).event(POI_CHECK_NOTIFY).handler(this.storeCheckNotifyHandler).end();
//
// // 自定义菜单事件
// newRouter.rule().async(false).msgType(EVENT).event(EventType.CLICK).handler(this.menuHandler).end();
//
// // 点击菜单连接事件
// newRouter.rule().async(false).msgType(EVENT).event(EventType.VIEW).handler(this.nullHandler).end();
//
// // 关注事件
// newRouter.rule().async(false).msgType(EVENT).event(SUBSCRIBE).handler(this.subscribeHandler).end();
//
// // 取消关注事件
// newRouter.rule().async(false).msgType(EVENT).event(UNSUBSCRIBE).handler(this.unsubscribeHandler).end();
//
// // 上报地理位置事件
// newRouter.rule().async(false).msgType(EVENT).event(EventType.LOCATION).handler(this.locationHandler).end();
//
// // 接收地理位置消息
// newRouter.rule().async(false).msgType(XmlMsgType.LOCATION).handler(this.locationHandler).end();
//
// // 扫码事件
// newRouter.rule().async(false).msgType(EVENT).event(EventType.SCAN).handler(this.scanHandler).end();
//
// // 默认
// newRouter.rule().async(false).handler(this.msgHandler).end();
//
// return newRouter;
// }
//
//}
xinrenli/src/main/java/com/yongqi/xinrenli/config/WxMpProperties.java 0 → 100644
//package com.yongqi.xinrenli.config;
//
//import com.yongqi.xinrenli.utils.JsonUtils;
//import lombok.Data;
//import org.springframework.boot.context.properties.ConfigurationProperties;
//
//import java.util.List;
//
///**
// * wechat mp properties
// *
// * @author <a href="https://github.com/binarywang">Binary Wang</a>
// */
//@Data
//@ConfigurationProperties(prefix = "wx.mp")
//public class WxMpProperties {
// /**
// * 是否使用redis存储access token
// */
// private boolean useRedis;
//
// /**
// * redis 配置
// */
// private RedisConfig redisConfig;
//
// @Data
// public static class RedisConfig {
// /**
// * redis服务器 主机地址
// */
// private String host;
//
// /**
// * redis服务器 端口号
// */
// private Integer port;
//
// /**
// * redis服务器 密码
// */
// private String password;
//
// /**
// * redis 服务连接超时时间
// */
// private Integer timeout;
// }
//
// /**
// * 多个公众号配置信息
// */
// private List<MpConfig> configs;
//
// @Data
// public static class MpConfig {
// /**
// * 设置微信公众号的appid
// */
// private String appId;
//
// /**
// * 设置微信公众号的app secret
// */
// private String secret;
//
// /**
// * 设置微信公众号的token
// */
// private String token;
//
// /**
// * 设置微信公众号的EncodingAESKey
// */
// private String aesKey;
// }
//
// @Override
// public String toString() {
// return JsonUtils.toJson(this);
// }
//}
xinrenli/src/main/java/com/yongqi/xinrenli/config/WxPayConfiguration.java 0 → 100644
package com.yongqi.xinrenli.config;
import com.github.binarywang.wxpay.config.WxPayConfig;
import com.github.binarywang.wxpay.service.WxPayService;
import com.github.binarywang.wxpay.service.impl.WxPayServiceImpl;
import lombok.AllArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* @author Binary Wang
*/
@Configuration
@ConditionalOnClass(WxPayService.class)
@EnableConfigurationProperties(WxPayProperties.class)
@AllArgsConstructor
public class WxPayConfiguration {
private WxPayProperties properties;
@Bean
@ConditionalOnMissingBean
public WxPayService wxService() {
WxPayConfig payConfig = new WxPayConfig();
payConfig.setAppId(StringUtils.trimToNull(this.properties.getAppId()));
payConfig.setMchId(StringUtils.trimToNull(this.properties.getMchId()));
payConfig.setMchKey(StringUtils.trimToNull(this.properties.getMchKey()));
payConfig.setSubAppId(StringUtils.trimToNull(this.properties.getSubAppId()));
payConfig.setSubMchId(StringUtils.trimToNull(this.properties.getSubMchId()));
payConfig.setKeyPath(StringUtils.trimToNull(this.properties.getKeyPath()));
// 可以指定是否使用沙箱环境
payConfig.setUseSandboxEnv(false);
WxPayService wxPayService = new WxPayServiceImpl();
wxPayService.setConfig(payConfig);
return wxPayService;
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/config/WxPayProperties.java 0 → 100644
package com.yongqi.xinrenli.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
/**
* wxpay pay properties.
*
* @author Binary Wang
*/
@Data
@ConfigurationProperties(prefix = "wx.pay")
public class WxPayProperties {
/**
* 设置微信公众号或者小程序等的appid
*/
private String appId;
/**
* 微信支付商户号
*/
private String mchId;
/**
* 微信支付商户密钥
*/
private String mchKey;
/**
* 服务商模式下的子商户公众账号ID，普通模式请不要配置，请在配置文件中将对应项删除
*/
private String subAppId;
/**
* 服务商模式下的子商户号，普通模式请不要配置，最好是请在配置文件中将对应项删除
*/
private String subMchId;
/**
* apiclient_cert.p12文件的绝对路径，或者如果放在项目中，请以classpath:开头指定
*/
private String keyPath;
}
xinrenli/src/main/java/com/yongqi/xinrenli/controller/DbArticleController.java 0 → 100644
package com.yongqi.xinrenli.controller;
import java.util.List;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;
import lombok.RequiredArgsConstructor;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.*;
import cn.dev33.satoken.annotation.SaCheckPermission;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.ruoyi.common.annotation.RepeatSubmit;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import com.ruoyi.common.core.validate.QueryGroup;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.yongqi.xinrenli.domain.vo.DbArticleVo;
import com.yongqi.xinrenli.domain.bo.DbArticleBo;
import com.yongqi.xinrenli.service.IDbArticleService;
import com.ruoyi.common.core.page.TableDataInfo;
/**
* 文章
*
* @author zyf
* @date 2023-03-09
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/xinrenli/article")
public class DbArticleController extends BaseController {
private final IDbArticleService iDbArticleService;
/**
* 查询文章列表
*/
@SaCheckPermission("xinrenli:article:list")
@GetMapping("/list")
public TableDataInfo<DbArticleVo> list(DbArticleBo bo, PageQuery pageQuery) {
return iDbArticleService.queryPageList(bo, pageQuery);
}
/**
* 导出文章列表
*/
@SaCheckPermission("xinrenli:article:export")
@Log(title = "文章", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(DbArticleBo bo, HttpServletResponse response) {
List<DbArticleVo> list = iDbArticleService.queryList(bo);
ExcelUtil.exportExcel(list, "文章", DbArticleVo.class, response);
}
/**
* 获取文章详细信息
*
* @param id 主键
*/
@SaCheckPermission("xinrenli:article:query")
@GetMapping("/{id}")
public R<DbArticleVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(iDbArticleService.queryById(id));
}
/**
* 新增文章
*/
@SaCheckPermission("xinrenli:article:add")
@Log(title = "文章", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody DbArticleBo bo) {
return toAjax(iDbArticleService.insertByBo(bo));
}
/**
* 修改文章
*/
@SaCheckPermission("xinrenli:article:edit")
@Log(title = "文章", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody DbArticleBo bo) {
return toAjax(iDbArticleService.updateByBo(bo));
}
/**
* 删除文章
*
* @param ids 主键串
*/
@SaCheckPermission("xinrenli:article:remove")
@Log(title = "文章", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(iDbArticleService.deleteWithValidByIds(Arrays.asList(ids), true));
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/controller/DbCouponController.java 0 → 100644
package com.yongqi.xinrenli.controller;
import java.util.List;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;
import lombok.RequiredArgsConstructor;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.*;
import cn.dev33.satoken.annotation.SaCheckPermission;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.ruoyi.common.annotation.RepeatSubmit;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import com.ruoyi.common.core.validate.QueryGroup;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.yongqi.xinrenli.domain.vo.DbCouponVo;
import com.yongqi.xinrenli.domain.bo.DbCouponBo;
import com.yongqi.xinrenli.service.IDbCouponService;
import com.ruoyi.common.core.page.TableDataInfo;
/**
* 优惠卷
*
* @author zyf
* @date 2023-03-09
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/xinrenli/coupon")
public class DbCouponController extends BaseController {
private final IDbCouponService iDbCouponService;
/**
* 查询优惠卷列表
*/
@SaCheckPermission("xinrenli:coupon:list")
@GetMapping("/list")
public TableDataInfo<DbCouponVo> list(DbCouponBo bo, PageQuery pageQuery) {
return iDbCouponService.queryPageList(bo, pageQuery);
}
/**
* 导出优惠卷列表
*/
@SaCheckPermission("xinrenli:coupon:export")
@Log(title = "优惠卷", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(DbCouponBo bo, HttpServletResponse response) {
List<DbCouponVo> list = iDbCouponService.queryList(bo);
ExcelUtil.exportExcel(list, "优惠卷", DbCouponVo.class, response);
}
/**
* 获取优惠卷详细信息
*
* @param id 主键
*/
@SaCheckPermission("xinrenli:coupon:query")
@GetMapping("/{id}")
public R<DbCouponVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(iDbCouponService.queryById(id));
}
/**
* 新增优惠卷
*/
@SaCheckPermission("xinrenli:coupon:add")
@Log(title = "优惠卷", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody DbCouponBo bo) {
return toAjax(iDbCouponService.insertByBo(bo));
}
/**
* 修改优惠卷
*/
@SaCheckPermission("xinrenli:coupon:edit")
@Log(title = "优惠卷", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody DbCouponBo bo) {
return toAjax(iDbCouponService.updateByBo(bo));
}
/**
* 删除优惠卷
*
* @param ids 主键串
*/
@SaCheckPermission("xinrenli:coupon:remove")
@Log(title = "优惠卷", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(iDbCouponService.deleteWithValidByIds(Arrays.asList(ids), true));
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/controller/DbFileController.java 0 → 100644
package com.yongqi.xinrenli.controller;
import java.util.List;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;
import lombok.RequiredArgsConstructor;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.*;
import cn.dev33.satoken.annotation.SaCheckPermission;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.ruoyi.common.annotation.RepeatSubmit;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import com.ruoyi.common.core.validate.QueryGroup;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.yongqi.xinrenli.domain.vo.DbFileVo;
import com.yongqi.xinrenli.domain.bo.DbFileBo;
import com.yongqi.xinrenli.service.IDbFileService;
import com.ruoyi.common.core.page.TableDataInfo;
/**
* 文件
*
* @author zyf
* @date 2023-03-09
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/xinrenli/file")
public class DbFileController extends BaseController {
private final IDbFileService iDbFileService;
/**
* 查询文件列表
*/
@SaCheckPermission("xinrenli:file:list")
@GetMapping("/list")
public TableDataInfo<DbFileVo> list(DbFileBo bo, PageQuery pageQuery) {
return iDbFileService.queryPageList(bo, pageQuery);
}
/**
* 导出文件列表
*/
@SaCheckPermission("xinrenli:file:export")
@Log(title = "文件", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(DbFileBo bo, HttpServletResponse response) {
List<DbFileVo> list = iDbFileService.queryList(bo);
ExcelUtil.exportExcel(list, "文件", DbFileVo.class, response);
}
/**
* 获取文件详细信息
*
* @param id 主键
*/
@SaCheckPermission("xinrenli:file:query")
@GetMapping("/{id}")
public R<DbFileVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(iDbFileService.queryById(id));
}
/**
* 新增文件
*/
@SaCheckPermission("xinrenli:file:add")
@Log(title = "文件", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody DbFileBo bo) {
return toAjax(iDbFileService.insertByBo(bo));
}
/**
* 修改文件
*/
@SaCheckPermission("xinrenli:file:edit")
@Log(title = "文件", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody DbFileBo bo) {
return toAjax(iDbFileService.updateByBo(bo));
}
/**
* 删除文件
*
* @param ids 主键串
*/
@SaCheckPermission("xinrenli:file:remove")
@Log(title = "文件", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(iDbFileService.deleteWithValidByIds(Arrays.asList(ids), true));
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/controller/DbInviterController.java 0 → 100644
package com.yongqi.xinrenli.controller;
import java.util.List;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;
import lombok.RequiredArgsConstructor;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.*;
import cn.dev33.satoken.annotation.SaCheckPermission;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.ruoyi.common.annotation.RepeatSubmit;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import com.ruoyi.common.core.validate.QueryGroup;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.yongqi.xinrenli.domain.vo.DbInviterVo;
import com.yongqi.xinrenli.domain.bo.DbInviterBo;
import com.yongqi.xinrenli.service.IDbInviterService;
import com.ruoyi.common.core.page.TableDataInfo;
/**
* 邀请
*
* @author zyf
* @date 2023-03-09
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/xinrenli/Inviter")
public class DbInviterController extends BaseController {
private final IDbInviterService iDbInviterService;
/**
* 查询邀请列表
*/
@SaCheckPermission("xinrenli:Inviter:list")
@GetMapping("/list")
public TableDataInfo<DbInviterVo> list(DbInviterBo bo, PageQuery pageQuery) {
return iDbInviterService.queryPageList(bo, pageQuery);
}
/**
* 导出邀请列表
*/
@SaCheckPermission("xinrenli:Inviter:export")
@Log(title = "邀请", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(DbInviterBo bo, HttpServletResponse response) {
List<DbInviterVo> list = iDbInviterService.queryList(bo);
ExcelUtil.exportExcel(list, "邀请", DbInviterVo.class, response);
}
/**
* 获取邀请详细信息
*
* @param id 主键
*/
@SaCheckPermission("xinrenli:Inviter:query")
@GetMapping("/{id}")
public R<DbInviterVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(iDbInviterService.queryById(id));
}
/**
* 新增邀请
*/
@SaCheckPermission("xinrenli:Inviter:add")
@Log(title = "邀请", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody DbInviterBo bo) {
return toAjax(iDbInviterService.insertByBo(bo));
}
/**
* 修改邀请
*/
@SaCheckPermission("xinrenli:Inviter:edit")
@Log(title = "邀请", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody DbInviterBo bo) {
return toAjax(iDbInviterService.updateByBo(bo));
}
/**
* 删除邀请
*
* @param ids 主键串
*/
@SaCheckPermission("xinrenli:Inviter:remove")
@Log(title = "邀请", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(iDbInviterService.deleteWithValidByIds(Arrays.asList(ids), true));
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/controller/DbOrderController.java 0 → 100644
package com.yongqi.xinrenli.controller;
import java.util.List;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;
import lombok.RequiredArgsConstructor;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.*;
import cn.dev33.satoken.annotation.SaCheckPermission;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.ruoyi.common.annotation.RepeatSubmit;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import com.ruoyi.common.core.validate.QueryGroup;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.yongqi.xinrenli.domain.vo.DbOrderVo;
import com.yongqi.xinrenli.domain.bo.DbOrderBo;
import com.yongqi.xinrenli.service.IDbOrderService;
import com.ruoyi.common.core.page.TableDataInfo;
/**
* 订单
*
* @author zyf
* @date 2023-03-09
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/xinrenli/order")
public class DbOrderController extends BaseController {
private final IDbOrderService iDbOrderService;
/**
* 查询订单列表
*/
@SaCheckPermission("xinrenli:order:list")
@GetMapping("/list")
public TableDataInfo<DbOrderVo> list(DbOrderBo bo, PageQuery pageQuery) {
return iDbOrderService.queryPageList(bo, pageQuery);
}
/**
* 导出订单列表
*/
@SaCheckPermission("xinrenli:order:export")
@Log(title = "订单", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(DbOrderBo bo, HttpServletResponse response) {
List<DbOrderVo> list = iDbOrderService.queryList(bo);
ExcelUtil.exportExcel(list, "订单", DbOrderVo.class, response);
}
/**
* 获取订单详细信息
*
* @param id 主键
*/
@SaCheckPermission("xinrenli:order:query")
@GetMapping("/{id}")
public R<DbOrderVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(iDbOrderService.queryById(id));
}
/**
* 新增订单
*/
@SaCheckPermission("xinrenli:order:add")
@Log(title = "订单", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody DbOrderBo bo) {
return toAjax(iDbOrderService.insertByBo(bo));
}
/**
* 修改订单
*/
@SaCheckPermission("xinrenli:order:edit")
@Log(title = "订单", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody DbOrderBo bo) {
return toAjax(iDbOrderService.updateByBo(bo));
}
/**
* 删除订单
*
* @param ids 主键串
*/
@SaCheckPermission("xinrenli:order:remove")
@Log(title = "订单", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(iDbOrderService.deleteWithValidByIds(Arrays.asList(ids), true));
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/controller/DbUserCommentController.java 0 → 100644
package com.yongqi.xinrenli.controller;
import java.util.List;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;
import lombok.RequiredArgsConstructor;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.*;
import cn.dev33.satoken.annotation.SaCheckPermission;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.ruoyi.common.annotation.RepeatSubmit;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import com.ruoyi.common.core.validate.QueryGroup;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.yongqi.xinrenli.domain.vo.DbUserCommentVo;
import com.yongqi.xinrenli.domain.bo.DbUserCommentBo;
import com.yongqi.xinrenli.service.IDbUserCommentService;
import com.ruoyi.common.core.page.TableDataInfo;
/**
* 用户评论
*
* @author zyf
* @date 2023-03-09
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/xinrenli/userComment")
public class DbUserCommentController extends BaseController {
private final IDbUserCommentService iDbUserCommentService;
/**
* 查询用户评论列表
*/
@SaCheckPermission("xinrenli:userComment:list")
@GetMapping("/list")
public TableDataInfo<DbUserCommentVo> list(DbUserCommentBo bo, PageQuery pageQuery) {
return iDbUserCommentService.queryPageList(bo, pageQuery);
}
/**
* 导出用户评论列表
*/
@SaCheckPermission("xinrenli:userComment:export")
@Log(title = "用户评论", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(DbUserCommentBo bo, HttpServletResponse response) {
List<DbUserCommentVo> list = iDbUserCommentService.queryList(bo);
ExcelUtil.exportExcel(list, "用户评论", DbUserCommentVo.class, response);
}
/**
* 获取用户评论详细信息
*
* @param id 主键
*/
@SaCheckPermission("xinrenli:userComment:query")
@GetMapping("/{id}")
public R<DbUserCommentVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(iDbUserCommentService.queryById(id));
}
/**
* 新增用户评论
*/
@SaCheckPermission("xinrenli:userComment:add")
@Log(title = "用户评论", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody DbUserCommentBo bo) {
return toAjax(iDbUserCommentService.insertByBo(bo));
}
/**
* 修改用户评论
*/
@SaCheckPermission("xinrenli:userComment:edit")
@Log(title = "用户评论", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody DbUserCommentBo bo) {
return toAjax(iDbUserCommentService.updateByBo(bo));
}
/**
* 删除用户评论
*
* @param ids 主键串
*/
@SaCheckPermission("xinrenli:userComment:remove")
@Log(title = "用户评论", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(iDbUserCommentService.deleteWithValidByIds(Arrays.asList(ids), true));
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/controller/DbUserCouponController.java 0 → 100644
package com.yongqi.xinrenli.controller;
import java.util.List;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;
import lombok.RequiredArgsConstructor;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.*;
import cn.dev33.satoken.annotation.SaCheckPermission;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.ruoyi.common.annotation.RepeatSubmit;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import com.ruoyi.common.core.validate.QueryGroup;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.yongqi.xinrenli.domain.vo.DbUserCouponVo;
import com.yongqi.xinrenli.domain.bo.DbUserCouponBo;
import com.yongqi.xinrenli.service.IDbUserCouponService;
import com.ruoyi.common.core.page.TableDataInfo;
/**
* 用户优惠券关联
*
* @author zyf
* @date 2023-03-09
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/xinrenli/userCoupon")
public class DbUserCouponController extends BaseController {
private final IDbUserCouponService iDbUserCouponService;
/**
* 查询用户优惠券关联列表
*/
@SaCheckPermission("xinrenli:userCoupon:list")
@GetMapping("/list")
public TableDataInfo<DbUserCouponVo> list(DbUserCouponBo bo, PageQuery pageQuery) {
return iDbUserCouponService.queryPageList(bo, pageQuery);
}
/**
* 导出用户优惠券关联列表
*/
@SaCheckPermission("xinrenli:userCoupon:export")
@Log(title = "用户优惠券关联", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(DbUserCouponBo bo, HttpServletResponse response) {
List<DbUserCouponVo> list = iDbUserCouponService.queryList(bo);
ExcelUtil.exportExcel(list, "用户优惠券关联", DbUserCouponVo.class, response);
}
/**
* 获取用户优惠券关联详细信息
*
* @param id 主键
*/
@SaCheckPermission("xinrenli:userCoupon:query")
@GetMapping("/{id}")
public R<DbUserCouponVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(iDbUserCouponService.queryById(id));
}
/**
* 新增用户优惠券关联
*/
@SaCheckPermission("xinrenli:userCoupon:add")
@Log(title = "用户优惠券关联", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody DbUserCouponBo bo) {
return toAjax(iDbUserCouponService.insertByBo(bo));
}
/**
* 修改用户优惠券关联
*/
@SaCheckPermission("xinrenli:userCoupon:edit")
@Log(title = "用户优惠券关联", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody DbUserCouponBo bo) {
return toAjax(iDbUserCouponService.updateByBo(bo));
}
/**
* 删除用户优惠券关联
*
* @param ids 主键串
*/
@SaCheckPermission("xinrenli:userCoupon:remove")
@Log(title = "用户优惠券关联", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(iDbUserCouponService.deleteWithValidByIds(Arrays.asList(ids), true));
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/controller/DbUserDiscountController.java 0 → 100644
package com.yongqi.xinrenli.controller;
import java.util.List;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;
import lombok.RequiredArgsConstructor;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.*;
import cn.dev33.satoken.annotation.SaCheckPermission;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.ruoyi.common.annotation.RepeatSubmit;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import com.ruoyi.common.core.validate.QueryGroup;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.yongqi.xinrenli.domain.vo.DbUserDiscountVo;
import com.yongqi.xinrenli.domain.bo.DbUserDiscountBo;
import com.yongqi.xinrenli.service.IDbUserDiscountService;
import com.ruoyi.common.core.page.TableDataInfo;
/**
* 用户折扣
*
* @author zyf
* @date 2023-03-09
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/xinrenli/userDiscount")
public class DbUserDiscountController extends BaseController {
private final IDbUserDiscountService iDbUserDiscountService;
/**
* 查询用户折扣列表
*/
@SaCheckPermission("xinrenli:userDiscount:list")
@GetMapping("/list")
public TableDataInfo<DbUserDiscountVo> list(DbUserDiscountBo bo, PageQuery pageQuery) {
return iDbUserDiscountService.queryPageList(bo, pageQuery);
}
/**
* 导出用户折扣列表
*/
@SaCheckPermission("xinrenli:userDiscount:export")
@Log(title = "用户折扣", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(DbUserDiscountBo bo, HttpServletResponse response) {
List<DbUserDiscountVo> list = iDbUserDiscountService.queryList(bo);
ExcelUtil.exportExcel(list, "用户折扣", DbUserDiscountVo.class, response);
}
/**
* 获取用户折扣详细信息
*
* @param id 主键
*/
@SaCheckPermission("xinrenli:userDiscount:query")
@GetMapping("/{id}")
public R<DbUserDiscountVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(iDbUserDiscountService.queryById(id));
}
/**
* 新增用户折扣
*/
@SaCheckPermission("xinrenli:userDiscount:add")
@Log(title = "用户折扣", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody DbUserDiscountBo bo) {
return toAjax(iDbUserDiscountService.insertByBo(bo));
}
/**
* 修改用户折扣
*/
@SaCheckPermission("xinrenli:userDiscount:edit")
@Log(title = "用户折扣", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody DbUserDiscountBo bo) {
return toAjax(iDbUserDiscountService.updateByBo(bo));
}
/**
* 删除用户折扣
*
* @param ids 主键串
*/
@SaCheckPermission("xinrenli:userDiscount:remove")
@Log(title = "用户折扣", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(iDbUserDiscountService.deleteWithValidByIds(Arrays.asList(ids), true));
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/controller/DbUserFeedbackController.java 0 → 100644
package com.yongqi.xinrenli.controller;
import java.util.List;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;
import lombok.RequiredArgsConstructor;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.*;
import cn.dev33.satoken.annotation.SaCheckPermission;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.ruoyi.common.annotation.RepeatSubmit;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import com.ruoyi.common.core.validate.QueryGroup;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.yongqi.xinrenli.domain.vo.DbUserFeedbackVo;
import com.yongqi.xinrenli.domain.bo.DbUserFeedbackBo;
import com.yongqi.xinrenli.service.IDbUserFeedbackService;
import com.ruoyi.common.core.page.TableDataInfo;
/**
* 用户反馈
*
* @author zyf
* @date 2023-03-09
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/xinrenli/userFeedback")
public class DbUserFeedbackController extends BaseController {
private final IDbUserFeedbackService iDbUserFeedbackService;
/**
* 查询用户反馈列表
*/
@SaCheckPermission("xinrenli:userFeedback:list")
@GetMapping("/list")
public TableDataInfo<DbUserFeedbackVo> list(DbUserFeedbackBo bo, PageQuery pageQuery) {
return iDbUserFeedbackService.queryPageList(bo, pageQuery);
}
/**
* 导出用户反馈列表
*/
@SaCheckPermission("xinrenli:userFeedback:export")
@Log(title = "用户反馈", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(DbUserFeedbackBo bo, HttpServletResponse response) {
List<DbUserFeedbackVo> list = iDbUserFeedbackService.queryList(bo);
ExcelUtil.exportExcel(list, "用户反馈", DbUserFeedbackVo.class, response);
}
/**
* 获取用户反馈详细信息
*
* @param id 主键
*/
@SaCheckPermission("xinrenli:userFeedback:query")
@GetMapping("/{id}")
public R<DbUserFeedbackVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(iDbUserFeedbackService.queryById(id));
}
/**
* 新增用户反馈
*/
@SaCheckPermission("xinrenli:userFeedback:add")
@Log(title = "用户反馈", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody DbUserFeedbackBo bo) {
return toAjax(iDbUserFeedbackService.insertByBo(bo));
}
/**
* 修改用户反馈
*/
@SaCheckPermission("xinrenli:userFeedback:edit")
@Log(title = "用户反馈", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody DbUserFeedbackBo bo) {
return toAjax(iDbUserFeedbackService.updateByBo(bo));
}
/**
* 删除用户反馈
*
* @param ids 主键串
*/
@SaCheckPermission("xinrenli:userFeedback:remove")
@Log(title = "用户反馈", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(iDbUserFeedbackService.deleteWithValidByIds(Arrays.asList(ids), true));
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/controller/DbWxUserController.java 0 → 100644
package com.yongqi.xinrenli.controller;
import java.util.List;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;
import lombok.RequiredArgsConstructor;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.*;
import cn.dev33.satoken.annotation.SaCheckPermission;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.ruoyi.common.annotation.RepeatSubmit;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import com.ruoyi.common.core.validate.QueryGroup;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.yongqi.xinrenli.domain.vo.DbWxUserVo;
import com.yongqi.xinrenli.domain.bo.DbWxUserBo;
import com.yongqi.xinrenli.service.IDbWxUserService;
import com.ruoyi.common.core.page.TableDataInfo;
/**
* 微信用户
*
* @author zyf
* @date 2023-03-09
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/xinrenli/wxUser")
public class DbWxUserController extends BaseController {
private final IDbWxUserService iDbWxUserService;
/**
* 查询微信用户列表
*/
@SaCheckPermission("xinrenli:wxUser:list")
@GetMapping("/list")
public TableDataInfo<DbWxUserVo> list(DbWxUserBo bo, PageQuery pageQuery) {
return iDbWxUserService.queryPageList(bo, pageQuery);
}
/**
* 导出微信用户列表
*/
@SaCheckPermission("xinrenli:wxUser:export")
@Log(title = "微信用户", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(DbWxUserBo bo, HttpServletResponse response) {
List<DbWxUserVo> list = iDbWxUserService.queryList(bo);
ExcelUtil.exportExcel(list, "微信用户", DbWxUserVo.class, response);
}
/**
* 获取微信用户详细信息
*
* @param id 主键
*/
@SaCheckPermission("xinrenli:wxUser:query")
@GetMapping("/{id}")
public R<DbWxUserVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(iDbWxUserService.queryById(id));
}
/**
* 新增微信用户
*/
@SaCheckPermission("xinrenli:wxUser:add")
@Log(title = "微信用户", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody DbWxUserBo bo) {
return toAjax(iDbWxUserService.insertByBo(bo));
}
/**
* 修改微信用户
*/
@SaCheckPermission("xinrenli:wxUser:edit")
@Log(title = "微信用户", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody DbWxUserBo bo) {
return toAjax(iDbWxUserService.updateByBo(bo));
}
/**
* 删除微信用户
*
* @param ids 主键串
*/
@SaCheckPermission("xinrenli:wxUser:remove")
@Log(title = "微信用户", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(iDbWxUserService.deleteWithValidByIds(Arrays.asList(ids), true));
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/Article.java deleted 100644 → 0
package com.yongqi.xinrenli.domain;
import com.baomidou.mybatisplus.annotation.*;
import com.ruoyi.common.core.domain.BaseEntity;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.util.Date;
/**
* <p>
* 文章表
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("by_article")
@Schema(name="Article对象", description="文章表")
public class Article implements Serializable {
private static final long serialVersionUID = 1L;
@Schema(name = "自增id")
@TableId(value = "id", type = IdType.AUTO)
private Long id;
@Schema(name = "用户id")
@TableField("user_id")
private String userId;
@Schema(name = "动态标题")
@TableField("title")
private String title;
@Schema(name = "动态内容")
@TableField("content")
private String content;
@Schema(name = "添加图片地址")
@TableField("image_src")
private String imageSrc;
@Schema(name = "创建人")
@TableField("create_user")
private String createUser;
@Schema(name = "创建时间")
@TableField("create_time")
private Date createTime;
@Schema(name = "修改人")
@TableField("update_user")
private String updateUser;
@Schema(name = "修改时间")
@TableField("update_time")
private Date updateTime;
@Schema(name = "删除状态 0：未删除 1：删除")
@TableField("delete_status")
@TableLogic(value = "0",delval = "1")
private Integer delStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/Coupon.java deleted 100644 → 0
package com.yongqi.xinrenli.domain;
import com.baomidou.mybatisplus.annotation.*;
import com.ruoyi.common.core.domain.BaseEntity;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.util.Date;
/**
* <p>
* 优惠卷表
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("by_coupon")
@Schema(name="Coupon对象", description="优惠卷表")
public class Coupon implements Serializable {
private static final long serialVersionUID = 1L;
@Schema(name = "自增id")
@TableId(value = "id", type = IdType.AUTO)
private Long id;
@TableField("user_id")
@Schema(name = "用户id")
private Integer userId;
@Schema(name = "券类型")
@TableField("coupon_type")
private Integer couponType;
@Schema(name = "优惠内容：满减")
@TableField("full_subtraction")
private Integer fullSubtraction;
@Schema(name = "使用门槛： 最低消费")
@TableField("min_used")
private Integer minUsed;
@Schema(name = "生效时间")
@TableField("effective_time")
private Date effectiveTime;
@Schema(name = "失效时间")
@TableField("failure_time")
private Date failureTime;
@Schema(name = "创建人")
@TableField("create_user")
private String createUser;
@Schema(name = "创建时间")
@TableField("create_time")
private Date createTime;
@Schema(name = "修改人")
@TableField("update_user")
private String updateUser;
@Schema(name = "修改时间")
@TableField("update_time")
private Date updateTime;
@Schema(name = "删除状态 0：未删除 1：删除")
@TableField("delete_status")
@TableLogic(value = "0",delval = "1")
private Integer delStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/DbArticle.java 0 → 100644
package com.yongqi.xinrenli.domain;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
import java.util.Date;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.ruoyi.common.core.domain.BaseEntity;
/**
* 文章对象 db_article
*
* @author zyf
* @date 2023-03-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("db_article")
public class DbArticle extends BaseEntity {
private static final long serialVersionUID = 1L;
/**
* 自增id
*/
@TableId(value = "id")
private Long id;
/**
* 动态标题
*/
private String title;
/**
* 动态内容
*/
private String content;
/**
* 创建人
*/
private String createUser;
/**
* 修改人
*/
private String modifyUser;
/**
* 修改时间
*/
private Date modifyTime;
/**
* 删除状态
*/
private Integer deleteStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/DbCoupon.java 0 → 100644
package com.yongqi.xinrenli.domain;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
import java.util.Date;
import java.math.BigDecimal;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.ruoyi.common.core.domain.BaseEntity;
/**
* 优惠卷对象 db_coupon
*
* @author zyf
* @date 2023-03-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("db_coupon")
public class DbCoupon extends BaseEntity {
private static final long serialVersionUID = 1L;
/**
* 自增id
*/
@TableId(value = "id")
private Long id;
/**
* 券类型
*/
private String couponType;
/**
* 优惠内容
*/
private String fullSubtraction;
/**
* 使用门槛：最低消费
*/
private BigDecimal minUsed;
/**
* 生效时间
*/
private Date effectiveTime;
/**
* 失效时间
*/
private Date failureTime;
/**
* 创建人
*/
private String createUser;
/**
* 修改人
*/
private String modifyUser;
/**
* 修改时间
*/
private Date modifyTime;
/**
* 删除状态
*/
private Integer deleteStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/DbFile.java 0 → 100644
package com.yongqi.xinrenli.domain;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
import java.util.Date;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.ruoyi.common.core.domain.BaseEntity;
/**
* 文件对象 db_file
*
* @author zyf
* @date 2023-03-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("db_file")
public class DbFile extends BaseEntity {
private static final long serialVersionUID = 1L;
/**
* 主键id
*/
@TableId(value = "id")
private Long id;
/**
* 业务类型
*/
private String serviceType;
/**
* 文件地址
*/
private String url;
/**
* 文件类型
*/
private String fileType;
/**
* 排序
*/
private Long sort;
/**
* 删除状态 0正常 1删除
*/
private Integer deleteStatus;
/**
* 创建人
*/
private String createName;
/**
* 修改时间
*/
private Date modifyTime;
/**
* 修改人
*/
private String modifyName;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/DbInviter.java 0 → 100644
package com.yongqi.xinrenli.domain;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
import java.util.Date;
import java.math.BigDecimal;
import com.ruoyi.common.core.domain.BaseEntity;
/**
* 邀请对象 db_Inviter
*
* @author zyf
* @date 2023-03-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("db_Inviter")
public class DbInviter extends BaseEntity {
private static final long serialVersionUID = 1L;
/**
* 主键id
*/
@TableId(value = "id")
private Long id;
/**
* 邀请人id
*/
private Long inviterId;
/**
* 邀请人名称
*/
private String inviterName;
/**
* 被邀请人id
*/
private Long inviteeId;
/**
* 被邀请人名称
*/
private String inviteeName;
/**
* 状态：是否已计入折扣
*/
private Integer status;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/DbOrder.java 0 → 100644
package com.yongqi.xinrenli.domain;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
import java.util.Date;
import java.math.BigDecimal;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.ruoyi.common.core.domain.BaseEntity;
/**
* 订单对象 db_order
*
* @author zyf
* @date 2023-03-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("db_order")
public class DbOrder extends BaseEntity {
private static final long serialVersionUID = 1L;
/**
* 自增id
*/
@TableId(value = "id")
private Long id;
/**
* 用户id
*/
private Long userId;
/**
* 标题
*/
private String title;
/**
* 联系人
*/
private String linkman;
/**
* 联系电话
*/
private String phone;
/**
* 维修时间
*/
private Date repairTime;
/**
* 维修地址
*/
private String repairAddress;
/**
* 预算金额
*/
private BigDecimal budget;
/**
* 备注说明
*/
private String remark;
/**
* 订单状态：0 已发布；1 已驳回；2 待支付；3 已接单；4 已完成；5 退款中；6 已退款
*/
private Integer status;
/**
* 创建人
*/
private String createUser;
/**
* 修改人
*/
private String modifyUser;
/**
* 修改时间
*/
private Date modifyTime;
/**
* 删除状态 0：未删除 1：删除
*/
private Integer deleteStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/DbUserComment.java 0 → 100644
package com.yongqi.xinrenli.domain;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
import java.util.Date;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.ruoyi.common.core.domain.BaseEntity;
/**
* 用户评论对象 db_user_comment
*
* @author zyf
* @date 2023-03-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("db_user_comment")
public class DbUserComment extends BaseEntity {
private static final long serialVersionUID = 1L;
/**
* id自增
*/
@TableId(value = "id")
private Long id;
/**
* 文章id
*/
private Long articleId;
/**
* 用户id
*/
private Long userId;
/**
* 用户评论内容
*/
private String content;
/**
* 创建人
*/
private String createUser;
/**
* 修改人
*/
private String modifyUser;
/**
* 修改时间
*/
private Date modifyTime;
/**
* 删除状态
*/
private Integer deleteStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/DbUserCoupon.java 0 → 100644
package com.yongqi.xinrenli.domain;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
import java.util.Date;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.ruoyi.common.core.domain.BaseEntity;
/**
* 用户优惠券关联对象 db_user_coupon
*
* @author zyf
* @date 2023-03-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("db_user_coupon")
public class DbUserCoupon extends BaseEntity {
private static final long serialVersionUID = 1L;
/**
* 主键id
*/
@TableId(value = "id")
private Long id;
/**
* 优惠券id
*/
private Long couponId;
/**
* 小程序用户id
*/
private Long userId;
/**
* 使用状态 0 未使用， 1已使用
*/
private Integer useStatus;
/**
* 修改时间
*/
private Date modifyTime;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/DbUserDiscount.java 0 → 100644
package com.yongqi.xinrenli.domain;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
import java.util.Date;
import java.math.BigDecimal;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.ruoyi.common.core.domain.BaseEntity;
/**
* 用户折扣对象 db_user_discount
*
* @author zyf
* @date 2023-03-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("db_user_discount")
public class DbUserDiscount extends BaseEntity {
private static final long serialVersionUID = 1L;
/**
* 主键id
*/
@TableId(value = "id")
private Long id;
/**
* 用户id
*/
private Long userId;
/**
* 折扣比例
*/
private BigDecimal discountRatio;
/**
* 是否使用：0未使用， 1已使用
*/
private Integer useStatus;
/**
* 使用时间
*/
private Date modifyTime;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/DbUserFeedback.java 0 → 100644
package com.yongqi.xinrenli.domain;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
import java.util.Date;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.ruoyi.common.core.domain.BaseEntity;
/**
* 用户反馈对象 db_user_feedback
*
* @author zyf
* @date 2023-03-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("db_user_feedback")
public class DbUserFeedback extends BaseEntity {
private static final long serialVersionUID = 1L;
/**
* 自增id
*/
@TableId(value = "id")
private Long id;
/**
* 用户id
*/
private Long userId;
/**
* 反馈标题
*/
private String title;
/**
* 反馈内容
*/
private String content;
/**
* 创建人
*/
private String createUser;
/**
* 修改人
*/
private String modifyUser;
/**
* 修改时间
*/
private Date modifyTime;
/**
* 删除状态
*/
private Integer deleteStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/DbWxUser.java 0 → 100644
package com.yongqi.xinrenli.domain;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
import java.util.Date;
import java.math.BigDecimal;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.ruoyi.common.core.domain.BaseEntity;
/**
* 微信用户对象 db_wx_user
*
* @author zyf
* @date 2023-03-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("db_wx_user")
public class DbWxUser extends BaseEntity {
private static final long serialVersionUID = 1L;
/**
* 主键标识
*/
@TableId(value = "id")
private Long id;
/**
* 微信用户的唯一标识
*/
private String openId;
/**
* 是否是团长：1：是，2：否
*/
private Integer headOrNot;
/**
* 用户昵称
*/
private String nickname;
/**
* 用户的性别，值为1时是男性，值为2时是女性，值为0时是未知
*/
private Integer sex;
/**
* 用户个人资料填写的省份
*/
private String province;
/**
* 普通用户个人资料填写的城市
*/
private String city;
/**
* 国家，如中国为CN
*/
private String country;
/**
* 用户头像
*/
private String headImgUrl;
/**
* 只有在用户将公众号绑定到微信开放平台帐号后，才会出现该字段。
*/
private String unionId;
/**
* 手机号
*/
private String mobile;
/**
* 授权手机号
*/
private String authMobile;
/**
* 商场编码
*/
private String mallCode;
/**
* 会员卡号
*/
private String userCode;
/**
*
*/
private String sessionKey;
/**
* 是否关注微信(1:关注，0：取消关注)
*/
private Integer wechatSubscribe;
/**
* 是否取消关注(关注后又取消，和oauth取得的会员区别)(1:取消，0：未取消)
*/
private Integer cancelSubscribe;
/**
* 微信原始ID
*/
private String wechatOriginalId;
/**
* 下单次数
*/
private Long orderNum;
/**
* 累计消费
*/
private BigDecimal cumulativeConsumption;
/**
* 最近消费时间
*/
private Date lastConsumptionTime;
/**
* 创建人Code
*/
private String createCode;
/**
* 更新时间
*/
private Date modifyTime;
/**
* 更新者
*/
private String modifyBy;
/**
* 更新者code
*/
private String modifyCode;
/**
* 删除状态 0：未删除 1：删除
*/
private Integer deleteFlag;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/Order.java deleted 100644 → 0
package com.yongqi.xinrenli.domain;
import com.baomidou.mybatisplus.annotation.*;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.ruoyi.common.core.domain.BaseEntity;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
/**
* <p>
* 订单表
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("by_order")
@Schema(name="Order对象", description="订单表")
public class Order implements Serializable {
private static final long serialVersionUID = 1L;
@Schema(name = "自增id")
@TableId(value = "id", type = IdType.AUTO)
private Long id;
@Schema(name = "用户id")
@TableField("user_id")
private Long userId;
@Schema(name = "标题")
@TableField("title")
private String title;
@Schema(name = "联系人")
@TableField("linkman")
private String linkman;
@Schema(name = "联系电话")
@TableField("phone")
private String phone;
@Schema(name = "维修时间")
@TableField("repair_time")
@JsonFormat(pattern = "yyyy/MM/dd")
private Date repairTime;
@Schema(name = "维修地址")
@TableField("repair_address")
private String repairAddress;
@Schema(name = "预算金额")
@TableField("budget")
private Double budget;
@Schema(name = "图片地址")
@TableField("image_src")
private String imageSrc;
@Schema(name = "视频地址")
@TableField("video_src")
private String videoSrc;
@Schema(name = "语音地址")
@TableField("audio_src")
private String audioSrc;
@Schema(name = "备注说明")
@TableField("remark")
private String remark;
@Schema(name = "订单状态：0 已发布；1 已驳回；2 待支付；3 已接单；4 已完成；5 退款中；6 已退款")
@TableField("status")
private Integer status;
@Schema(name = "创建人")
@TableField("create_user")
private String createUser;
@Schema(name = "创建时间")
@TableField("create_time")
private Date createTime;
@Schema(name = "修改人")
@TableField("update_user")
private String updateUser;
@Schema(name = "修改时间")
@TableField("update_time")
private Date updateTime;
@Schema(name = "删除状态 0：未删除 1：删除")
@TableField("delete_status")
@TableLogic(value = "0",delval = "1")
private Integer delStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/UserComment.java deleted 100644 → 0
package com.yongqi.xinrenli.domain;
import com.baomidou.mybatisplus.annotation.*;
import com.ruoyi.common.core.domain.BaseEntity;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.util.Date;
/**
* <p>
* 用户评论表
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("by_user_comment")
@Schema(name="UserComment对象", description="用户评论表")
public class UserComment implements Serializable {
private static final long serialVersionUID = 1L;
@Schema(name = "id自增")
@TableId(value = "id", type = IdType.AUTO)
private Long id;
@Schema(name = "文章id")
@TableField("article_id")
private Integer articleId;
@Schema(name = "用户id")
@TableField("user_id")
private Long userId;
@Schema(name = "用户评论内容")
@TableField("content")
private String content;
@Schema(name = "创建人")
@TableField("create_user")
private String createUser;
@Schema(name = "创建时间")
@TableField("create_time")
private Date createTime;
@Schema(name = "修改人")
@TableField("update_user")
private String updateUser;
@Schema(name = "修改时间")
@TableField("update_time")
private Date updateTime;
@Schema(name = "删除状态 0：未删除 1：删除")
@TableField("delete_status")
@TableLogic(value = "0",delval = "1")
private Integer delStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/UserFeedback.java deleted 100644 → 0
package com.yongqi.xinrenli.domain;
import com.baomidou.mybatisplus.annotation.*;
import com.ruoyi.common.core.domain.BaseEntity;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.util.Date;
/**
* <p>
* 用户反馈表
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("by_user_feedback")
@Schema(name="UserFeedback对象", description="用户反馈表")
public class UserFeedback implements Serializable {
private static final long serialVersionUID = 1L;
@Schema(name = "自增id")
@TableId(value = "id", type = IdType.AUTO)
private Long id;
@Schema(name = "用户id")
@TableField("user_id")
private Long userId;
@Schema(name = "反馈标题")
@TableField("title")
private String title;
@Schema(name = "反馈内容")
@TableField("content")
private String content;
@Schema(name = "创建人")
@TableField("create_user")
private String createUser;
@Schema(name = "创建时间")
@TableField("create_time")
private Date createTime;
@Schema(name = "修改人")
@TableField("update_user")
private String updateUser;
@Schema(name = "修改时间")
@TableField("update_time")
private Date updateTime;
@Schema(name = "删除状态 0：未删除 1：删除")
@TableField("delete_status")
@TableLogic(value = "0",delval = "1")
private Integer delStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/WxUser.java deleted 100644 → 0
package com.yongqi.xinrenli.domain;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.ruoyi.common.core.domain.BaseEntity;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
/**
* <p>
* 微信用户
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("by_wx_user")
@Schema(name="WxUser对象", description="微信用户")
public class WxUser implements Serializable {
private static final long serialVersionUID = 1L;
@Schema(name = "主键标识")
@TableId(value = "id", type = IdType.AUTO)
private Long id;
@Schema(name = "微信用户的唯一标识")
@TableField("open_id")
private String openId;
@Schema(name = "是否是团长：1：是，2：否")
@TableField("head_or_not")
private Boolean headOrNot;
@Schema(name = "用户昵称")
@TableField("nickname")
private String nickname;
@Schema(name = "用户的性别，值为1时是男性，值为2时是女性，值为0时是未知")
@TableField("sex")
private Integer sex;
@Schema(name = "用户个人资料填写的省份")
@TableField("province")
private String province;
@Schema(name = "普通用户个人资料填写的城市")
@TableField("city")
private String city;
@Schema(name = "国家，如中国为CN")
@TableField("country")
private String country;
@Schema(name = "用户头像")
@TableField("head_img_url")
private String headImgUrl;
@Schema(name = "只有在用户将公众号绑定到微信开放平台帐号后，才会出现该字段。")
@TableField("union_id")
private String unionId;
@Schema(name = "手机号")
@TableField("mobile")
private String mobile;
@Schema(name = "授权手机号")
@TableField("auth_mobile")
private String authMobile;
@Schema(name = "商场编码")
@TableField("mall_code")
private String mallCode;
@Schema(name = "会员卡号")
@TableField("user_code")
private String userCode;
@TableField("session_key")
private String sessionKey;
@Schema(name = "是否关注微信(1:关注，0：取消关注)")
@TableField("wechat_subscribe")
private Integer wechatSubscribe;
@Schema(name = "是否取消关注(关注后又取消，和oauth取得的会员区别)(1:取消，0：未取消)")
@TableField("cancel_subscribe")
private Integer cancelSubscribe;
@Schema(name = "微信原始ID")
@TableField("wechat_original_id")
private String wechatOriginalId;
@Schema(name = "下单次数")
@TableField("order_num")
private Integer orderNum;
@Schema(name = "累计消费")
@TableField("cumulative_consumption")
private BigDecimal cumulativeConsumption;
@Schema(name = "最近消费时间")
@TableField("last_consumption_time")
private Date lastConsumptionTime;
@Schema(name = "创建时间")
@TableField("create_time")
private Date createTime;
@Schema(name = "创建者")
@TableField("create_by")
private String createBy;
@Schema(name = "创建人Code")
@TableField("create_code")
private String createCode;
@Schema(name = "更新时间")
@TableField("modify_time")
private Date modifyTime;
@Schema(name = "更新者")
@TableField("modify_by")
private String modifyBy;
@Schema(name = "更新者code")
@TableField("modify_code")
private String modifyCode;
@Schema(name = "删除状态 0：未删除 1：删除")
@TableField("delete_flag")
private Boolean deleteFlag;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/bo/ArticleBo.java deleted 100644 → 0
package com.yongqi.xinrenli.domain.bo;
import com.ruoyi.common.core.domain.BaseEntity;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.util.Date;
/**
* <p>
* 文章表
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Data
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
@Schema(name="Article对象", description="文章表")
public class ArticleBo extends BaseEntity {
private static final long serialVersionUID = 1L;
@Schema(name = "自增id")
private Long id;
@Schema(name = "用户id")
private String userId;
@Schema(name = "动态标题")
@NotNull(message = "动态标题不能为空", groups = {AddGroup.class, EditGroup.class})
@NotBlank(message = "动态标题不能为空", groups = {AddGroup.class, EditGroup.class})
private String title;
@Schema(name = "动态内容")
@NotNull(message = "动态内容不能为空", groups = {AddGroup.class, EditGroup.class})
@NotBlank(message = "动态内容不能为空", groups = {AddGroup.class, EditGroup.class})
private String content;
@Schema(name = "添加图片地址")
private String imageSrc;
@Schema(name = "创建人")
private String createUser;
@Schema(name = "修改人")
private String updateUser;
@Schema(name = "删除状态 0：未删除 1：删除")
private Integer delStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/bo/CouponBo.java deleted 100644 → 0
package com.yongqi.xinrenli.domain.bo;
import com.ruoyi.common.core.domain.BaseEntity;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import javax.validation.constraints.NotNull;
import java.util.Date;
/**
* <p>
* 优惠卷表
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Data
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
@Schema(name="Coupon对象", description="优惠卷表")
public class CouponBo extends BaseEntity {
private static final long serialVersionUID = 1L;
@Schema(name = "自增id")
private Long id;
@Schema(name = "用户id")
private Integer userId;
@Schema(name = "券类型")
@NotNull(message = "券类型不能为空", groups = {AddGroup.class, EditGroup.class})
private Integer couponType;
@Schema(name = "优惠内容：满减")
@NotNull(message = "优惠内容不能为空", groups = {AddGroup.class, EditGroup.class})
private Integer fullSubtraction;
@Schema(name = "使用门槛： 最低消费")
@NotNull(message = "使用门槛不能为空", groups = {AddGroup.class, EditGroup.class})
private Integer minUsed;
@Schema(name = "生效时间")
@NotNull(message = "生效时间不能为空", groups = {AddGroup.class, EditGroup.class})
private Date effectiveTime;
@Schema(name = "失效时间")
private Date failureTime;
@Schema(name = "创建人")
private String createUser;
@Schema(name = "修改人")
private String updateUser;
@Schema(name = "删除状态 0：未删除 1：删除")
private Integer delStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/bo/DbArticleBo.java 0 → 100644
package com.yongqi.xinrenli.domain.bo;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.*;
import java.util.Date;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.ruoyi.common.core.domain.BaseEntity;
/**
* 文章业务对象 db_article
*
* @author zyf
* @date 2023-03-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class DbArticleBo extends BaseEntity {
/**
* 自增id
*/
@NotNull(message = "自增id不能为空", groups = {EditGroup.class})
private Long id;
/**
* 动态标题
*/
@NotBlank(message = "动态标题不能为空", groups = {AddGroup.class, EditGroup.class})
private String title;
/**
* 动态内容
*/
@NotBlank(message = "动态内容不能为空", groups = {AddGroup.class, EditGroup.class})
private String content;
/**
* 创建人
*/
@NotBlank(message = "创建人不能为空", groups = {AddGroup.class, EditGroup.class})
private String createUser;
/**
* 修改人
*/
@NotBlank(message = "修改人不能为空", groups = {AddGroup.class, EditGroup.class})
private String modifyUser;
/**
* 修改时间
*/
@NotNull(message = "修改时间不能为空", groups = {AddGroup.class, EditGroup.class})
private Date modifyTime;
/**
* 删除状态
*/
@NotNull(message = "删除状态不能为空", groups = {AddGroup.class, EditGroup.class})
private Integer deleteStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/bo/DbCouponBo.java 0 → 100644
package com.yongqi.xinrenli.domain.bo;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.*;
import java.util.Date;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.ruoyi.common.core.domain.BaseEntity;
/**
* 优惠卷业务对象 db_coupon
*
* @author zyf
* @date 2023-03-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class DbCouponBo extends BaseEntity {
/**
* 自增id
*/
@NotNull(message = "自增id不能为空", groups = {EditGroup.class})
private Long id;
/**
* 券类型
*/
@NotBlank(message = "券类型不能为空", groups = {AddGroup.class, EditGroup.class})
private String couponType;
/**
* 优惠内容
*/
@NotBlank(message = "优惠内容不能为空", groups = {AddGroup.class, EditGroup.class})
private String fullSubtraction;
/**
* 使用门槛：最低消费
*/
@NotNull(message = "使用门槛：最低消费不能为空", groups = {AddGroup.class, EditGroup.class})
private BigDecimal minUsed;
/**
* 生效时间
*/
@NotNull(message = "生效时间不能为空", groups = {AddGroup.class, EditGroup.class})
private Date effectiveTime;
/**
* 失效时间
*/
@NotNull(message = "失效时间不能为空", groups = {AddGroup.class, EditGroup.class})
private Date failureTime;
/**
* 创建人
*/
@NotBlank(message = "创建人不能为空", groups = {AddGroup.class, EditGroup.class})
private String createUser;
/**
* 修改人
*/
@NotBlank(message = "修改人不能为空", groups = {AddGroup.class, EditGroup.class})
private String modifyUser;
/**
* 修改时间
*/
@NotNull(message = "修改时间不能为空", groups = {AddGroup.class, EditGroup.class})
private Date modifyTime;
/**
* 删除状态
*/
@NotNull(message = "删除状态不能为空", groups = {AddGroup.class, EditGroup.class})
private Integer deleteStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/bo/DbFileBo.java 0 → 100644
package com.yongqi.xinrenli.domain.bo;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.*;
import java.util.Date;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.ruoyi.common.core.domain.BaseEntity;
/**
* 文件业务对象 db_file
*
* @author zyf
* @date 2023-03-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class DbFileBo extends BaseEntity {
/**
* 主键id
*/
@NotNull(message = "主键id不能为空", groups = {EditGroup.class})
private Long id;
/**
* 业务类型
*/
@NotBlank(message = "业务类型不能为空", groups = {AddGroup.class, EditGroup.class})
private String serviceType;
/**
* 文件地址
*/
@NotBlank(message = "文件地址不能为空", groups = {AddGroup.class, EditGroup.class})
private String url;
/**
* 文件类型
*/
@NotBlank(message = "文件类型不能为空", groups = {AddGroup.class, EditGroup.class})
private String fileType;
/**
* 排序
*/
@NotNull(message = "排序不能为空", groups = {AddGroup.class, EditGroup.class})
private Long sort;
/**
* 删除状态 0正常 1删除
*/
@NotNull(message = "删除状态 0正常 1删除不能为空", groups = {AddGroup.class, EditGroup.class})
private Integer deleteStatus;
/**
* 创建人
*/
@NotBlank(message = "创建人不能为空", groups = {AddGroup.class, EditGroup.class})
private String createName;
/**
* 修改时间
*/
@NotNull(message = "修改时间不能为空", groups = {AddGroup.class, EditGroup.class})
private Date modifyTime;
/**
* 修改人
*/
@NotBlank(message = "修改人不能为空", groups = {AddGroup.class, EditGroup.class})
private String modifyName;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/bo/DbInviterBo.java 0 → 100644
package com.yongqi.xinrenli.domain.bo;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.*;
import java.util.Date;
import com.ruoyi.common.core.domain.BaseEntity;
/**
* 邀请业务对象 db_Inviter
*
* @author zyf
* @date 2023-03-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class DbInviterBo extends BaseEntity {
/**
* 主键id
*/
@NotNull(message = "主键id不能为空", groups = {EditGroup.class})
private Long id;
/**
* 邀请人id
*/
@NotNull(message = "邀请人id不能为空", groups = {AddGroup.class, EditGroup.class})
private Long inviterId;
/**
* 邀请人名称
*/
@NotBlank(message = "邀请人名称不能为空", groups = {AddGroup.class, EditGroup.class})
private String inviterName;
/**
* 被邀请人id
*/
@NotNull(message = "被邀请人id不能为空", groups = {AddGroup.class, EditGroup.class})
private Long inviteeId;
/**
* 被邀请人名称
*/
@NotBlank(message = "被邀请人名称不能为空", groups = {AddGroup.class, EditGroup.class})
private String inviteeName;
/**
* 状态：是否已计入折扣
*/
@NotNull(message = "状态：是否已计入折扣不能为空", groups = {AddGroup.class, EditGroup.class})
private Integer status;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/bo/DbOrderBo.java 0 → 100644
package com.yongqi.xinrenli.domain.bo;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.*;
import java.util.Date;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.ruoyi.common.core.domain.BaseEntity;
/**
* 订单业务对象 db_order
*
* @author zyf
* @date 2023-03-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class DbOrderBo extends BaseEntity {
/**
* 自增id
*/
@NotNull(message = "自增id不能为空", groups = {EditGroup.class})
private Long id;
/**
* 用户id
*/
@NotNull(message = "用户id不能为空", groups = {AddGroup.class, EditGroup.class})
private Long userId;
/**
* 标题
*/
@NotBlank(message = "标题不能为空", groups = {AddGroup.class, EditGroup.class})
private String title;
/**
* 联系人
*/
@NotBlank(message = "联系人不能为空", groups = {AddGroup.class, EditGroup.class})
private String linkman;
/**
* 联系电话
*/
@NotBlank(message = "联系电话不能为空", groups = {AddGroup.class, EditGroup.class})
private String phone;
/**
* 维修时间
*/
@NotNull(message = "维修时间不能为空", groups = {AddGroup.class, EditGroup.class})
private Date repairTime;
/**
* 维修地址
*/
@NotBlank(message = "维修地址不能为空", groups = {AddGroup.class, EditGroup.class})
private String repairAddress;
/**
* 预算金额
*/
@NotNull(message = "预算金额不能为空", groups = {AddGroup.class, EditGroup.class})
private BigDecimal budget;
/**
* 备注说明
*/
@NotBlank(message = "备注说明不能为空", groups = {AddGroup.class, EditGroup.class})
private String remark;
/**
* 订单状态：0 已发布；1 已驳回；2 待支付；3 已接单；4 已完成；5 退款中；6 已退款
*/
@NotNull(message = "订单状态：0 已发布；1 已驳回；2 待支付；3 已接单；4 已完成；5 退款中；6 已退款不能为空", groups = {AddGroup.class, EditGroup.class})
private Integer status;
/**
* 创建人
*/
@NotBlank(message = "创建人不能为空", groups = {AddGroup.class, EditGroup.class})
private String createUser;
/**
* 修改人
*/
@NotBlank(message = "修改人不能为空", groups = {AddGroup.class, EditGroup.class})
private String modifyUser;
/**
* 修改时间
*/
@NotNull(message = "修改时间不能为空", groups = {AddGroup.class, EditGroup.class})
private Date modifyTime;
/**
* 删除状态 0：未删除 1：删除
*/
@NotNull(message = "删除状态 0：未删除 1：删除不能为空", groups = {AddGroup.class, EditGroup.class})
private Integer deleteStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/bo/DbUserCommentBo.java 0 → 100644
package com.yongqi.xinrenli.domain.bo;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.*;
import java.util.Date;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.ruoyi.common.core.domain.BaseEntity;
/**
* 用户评论业务对象 db_user_comment
*
* @author zyf
* @date 2023-03-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class DbUserCommentBo extends BaseEntity {
/**
* id自增
*/
@NotNull(message = "id自增不能为空", groups = {EditGroup.class})
private Long id;
/**
* 文章id
*/
@NotNull(message = "文章id不能为空", groups = {AddGroup.class, EditGroup.class})
private Long articleId;
/**
* 用户id
*/
@NotNull(message = "用户id不能为空", groups = {AddGroup.class, EditGroup.class})
private Long userId;
/**
* 用户评论内容
*/
@NotBlank(message = "用户评论内容不能为空", groups = {AddGroup.class, EditGroup.class})
private String content;
/**
* 创建人
*/
@NotBlank(message = "创建人不能为空", groups = {AddGroup.class, EditGroup.class})
private String createUser;
/**
* 修改人
*/
@NotBlank(message = "修改人不能为空", groups = {AddGroup.class, EditGroup.class})
private String modifyUser;
/**
* 修改时间
*/
@NotNull(message = "修改时间不能为空", groups = {AddGroup.class, EditGroup.class})
private Date modifyTime;
/**
* 删除状态
*/
@NotNull(message = "删除状态不能为空", groups = {AddGroup.class, EditGroup.class})
private Integer deleteStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/bo/DbUserCouponBo.java 0 → 100644
package com.yongqi.xinrenli.domain.bo;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.*;
import java.util.Date;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.ruoyi.common.core.domain.BaseEntity;
/**
* 用户优惠券关联业务对象 db_user_coupon
*
* @author zyf
* @date 2023-03-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class DbUserCouponBo extends BaseEntity {
/**
* 主键id
*/
@NotNull(message = "主键id不能为空", groups = {EditGroup.class})
private Long id;
/**
* 优惠券id
*/
@NotNull(message = "优惠券id不能为空", groups = {AddGroup.class, EditGroup.class})
private Long couponId;
/**
* 小程序用户id
*/
@NotNull(message = "小程序用户id不能为空", groups = {AddGroup.class, EditGroup.class})
private Long userId;
/**
* 使用状态 0 未使用， 1已使用
*/
@NotNull(message = "使用状态 0 未使用， 1已使用不能为空", groups = {AddGroup.class, EditGroup.class})
private Integer useStatus;
/**
* 修改时间
*/
@NotNull(message = "修改时间不能为空", groups = {AddGroup.class, EditGroup.class})
private Date modifyTime;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/bo/DbUserDiscountBo.java 0 → 100644
package com.yongqi.xinrenli.domain.bo;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.*;
import java.util.Date;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.ruoyi.common.core.domain.BaseEntity;
/**
* 用户折扣业务对象 db_user_discount
*
* @author zyf
* @date 2023-03-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class DbUserDiscountBo extends BaseEntity {
/**
* 主键id
*/
@NotNull(message = "主键id不能为空", groups = {EditGroup.class})
private Long id;
/**
* 用户id
*/
@NotNull(message = "用户id不能为空", groups = {AddGroup.class, EditGroup.class})
private Long userId;
/**
* 折扣比例
*/
@NotNull(message = "折扣比例不能为空", groups = {AddGroup.class, EditGroup.class})
private BigDecimal discountRatio;
/**
* 是否使用：0未使用， 1已使用
*/
@NotNull(message = "是否使用：0未使用， 1已使用不能为空", groups = {AddGroup.class, EditGroup.class})
private Integer useStatus;
/**
* 使用时间
*/
@NotNull(message = "使用时间不能为空", groups = {AddGroup.class, EditGroup.class})
private Date modifyTime;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/bo/DbUserFeedbackBo.java 0 → 100644
package com.yongqi.xinrenli.domain.bo;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.*;
import java.util.Date;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.ruoyi.common.core.domain.BaseEntity;
/**
* 用户反馈业务对象 db_user_feedback
*
* @author zyf
* @date 2023-03-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class DbUserFeedbackBo extends BaseEntity {
/**
* 自增id
*/
@NotNull(message = "自增id不能为空", groups = {EditGroup.class})
private Long id;
/**
* 用户id
*/
@NotNull(message = "用户id不能为空", groups = {AddGroup.class, EditGroup.class})
private Long userId;
/**
* 反馈标题
*/
@NotBlank(message = "反馈标题不能为空", groups = {AddGroup.class, EditGroup.class})
private String title;
/**
* 反馈内容
*/
@NotBlank(message = "反馈内容不能为空", groups = {AddGroup.class, EditGroup.class})
private String content;
/**
* 创建人
*/
@NotBlank(message = "创建人不能为空", groups = {AddGroup.class, EditGroup.class})
private String createUser;
/**
* 修改人
*/
@NotBlank(message = "修改人不能为空", groups = {AddGroup.class, EditGroup.class})
private String modifyUser;
/**
* 修改时间
*/
@NotNull(message = "修改时间不能为空", groups = {AddGroup.class, EditGroup.class})
private Date modifyTime;
/**
* 删除状态
*/
@NotNull(message = "删除状态不能为空", groups = {AddGroup.class, EditGroup.class})
private Integer deleteStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/bo/DbWxUserBo.java 0 → 100644
package com.yongqi.xinrenli.domain.bo;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.*;
import java.util.Date;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.ruoyi.common.core.domain.BaseEntity;
/**
* 微信用户业务对象 db_wx_user
*
* @author zyf
* @date 2023-03-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class DbWxUserBo extends BaseEntity {
/**
* 主键标识
*/
@NotNull(message = "主键标识不能为空", groups = {EditGroup.class})
private Long id;
/**
* 微信用户的唯一标识
*/
@NotBlank(message = "微信用户的唯一标识不能为空", groups = {AddGroup.class, EditGroup.class})
private String openId;
/**
* 是否是团长：1：是，2：否
*/
@NotNull(message = "是否是团长：1：是，2：否不能为空", groups = {AddGroup.class, EditGroup.class})
private Integer headOrNot;
/**
* 用户昵称
*/
@NotBlank(message = "用户昵称不能为空", groups = {AddGroup.class, EditGroup.class})
private String nickname;
/**
* 用户的性别，值为1时是男性，值为2时是女性，值为0时是未知
*/
@NotNull(message = "用户的性别，值为1时是男性，值为2时是女性，值为0时是未知不能为空", groups = {AddGroup.class, EditGroup.class})
private Integer sex;
/**
* 用户个人资料填写的省份
*/
@NotBlank(message = "用户个人资料填写的省份不能为空", groups = {AddGroup.class, EditGroup.class})
private String province;
/**
* 普通用户个人资料填写的城市
*/
@NotBlank(message = "普通用户个人资料填写的城市不能为空", groups = {AddGroup.class, EditGroup.class})
private String city;
/**
* 国家，如中国为CN
*/
@NotBlank(message = "国家，如中国为CN不能为空", groups = {AddGroup.class, EditGroup.class})
private String country;
/**
* 用户头像
*/
@NotBlank(message = "用户头像不能为空", groups = {AddGroup.class, EditGroup.class})
private String headImgUrl;
/**
* 只有在用户将公众号绑定到微信开放平台帐号后，才会出现该字段。
*/
@NotBlank(message = "只有在用户将公众号绑定到微信开放平台帐号后，才会出现该字段。不能为空", groups = {AddGroup.class, EditGroup.class})
private String unionId;
/**
* 手机号
*/
@NotBlank(message = "手机号不能为空", groups = {AddGroup.class, EditGroup.class})
private String mobile;
/**
* 授权手机号
*/
@NotBlank(message = "授权手机号不能为空", groups = {AddGroup.class, EditGroup.class})
private String authMobile;
/**
* 商场编码
*/
@NotBlank(message = "商场编码不能为空", groups = {AddGroup.class, EditGroup.class})
private String mallCode;
/**
* 会员卡号
*/
@NotBlank(message = "会员卡号不能为空", groups = {AddGroup.class, EditGroup.class})
private String userCode;
/**
*
*/
@NotBlank(message = "不能为空", groups = {AddGroup.class, EditGroup.class})
private String sessionKey;
/**
* 是否关注微信(1:关注，0：取消关注)
*/
@NotNull(message = "是否关注微信(1:关注，0：取消关注)不能为空", groups = {AddGroup.class, EditGroup.class})
private Integer wechatSubscribe;
/**
* 是否取消关注(关注后又取消，和oauth取得的会员区别)(1:取消，0：未取消)
*/
@NotNull(message = "是否取消关注(关注后又取消，和oauth取得的会员区别)(1:取消，0：未取消)不能为空", groups = {AddGroup.class, EditGroup.class})
private Integer cancelSubscribe;
/**
* 微信原始ID
*/
@NotBlank(message = "微信原始ID不能为空", groups = {AddGroup.class, EditGroup.class})
private String wechatOriginalId;
/**
* 下单次数
*/
@NotNull(message = "下单次数不能为空", groups = {AddGroup.class, EditGroup.class})
private Long orderNum;
/**
* 累计消费
*/
@NotNull(message = "累计消费不能为空", groups = {AddGroup.class, EditGroup.class})
private BigDecimal cumulativeConsumption;
/**
* 最近消费时间
*/
@NotNull(message = "最近消费时间不能为空", groups = {AddGroup.class, EditGroup.class})
private Date lastConsumptionTime;
/**
* 创建人Code
*/
@NotBlank(message = "创建人Code不能为空", groups = {AddGroup.class, EditGroup.class})
private String createCode;
/**
* 更新时间
*/
@NotNull(message = "更新时间不能为空", groups = {AddGroup.class, EditGroup.class})
private Date modifyTime;
/**
* 更新者
*/
@NotBlank(message = "更新者不能为空", groups = {AddGroup.class, EditGroup.class})
private String modifyBy;
/**
* 更新者code
*/
@NotBlank(message = "更新者code不能为空", groups = {AddGroup.class, EditGroup.class})
private String modifyCode;
/**
* 删除状态 0：未删除 1：删除
*/
@NotNull(message = "删除状态 0：未删除 1：删除不能为空", groups = {AddGroup.class, EditGroup.class})
private Integer deleteFlag;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/bo/OrderBo.java deleted 100644 → 0
package com.yongqi.xinrenli.domain.bo;
import com.baomidou.mybatisplus.annotation.*;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.ruoyi.common.core.domain.BaseEntity;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import com.yongqi.xinrenli.admin.controller.OrderController;
import io.swagger.v3.oas.annotations.media.Schema;
import javafx.beans.binding.MapExpression;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.util.Date;
import java.util.List;
/**
* <p>
* 订单表
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Data
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
@Schema(name="Order对象", description="订单表")
public class OrderBo extends BaseEntity {
private static final long serialVersionUID = 1L;
@Schema(name = "自增id")
private Long id;
@Schema(name = "用户id")
@NotNull(message = "用户id不能为空", groups = {AddGroup.class, EditGroup.class})
private Long userId;
@Schema(name = "标题")
@NotNull(message = "标题不能为空", groups = {AddGroup.class, EditGroup.class})
@NotBlank(message = "标题不能为空", groups = {AddGroup.class, EditGroup.class})
private String title;
@Schema(name = "联系人")
@NotNull(message = "联系人不能为空", groups = {AddGroup.class, EditGroup.class})
@NotBlank(message = "联系人不能为空", groups = {AddGroup.class, EditGroup.class})
private String linkman;
@Schema(name = "联系电话")
@NotNull(message = "联系电话不能为空", groups = {AddGroup.class, EditGroup.class})
@NotBlank(message = "联系电话不能为空", groups = {AddGroup.class, EditGroup.class})
private String phone;
@Schema(name = "维修时间")
@NotNull(message = "维修时间不能为空", groups = {AddGroup.class, EditGroup.class})
@JsonFormat(pattern = "yyyy/MM/dd")
private Date repairTime;
@Schema(name = "维修地址")
@NotNull(message = "维修地址不能为空", groups = {AddGroup.class, EditGroup.class})
@NotBlank(message = "维修地址不能为空", groups = {AddGroup.class, EditGroup.class})
private String repairAddress;
@Schema(name = "预算金额")
@NotNull(message = "预算金额不能为空", groups = {AddGroup.class, EditGroup.class})
private Double budget;
@Schema(name = "图片地址")
private List<String> imageSrc;
@Schema(name = "视频地址")
private String videoSrc;
@Schema(name = "语音地址")
private String audioSrc;
@Schema(name = "备注说明")
private String remark;
@Schema(name = "订单状态：0 已发布；1 已驳回；2 待支付；3 已接单；4 已完成；5 退款中；6 已退款")
private Integer status;
@Schema(name = "创建人")
private String createUser;
@Schema(name = "修改人")
private String updateUser;
@Schema(name = "删除状态 0：未删除 1：删除")
private Integer delStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/bo/UserCommentBo.java deleted 100644 → 0
package com.yongqi.xinrenli.domain.bo;
import com.baomidou.mybatisplus.annotation.*;
import com.ruoyi.common.core.domain.BaseEntity;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.util.Date;
/**
* <p>
* 用户评论表
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Data
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
@Schema(name="UserComment对象", description="用户评论表")
public class UserCommentBo extends BaseEntity {
private static final long serialVersionUID = 1L;
@Schema(name = "id自增")
private Long id;
@Schema(name = "文章id")
private Integer articleId;
@Schema(name = "用户id")
@NotNull(message = "用户id不能为空", groups = {AddGroup.class, EditGroup.class})
private Long userId;
@Schema(name = "用户评论内容")
@NotNull(message = "评论内容不能为空", groups = {AddGroup.class, EditGroup.class})
@NotBlank(message = "评论内容不能为空", groups = {AddGroup.class, EditGroup.class})
private String content;
@Schema(name = "创建人")
private String createUser;
@Schema(name = "修改人")
private String updateUser;
@Schema(name = "删除状态 0：未删除 1：删除")
private Integer delStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/bo/UserFeedbackBo.java deleted 100644 → 0
package com.yongqi.xinrenli.domain.bo;
import com.baomidou.mybatisplus.annotation.*;
import com.ruoyi.common.core.domain.BaseEntity;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.util.Date;
/**
* <p>
* 用户反馈表
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Data
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
@Schema(name="UserFeedback对象", description="用户反馈表")
public class UserFeedbackBo extends BaseEntity {
private static final long serialVersionUID = 1L;
@Schema(name = "自增id")
private Long id;
@Schema(name = "用户id")
@NotNull(message = "用户id不能为空", groups = {AddGroup.class, EditGroup.class})
private Long userId;
@Schema(name = "反馈标题")
@NotNull(message = "反馈标题不能为空", groups = {AddGroup.class, EditGroup.class})
@NotBlank(message = "反馈标题不能为空", groups = {AddGroup.class, EditGroup.class})
private String title;
@Schema(name = "反馈内容")
@NotNull(message = "反馈标题不能为空", groups = {AddGroup.class, EditGroup.class})
@NotBlank(message = "反馈标题不能为空", groups = {AddGroup.class, EditGroup.class})
private String content;
@Schema(name = "创建人")
private String createUser;
@Schema(name = "修改人")
private String updateUser;
@Schema(name = "删除状态 0：未删除 1：删除")
private Integer delStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/bo/WxUserBo.java deleted 100644 → 0
package com.yongqi.xinrenli.domain.bo;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.ruoyi.common.core.domain.BaseEntity;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.math.BigDecimal;
import java.util.Date;
/**
* <p>
* 微信用户
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Data
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
@Schema(name="WxUser对象", description="微信用户")
public class WxUserBo extends BaseEntity {
private static final long serialVersionUID = 1L;
@Schema(name = "主键标识")
private Long id;
@Schema(name = "微信用户的唯一标识")
private String openId;
@Schema(name = "是否是团长：1：是，2：否")
private Boolean headOrNot;
@Schema(name = "用户昵称")
private String nickname;
@Schema(name = "用户的性别，值为1时是男性，值为2时是女性，值为0时是未知")
private Integer sex;
@Schema(name = "用户个人资料填写的省份")
private String province;
@Schema(name = "普通用户个人资料填写的城市")
private String city;
@Schema(name = "国家，如中国为CN")
private String country;
@Schema(name = "用户头像")
private String headImgUrl;
@Schema(name = "只有在用户将公众号绑定到微信开放平台帐号后，才会出现该字段。")
private String unionId;
@Schema(name = "手机号")
private String mobile;
@Schema(name = "授权手机号")
private String authMobile;
@Schema(name = "商场编码")
private String mallCode;
@Schema(name = "会员卡号")
private String userCode;
@Schema(name = "session_key")
private String sessionKey;
@Schema(name = "是否关注微信(1:关注，0：取消关注)")
private Integer wechatSubscribe;
@Schema(name = "是否取消关注(关注后又取消，和oauth取得的会员区别)(1:取消，0：未取消)")
private Integer cancelSubscribe;
@Schema(name = "微信原始ID")
private String wechatOriginalId;
@Schema(name = "下单次数")
private Integer orderNum;
@Schema(name = "累计消费")
private BigDecimal cumulativeConsumption;
@Schema(name = "最近消费时间")
private Date lastConsumptionTime;
@Schema(name = "创建人Code")
private String createCode;
@Schema(name = "更新时间")
private Date modifyTime;
@Schema(name = "更新者")
private String modifyBy;
@Schema(name = "更新者code")
private String modifyCode;
@Schema(name = "删除状态 0：未删除 1：删除")
private Boolean deleteFlag;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/vo/ArticleVo.java deleted 100644 → 0
package com.yongqi.xinrenli.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.baomidou.mybatisplus.annotation.*;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.util.Date;
/**
* <p>
* 文章表
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Data
@ExcelIgnoreUnannotated
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@Schema(name="Article对象", description="文章表")
public class ArticleVo implements Serializable {
private static final long serialVersionUID = 1L;
@ExcelProperty("主键")
@Schema(name = "自增id")
private Long id;
@ExcelProperty("用户id")
@Schema(name = "用户id")
private String userId;
@ExcelProperty("动态标题")
@Schema(name = "动态标题")
private String title;
@ExcelProperty("动态内容")
@Schema(name = "动态内容")
private String content;
@ExcelProperty("添加图片地址")
@Schema(name = "添加图片地址")
private String imageSrc;
@ExcelProperty("创建人")
@Schema(name = "创建人")
private String createUser;
@ExcelProperty("创建时间")
@Schema(name = "创建时间")
private Date createTime;
@ExcelProperty("修改人")
@Schema(name = "修改人")
private String updateUser;
@ExcelProperty("修改时间")
@Schema(name = "修改时间")
private Date updateTime;
@Schema(name = "删除状态 0：未删除 1：删除")
private Integer delStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/vo/CouponVo.java deleted 100644 → 0
package com.yongqi.xinrenli.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.baomidou.mybatisplus.annotation.*;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.util.Date;
/**
* <p>
* 优惠卷表
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Data
@ExcelIgnoreUnannotated
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@Schema(name="Coupon对象", description="优惠卷表")
public class CouponVo implements Serializable {
private static final long serialVersionUID = 1L;
@ExcelProperty("主键")
@Schema(name = "自增id")
private Long id;
@ExcelProperty("用户id")
@Schema(name = "用户id")
private Integer userId;
@ExcelProperty("券类型")
@Schema(name = "券类型")
private Integer couponType;
@ExcelProperty("优惠内容（满减）")
@Schema(name = "优惠内容：满减")
private Integer fullSubtraction;
@ExcelProperty("使用门槛（最低消费）")
@Schema(name = "使用门槛： 最低消费")
private Integer minUsed;
@ExcelProperty("生效时间")
@Schema(name = "生效时间")
private Date effectiveTime;
@ExcelProperty("失效时间")
@Schema(name = "失效时间")
private Date failureTime;
@ExcelProperty("创建人")
@Schema(name = "创建人")
private String createUser;
@ExcelProperty("创建时间")
@Schema(name = "创建时间")
private Date createTime;
@ExcelProperty("修改人")
@Schema(name = "修改人")
private String updateUser;
@ExcelProperty("修改时间")
@Schema(name = "修改时间")
private Date updateTime;
@Schema(name = "删除状态 0：未删除 1：删除")
private Integer delStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/vo/DbArticleVo.java 0 → 100644
package com.yongqi.xinrenli.domain.vo;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.ruoyi.common.annotation.ExcelDictFormat;
import com.ruoyi.common.convert.ExcelDictConvert;
import lombok.Data;
import java.util.Date;
/**
* 文章视图对象 db_article
*
* @author zyf
* @date 2023-03-09
*/
@Data
@ExcelIgnoreUnannotated
public class DbArticleVo {
private static final long serialVersionUID = 1L;
/**
* 自增id
*/
@ExcelProperty(value = "自增id")
private Long id;
/**
* 动态标题
*/
@ExcelProperty(value = "动态标题")
private String title;
/**
* 动态内容
*/
@ExcelProperty(value = "动态内容")
private String content;
/**
* 创建人
*/
@ExcelProperty(value = "创建人")
private String createUser;
/**
* 修改人
*/
@ExcelProperty(value = "修改人")
private String modifyUser;
/**
* 修改时间
*/
@ExcelProperty(value = "修改时间")
private Date modifyTime;
/**
* 删除状态
*/
@ExcelProperty(value = "删除状态")
private Integer deleteStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/vo/DbCouponVo.java 0 → 100644
package com.yongqi.xinrenli.domain.vo;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.ruoyi.common.annotation.ExcelDictFormat;
import com.ruoyi.common.convert.ExcelDictConvert;
import lombok.Data;
import java.util.Date;
/**
* 优惠卷视图对象 db_coupon
*
* @author zyf
* @date 2023-03-09
*/
@Data
@ExcelIgnoreUnannotated
public class DbCouponVo {
private static final long serialVersionUID = 1L;
/**
* 自增id
*/
@ExcelProperty(value = "自增id")
private Long id;
/**
* 券类型
*/
@ExcelProperty(value = "券类型")
private String couponType;
/**
* 优惠内容
*/
@ExcelProperty(value = "优惠内容")
private String fullSubtraction;
/**
* 使用门槛：最低消费
*/
@ExcelProperty(value = "使用门槛：最低消费")
private BigDecimal minUsed;
/**
* 生效时间
*/
@ExcelProperty(value = "生效时间")
private Date effectiveTime;
/**
* 失效时间
*/
@ExcelProperty(value = "失效时间")
private Date failureTime;
/**
* 创建人
*/
@ExcelProperty(value = "创建人")
private String createUser;
/**
* 修改人
*/
@ExcelProperty(value = "修改人")
private String modifyUser;
/**
* 修改时间
*/
@ExcelProperty(value = "修改时间")
private Date modifyTime;
/**
* 删除状态
*/
@ExcelProperty(value = "删除状态")
private Integer deleteStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/vo/DbFileVo.java 0 → 100644
package com.yongqi.xinrenli.domain.vo;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.ruoyi.common.annotation.ExcelDictFormat;
import com.ruoyi.common.convert.ExcelDictConvert;
import lombok.Data;
import java.util.Date;
/**
* 文件视图对象 db_file
*
* @author zyf
* @date 2023-03-09
*/
@Data
@ExcelIgnoreUnannotated
public class DbFileVo {
private static final long serialVersionUID = 1L;
/**
* 主键id
*/
@ExcelProperty(value = "主键id")
private Long id;
/**
* 业务类型
*/
@ExcelProperty(value = "业务类型")
private String serviceType;
/**
* 文件地址
*/
@ExcelProperty(value = "文件地址")
private String url;
/**
* 文件类型
*/
@ExcelProperty(value = "文件类型")
private String fileType;
/**
* 排序
*/
@ExcelProperty(value = "排序")
private Long sort;
/**
* 删除状态 0正常 1删除
*/
@ExcelProperty(value = "删除状态 0正常 1删除")
private Integer deleteStatus;
/**
* 创建人
*/
@ExcelProperty(value = "创建人")
private String createName;
/**
* 修改时间
*/
@ExcelProperty(value = "修改时间")
private Date modifyTime;
/**
* 修改人
*/
@ExcelProperty(value = "修改人")
private String modifyName;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/vo/DbInviterVo.java 0 → 100644
package com.yongqi.xinrenli.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.ruoyi.common.annotation.ExcelDictFormat;
import com.ruoyi.common.convert.ExcelDictConvert;
import lombok.Data;
import java.util.Date;
/**
* 邀请视图对象 db_Inviter
*
* @author zyf
* @date 2023-03-09
*/
@Data
@ExcelIgnoreUnannotated
public class DbInviterVo {
private static final long serialVersionUID = 1L;
/**
* 主键id
*/
@ExcelProperty(value = "主键id")
private Long id;
/**
* 邀请人id
*/
@ExcelProperty(value = "邀请人id")
private Long inviterId;
/**
* 邀请人名称
*/
@ExcelProperty(value = "邀请人名称")
private String inviterName;
/**
* 被邀请人id
*/
@ExcelProperty(value = "被邀请人id")
private Long inviteeId;
/**
* 被邀请人名称
*/
@ExcelProperty(value = "被邀请人名称")
private String inviteeName;
/**
* 状态：是否已计入折扣
*/
@ExcelProperty(value = "状态：是否已计入折扣")
private Integer status;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/vo/DbOrderVo.java 0 → 100644
package com.yongqi.xinrenli.domain.vo;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.ruoyi.common.annotation.ExcelDictFormat;
import com.ruoyi.common.convert.ExcelDictConvert;
import lombok.Data;
import java.util.Date;
/**
* 订单视图对象 db_order
*
* @author zyf
* @date 2023-03-09
*/
@Data
@ExcelIgnoreUnannotated
public class DbOrderVo {
private static final long serialVersionUID = 1L;
/**
* 自增id
*/
@ExcelProperty(value = "自增id")
private Long id;
/**
* 用户id
*/
@ExcelProperty(value = "用户id")
private Long userId;
/**
* 标题
*/
@ExcelProperty(value = "标题")
private String title;
/**
* 联系人
*/
@ExcelProperty(value = "联系人")
private String linkman;
/**
* 联系电话
*/
@ExcelProperty(value = "联系电话")
private String phone;
/**
* 维修时间
*/
@ExcelProperty(value = "维修时间")
private Date repairTime;
/**
* 维修地址
*/
@ExcelProperty(value = "维修地址")
private String repairAddress;
/**
* 预算金额
*/
@ExcelProperty(value = "预算金额")
private BigDecimal budget;
/**
* 备注说明
*/
@ExcelProperty(value = "备注说明")
private String remark;
/**
* 订单状态：0 已发布；1 已驳回；2 待支付；3 已接单；4 已完成；5 退款中；6 已退款
*/
@ExcelProperty(value = "订单状态：0 已发布；1 已驳回；2 待支付；3 已接单；4 已完成；5 退款中；6 已退款")
private Integer status;
/**
* 创建人
*/
@ExcelProperty(value = "创建人")
private String createUser;
/**
* 修改人
*/
@ExcelProperty(value = "修改人")
private String modifyUser;
/**
* 修改时间
*/
@ExcelProperty(value = "修改时间")
private Date modifyTime;
/**
* 删除状态 0：未删除 1：删除
*/
@ExcelProperty(value = "删除状态 0：未删除 1：删除")
private Integer deleteStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/vo/DbUserCommentVo.java 0 → 100644
package com.yongqi.xinrenli.domain.vo;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.ruoyi.common.annotation.ExcelDictFormat;
import com.ruoyi.common.convert.ExcelDictConvert;
import lombok.Data;
import java.util.Date;
/**
* 用户评论视图对象 db_user_comment
*
* @author zyf
* @date 2023-03-09
*/
@Data
@ExcelIgnoreUnannotated
public class DbUserCommentVo {
private static final long serialVersionUID = 1L;
/**
* id自增
*/
@ExcelProperty(value = "id自增")
private Long id;
/**
* 文章id
*/
@ExcelProperty(value = "文章id")
private Long articleId;
/**
* 用户id
*/
@ExcelProperty(value = "用户id")
private Long userId;
/**
* 用户评论内容
*/
@ExcelProperty(value = "用户评论内容")
private String content;
/**
* 创建人
*/
@ExcelProperty(value = "创建人")
private String createUser;
/**
* 修改人
*/
@ExcelProperty(value = "修改人")
private String modifyUser;
/**
* 修改时间
*/
@ExcelProperty(value = "修改时间")
private Date modifyTime;
/**
* 删除状态
*/
@ExcelProperty(value = "删除状态")
private Integer deleteStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/vo/DbUserCouponVo.java 0 → 100644
package com.yongqi.xinrenli.domain.vo;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.ruoyi.common.annotation.ExcelDictFormat;
import com.ruoyi.common.convert.ExcelDictConvert;
import lombok.Data;
import java.util.Date;
/**
* 用户优惠券关联视图对象 db_user_coupon
*
* @author zyf
* @date 2023-03-09
*/
@Data
@ExcelIgnoreUnannotated
public class DbUserCouponVo {
private static final long serialVersionUID = 1L;
/**
* 主键id
*/
@ExcelProperty(value = "主键id")
private Long id;
/**
* 优惠券id
*/
@ExcelProperty(value = "优惠券id")
private Long couponId;
/**
* 小程序用户id
*/
@ExcelProperty(value = "小程序用户id")
private Long userId;
/**
* 使用状态 0 未使用， 1已使用
*/
@ExcelProperty(value = "使用状态 0 未使用， 1已使用")
private Integer useStatus;
/**
* 修改时间
*/
@ExcelProperty(value = "修改时间")
private Date modifyTime;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/vo/DbUserDiscountVo.java 0 → 100644
package com.yongqi.xinrenli.domain.vo;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.ruoyi.common.annotation.ExcelDictFormat;
import com.ruoyi.common.convert.ExcelDictConvert;
import lombok.Data;
import java.util.Date;
/**
* 用户折扣视图对象 db_user_discount
*
* @author zyf
* @date 2023-03-09
*/
@Data
@ExcelIgnoreUnannotated
public class DbUserDiscountVo {
private static final long serialVersionUID = 1L;
/**
* 主键id
*/
@ExcelProperty(value = "主键id")
private Long id;
/**
* 用户id
*/
@ExcelProperty(value = "用户id")
private Long userId;
/**
* 折扣比例
*/
@ExcelProperty(value = "折扣比例")
private BigDecimal discountRatio;
/**
* 是否使用：0未使用， 1已使用
*/
@ExcelProperty(value = "是否使用：0未使用， 1已使用")
private Integer useStatus;
/**
* 使用时间
*/
@ExcelProperty(value = "使用时间")
private Date modifyTime;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/vo/DbUserFeedbackVo.java 0 → 100644
package com.yongqi.xinrenli.domain.vo;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.ruoyi.common.annotation.ExcelDictFormat;
import com.ruoyi.common.convert.ExcelDictConvert;
import lombok.Data;
import java.util.Date;
/**
* 用户反馈视图对象 db_user_feedback
*
* @author zyf
* @date 2023-03-09
*/
@Data
@ExcelIgnoreUnannotated
public class DbUserFeedbackVo {
private static final long serialVersionUID = 1L;
/**
* 自增id
*/
@ExcelProperty(value = "自增id")
private Long id;
/**
* 用户id
*/
@ExcelProperty(value = "用户id")
private Long userId;
/**
* 反馈标题
*/
@ExcelProperty(value = "反馈标题")
private String title;
/**
* 反馈内容
*/
@ExcelProperty(value = "反馈内容")
private String content;
/**
* 创建人
*/
@ExcelProperty(value = "创建人")
private String createUser;
/**
* 修改人
*/
@ExcelProperty(value = "修改人")
private String modifyUser;
/**
* 修改时间
*/
@ExcelProperty(value = "修改时间")
private Date modifyTime;
/**
* 删除状态
*/
@ExcelProperty(value = "删除状态")
private Integer deleteStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/vo/DbWxUserVo.java 0 → 100644
package com.yongqi.xinrenli.domain.vo;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.ruoyi.common.annotation.ExcelDictFormat;
import com.ruoyi.common.convert.ExcelDictConvert;
import lombok.Data;
import java.util.Date;
/**
* 微信用户视图对象 db_wx_user
*
* @author zyf
* @date 2023-03-09
*/
@Data
@ExcelIgnoreUnannotated
public class DbWxUserVo {
private static final long serialVersionUID = 1L;
/**
* 主键标识
*/
@ExcelProperty(value = "主键标识")
private Long id;
/**
* 微信用户的唯一标识
*/
@ExcelProperty(value = "微信用户的唯一标识")
private String openId;
/**
* 是否是团长：1：是，2：否
*/
@ExcelProperty(value = "是否是团长：1：是，2：否")
private Integer headOrNot;
/**
* 用户昵称
*/
@ExcelProperty(value = "用户昵称")
private String nickname;
/**
* 用户的性别，值为1时是男性，值为2时是女性，值为0时是未知
*/
@ExcelProperty(value = "用户的性别，值为1时是男性，值为2时是女性，值为0时是未知")
private Integer sex;
/**
* 用户个人资料填写的省份
*/
@ExcelProperty(value = "用户个人资料填写的省份")
private String province;
/**
* 普通用户个人资料填写的城市
*/
@ExcelProperty(value = "普通用户个人资料填写的城市")
private String city;
/**
* 国家，如中国为CN
*/
@ExcelProperty(value = "国家，如中国为CN")
private String country;
/**
* 用户头像
*/
@ExcelProperty(value = "用户头像")
private String headImgUrl;
/**
* 只有在用户将公众号绑定到微信开放平台帐号后，才会出现该字段。
*/
@ExcelProperty(value = "只有在用户将公众号绑定到微信开放平台帐号后，才会出现该字段。")
private String unionId;
/**
* 手机号
*/
@ExcelProperty(value = "手机号")
private String mobile;
/**
* 授权手机号
*/
@ExcelProperty(value = "授权手机号")
private String authMobile;
/**
* 商场编码
*/
@ExcelProperty(value = "商场编码")
private String mallCode;
/**
* 会员卡号
*/
@ExcelProperty(value = "会员卡号")
private String userCode;
/**
*
*/
@ExcelProperty(value = "")
private String sessionKey;
/**
* 是否关注微信(1:关注，0：取消关注)
*/
@ExcelProperty(value = "是否关注微信(1:关注，0：取消关注)")
private Integer wechatSubscribe;
/**
* 是否取消关注(关注后又取消，和oauth取得的会员区别)(1:取消，0：未取消)
*/
@ExcelProperty(value = "是否取消关注(关注后又取消，和oauth取得的会员区别)(1:取消，0：未取消)")
private Integer cancelSubscribe;
/**
* 微信原始ID
*/
@ExcelProperty(value = "微信原始ID")
private String wechatOriginalId;
/**
* 下单次数
*/
@ExcelProperty(value = "下单次数")
private Long orderNum;
/**
* 累计消费
*/
@ExcelProperty(value = "累计消费")
private BigDecimal cumulativeConsumption;
/**
* 最近消费时间
*/
@ExcelProperty(value = "最近消费时间")
private Date lastConsumptionTime;
/**
* 创建人Code
*/
@ExcelProperty(value = "创建人Code")
private String createCode;
/**
* 更新时间
*/
@ExcelProperty(value = "更新时间")
private Date modifyTime;
/**
* 更新者
*/
@ExcelProperty(value = "更新者")
private String modifyBy;
/**
* 更新者code
*/
@ExcelProperty(value = "更新者code")
private String modifyCode;
/**
* 删除状态 0：未删除 1：删除
*/
@ExcelProperty(value = "删除状态 0：未删除 1：删除")
private Integer deleteFlag;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/vo/OrderVo.java deleted 100644 → 0
package com.yongqi.xinrenli.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.baomidou.mybatisplus.annotation.*;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
/**
* <p>
* 订单表
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Data
@ExcelIgnoreUnannotated
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@Schema(name="Order对象", description="订单表")
public class OrderVo implements Serializable {
private static final long serialVersionUID = 1L;
@ExcelProperty("主键")
@Schema(name = "自增id")
private Long id;
@ExcelProperty("用户id")
@Schema(name = "用户id")
private Long userId;
@ExcelProperty("标题")
@Schema(name = "标题")
private String title;
@ExcelProperty("联系人")
@Schema(name = "联系人")
private String linkman;
@ExcelProperty("联系电话")
@Schema(name = "联系电话")
private String phone;
@ExcelProperty("维修时间")
@Schema(name = "维修时间")
@JsonFormat(pattern = "yyyy/MM/dd")
private Date repairTime;
@ExcelProperty("维修地址")
@Schema(name = "维修地址")
private String repairAddress;
@ExcelProperty("预算金额")
@Schema(name = "预算金额")
private Double budget;
@ExcelProperty("图片地址")
@Schema(name = "图片地址")
private List<String> imageSrc;
@ExcelProperty("视频地址")
@Schema(name = "视频地址")
private String videoSrc;
@ExcelProperty("语音地址")
@Schema(name = "语音地址")
private String audioSrc;
@ExcelProperty("备注说明")
@Schema(name = "备注说明")
private String remark;
@ExcelProperty("订单状态：0 已发布；1 已驳回；2 待支付；3 已接单；4 已完成；5 退款中；6 已退款")
@Schema(name = "订单状态：0 已发布；1 已驳回；2 待支付；3 已接单；4 已完成；5 退款中；6 已退款")
private Integer status;
@ExcelProperty("创建人")
@Schema(name = "创建人")
private String createUser;
@ExcelProperty("创建时间")
@Schema(name = "创建时间")
private Date createTime;
@ExcelProperty("修改人")
@Schema(name = "修改人")
private String updateUser;
@ExcelProperty("修改时间")
@Schema(name = "修改时间")
private Date updateTime;
@Schema(name = "删除状态 0：未删除 1：删除")
private Integer delStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/vo/UserCommentVo.java deleted 100644 → 0
package com.yongqi.xinrenli.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.baomidou.mybatisplus.annotation.*;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.util.Date;
/**
* <p>
* 用户评论表
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Data
@ExcelIgnoreUnannotated
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@Schema(name="UserComment对象", description="用户评论表")
public class UserCommentVo implements Serializable {
private static final long serialVersionUID = 1L;
@ExcelProperty("id自增")
@Schema(name = "id自增")
private Long id;
@Schema(name = "文章id")
@ExcelProperty("文章id")
private Integer articleId;
@Schema(name = "用户id")
@ExcelProperty("用户id")
private Long userId;
@Schema(name = "用户评论内容")
@ExcelProperty("用户评论内容")
private String content;
@ExcelProperty("创建人")
@Schema(name = "创建人")
private String createUser;
@ExcelProperty("创建时间")
@Schema(name = "创建时间")
private Date createTime;
@ExcelProperty("修改人")
@Schema(name = "修改人")
private String updateUser;
@ExcelProperty("修改时间")
@Schema(name = "修改时间")
private Date updateTime;
@Schema(name = "删除状态 0：未删除 1：删除")
private Integer delStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/vo/UserFeedbackVo.java deleted 100644 → 0
package com.yongqi.xinrenli.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.baomidou.mybatisplus.annotation.*;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.util.Date;
/**
* <p>
* 用户反馈表
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Data
@ExcelIgnoreUnannotated
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@Schema(name="UserFeedback对象", description="用户反馈表")
public class UserFeedbackVo implements Serializable {
private static final long serialVersionUID = 1L;
@Schema(name = "自增id")
@ExcelProperty("自增id")
private Long id;
@Schema(name = "用户id")
@ExcelProperty("用户id")
private Long userId;
@Schema(name = "反馈标题")
@ExcelProperty("反馈标题")
private String title;
@Schema(name = "反馈内容")
@ExcelProperty("反馈内容")
private String content;
@ExcelProperty("创建人")
@Schema(name = "创建人")
private String createUser;
@ExcelProperty("创建时间")
@Schema(name = "创建时间")
private Date createTime;
@ExcelProperty("修改人")
@Schema(name = "修改人")
private String updateUser;
@ExcelProperty("修改时间")
@Schema(name = "修改时间")
private Date updateTime;
@Schema(name = "删除状态 0：未删除 1：删除")
private Integer delStatus;
}
xinrenli/src/main/java/com/yongqi/xinrenli/domain/vo/WxUserVo.java deleted 100644 → 0
package com.yongqi.xinrenli.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
/**
* <p>
* 微信用户
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Data
@ExcelIgnoreUnannotated
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@Schema(name="WxUser对象", description="微信用户")
public class WxUserVo implements Serializable {
private static final long serialVersionUID = 1L;
@Schema(name = "主键标识")
@ExcelProperty("主键标识")
private Long id;
@Schema(name = "微信用户的唯一标识")
@ExcelProperty("微信用户的唯一标识")
private String openId;
@Schema(name = "是否是团长：1：是，2：否")
@ExcelProperty("是否是团长：1：是，2：否")
private Boolean headOrNot;
@Schema(name = "用户昵称")
@ExcelProperty("用户昵称")
private String nickname;
@Schema(name = "用户的性别，值为1时是男性，值为2时是女性，值为0时是未知")
@ExcelProperty("用户的性别，值为1时是男性，值为2时是女性，值为0时是未知")
private Integer sex;
@Schema(name = "用户个人资料填写的省份")
@ExcelProperty("用户个人资料填写的省份")
private String province;
@Schema(name = "普通用户个人资料填写的城市")
@ExcelProperty("普通用户个人资料填写的城市")
private String city;
@Schema(name = "国家，如中国为CN")
@ExcelProperty("国家，如中国为CN")
private String country;
@Schema(name = "用户头像")
@ExcelProperty("用户头像")
private String headImgUrl;
@Schema(name = "只有在用户将公众号绑定到微信开放平台帐号后，才会出现该字段。")
@ExcelProperty("只有在用户将公众号绑定到微信开放平台帐号后，才会出现该字段。")
private String unionId;
@Schema(name = "手机号")
@ExcelProperty("手机号")
private String mobile;
@Schema(name = "授权手机号")
@ExcelProperty("授权手机号")
private String authMobile;
@Schema(name = "商场编码")
@ExcelProperty("商场编码")
private String mallCode;
@Schema(name = "会员卡号")
@ExcelProperty("会员卡号")
private String userCode;
@ExcelProperty("session_key")
private String sessionKey;
@Schema(name = "是否关注微信(1:关注，0：取消关注)")
@ExcelProperty("是否关注微信(1:关注，0：取消关注)")
private Integer wechatSubscribe;
@Schema(name = "是否取消关注(关注后又取消，和oauth取得的会员区别)(1:取消，0：未取消)")
@ExcelProperty("是否取消关注(关注后又取消，和oauth取得的会员区别)(1:取消，0：未取消)")
private Integer cancelSubscribe;
@Schema(name = "微信原始ID")
@ExcelProperty("微信原始ID")
private String wechatOriginalId;
@Schema(name = "下单次数")
@ExcelProperty("下单次数")
private Integer orderNum;
@Schema(name = "累计消费")
@ExcelProperty("累计消费")
private BigDecimal cumulativeConsumption;
@Schema(name = "最近消费时间")
@ExcelProperty("最近消费时间")
private Date lastConsumptionTime;
@Schema(name = "创建时间")
@ExcelProperty("创建时间")
private Date createTime;
@Schema(name = "创建者")
@ExcelProperty("创建者")
private String createBy;
@Schema(name = "创建人Code")
@ExcelProperty("创建人Code")
private String createCode;
@Schema(name = "更新时间")
@ExcelProperty("更新时间")
private Date modifyTime;
@Schema(name = "更新者")
@ExcelProperty("更新者")
private String modifyBy;
@Schema(name = "更新者code")
@ExcelProperty("更新者code")
private String modifyCode;
@Schema(name = "删除状态 0：未删除 1：删除")
@ExcelProperty("删除状态 0：未删除 1：删除")
private Boolean deleteFlag;
}
xinrenli/src/main/java/com/yongqi/xinrenli/handler/AbstractHandler.java 0 → 100644
package com.yongqi.xinrenli.handler;
import me.chanjar.weixin.mp.api.WxMpMessageHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @author <a href="https://github.com/binarywang">Binary Wang</a>
*/
public abstract class AbstractHandler implements WxMpMessageHandler {
protected Logger logger = LoggerFactory.getLogger(getClass());
}
xinrenli/src/main/java/com/yongqi/xinrenli/handler/KfSessionHandler.java 0 → 100644
package com.yongqi.xinrenli.handler;
import me.chanjar.weixin.common.session.WxSessionManager;
import me.chanjar.weixin.mp.api.WxMpService;
import me.chanjar.weixin.mp.bean.message.WxMpXmlMessage;
import me.chanjar.weixin.mp.bean.message.WxMpXmlOutMessage;
import org.springframework.stereotype.Component;
import java.util.Map;
/**
* @author <a href="https://github.com/binarywang">Binary Wang</a>
*/
@Component
public class KfSessionHandler extends AbstractHandler {
@Override
public WxMpXmlOutMessage handle(WxMpXmlMessage wxMessage,
Map<String, Object> context, WxMpService wxMpService,
WxSessionManager sessionManager) {
//TODO 对会话做处理
return null;
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/handler/LocationHandler.java 0 → 100644
package com.yongqi.xinrenli.handler;
import com.yongqi.xinrenli.builder.TextBuilder;
import me.chanjar.weixin.common.session.WxSessionManager;
import me.chanjar.weixin.mp.api.WxMpService;
import me.chanjar.weixin.mp.bean.message.WxMpXmlMessage;
import me.chanjar.weixin.mp.bean.message.WxMpXmlOutMessage;
import org.springframework.stereotype.Component;
import java.util.Map;
import static me.chanjar.weixin.common.api.WxConsts.XmlMsgType;
/**
* @author <a href="https://github.com/binarywang">Binary Wang</a>
*/
@Component
public class LocationHandler extends AbstractHandler {
@Override
public WxMpXmlOutMessage handle(WxMpXmlMessage wxMessage,
Map<String, Object> context, WxMpService wxMpService,
WxSessionManager sessionManager) {
if (wxMessage.getMsgType().equals(XmlMsgType.LOCATION)) {
//TODO 接收处理用户发送的地理位置消息
try {
String content = "感谢反馈，您的的地理位置已收到！";
return new TextBuilder().build(content, wxMessage, null);
} catch (Exception e) {
this.logger.error("位置消息接收处理失败", e);
return null;
}
}
//上报地理位置事件
this.logger.info("上报地理位置，纬度 : {}，经度 : {}，精度 : {}",
wxMessage.getLatitude(), wxMessage.getLongitude(), String.valueOf(wxMessage.getPrecision()));
//TODO 可以将用户地理位置信息保存到本地数据库，以便以后使用
return null;
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/handler/LogHandler.java 0 → 100644
package com.yongqi.xinrenli.handler;
import com.yongqi.xinrenli.utils.JsonUtils;
import me.chanjar.weixin.common.session.WxSessionManager;
import me.chanjar.weixin.mp.api.WxMpService;
import me.chanjar.weixin.mp.bean.message.WxMpXmlMessage;
import me.chanjar.weixin.mp.bean.message.WxMpXmlOutMessage;
import org.springframework.stereotype.Component;
import java.util.Map;
/**
* @author <a href="https://github.com/binarywang">Binary Wang</a>
*/
@Component
public class LogHandler extends AbstractHandler {
@Override
public WxMpXmlOutMessage handle(WxMpXmlMessage wxMessage,
Map<String, Object> context, WxMpService wxMpService,
WxSessionManager sessionManager) {
this.logger.info("\n接收到请求消息，内容：{}", JsonUtils.toJson(wxMessage));
return null;
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/handler/MenuHandler.java 0 → 100644
package com.yongqi.xinrenli.handler;
import me.chanjar.weixin.common.session.WxSessionManager;
import me.chanjar.weixin.mp.api.WxMpService;
import me.chanjar.weixin.mp.bean.message.WxMpXmlMessage;
import me.chanjar.weixin.mp.bean.message.WxMpXmlOutMessage;
import org.springframework.stereotype.Component;
import java.util.Map;
import static me.chanjar.weixin.common.api.WxConsts.EventType;
/**
* @author <a href="https://github.com/binarywang">Binary Wang</a>
*/
@Component
public class MenuHandler extends AbstractHandler {
@Override
public WxMpXmlOutMessage handle(WxMpXmlMessage wxMessage,
Map<String, Object> context, WxMpService weixinService,
WxSessionManager sessionManager) {
String msg = String.format("type:%s, event:%s, key:%s",
wxMessage.getMsgType(), wxMessage.getEvent(),
wxMessage.getEventKey());
if (EventType.VIEW.equals(wxMessage.getEvent())) {
return null;
}
return WxMpXmlOutMessage.TEXT().content(msg)
.fromUser(wxMessage.getToUser()).toUser(wxMessage.getFromUser())
.build();
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/handler/MsgHandler.java 0 → 100644
package com.yongqi.xinrenli.handler;
import com.yongqi.xinrenli.builder.TextBuilder;
import com.yongqi.xinrenli.utils.JsonUtils;
import me.chanjar.weixin.common.error.WxErrorException;
import me.chanjar.weixin.common.session.WxSessionManager;
import me.chanjar.weixin.mp.api.WxMpService;
import me.chanjar.weixin.mp.bean.message.WxMpXmlMessage;
import me.chanjar.weixin.mp.bean.message.WxMpXmlOutMessage;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;
import java.util.Map;
import static me.chanjar.weixin.common.api.WxConsts.XmlMsgType;
/**
* @author <a href="https://github.com/binarywang">Binary Wang</a>
*/
@Component
public class MsgHandler extends AbstractHandler {
@Override
public WxMpXmlOutMessage handle(WxMpXmlMessage wxMessage,
Map<String, Object> context, WxMpService weixinService,
WxSessionManager sessionManager) {
if (!wxMessage.getMsgType().equals(XmlMsgType.EVENT)) {
//TODO 可以选择将消息保存到本地
}
//当用户输入关键词如“你好”，“客服”等，并且有客服在线时，把消息转发给在线客服
try {
if (StringUtils.startsWithAny(wxMessage.getContent(), "你好", "客服")
&& weixinService.getKefuService().kfOnlineList()
.getKfOnlineList().size() > 0) {
return WxMpXmlOutMessage.TRANSFER_CUSTOMER_SERVICE()
.fromUser(wxMessage.getToUser())
.toUser(wxMessage.getFromUser()).build();
}
} catch (WxErrorException e) {
e.printStackTrace();
}
//TODO 组装回复消息
String content = "收到信息内容：" + JsonUtils.toJson(wxMessage);
return new TextBuilder().build(content, wxMessage, weixinService);
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/handler/NullHandler.java 0 → 100644
package com.yongqi.xinrenli.handler;
import me.chanjar.weixin.common.session.WxSessionManager;
import me.chanjar.weixin.mp.api.WxMpService;
import me.chanjar.weixin.mp.bean.message.WxMpXmlMessage;
import me.chanjar.weixin.mp.bean.message.WxMpXmlOutMessage;
import org.springframework.stereotype.Component;
import java.util.Map;
/**
* @author <a href="https://github.com/binarywang">Binary Wang</a>
*/
@Component
public class NullHandler extends AbstractHandler {
@Override
public WxMpXmlOutMessage handle(WxMpXmlMessage wxMessage,
Map<String, Object> context, WxMpService wxMpService,
WxSessionManager sessionManager) {
return null;
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/handler/ScanHandler.java 0 → 100644
package com.yongqi.xinrenli.handler;
import java.util.Map;
import org.springframework.stereotype.Component;
import me.chanjar.weixin.common.error.WxErrorException;
import me.chanjar.weixin.common.session.WxSessionManager;
import me.chanjar.weixin.mp.api.WxMpService;
import me.chanjar.weixin.mp.bean.message.WxMpXmlMessage;
import me.chanjar.weixin.mp.bean.message.WxMpXmlOutMessage;
/**
* @author <a href="https://github.com/binarywang">Binary Wang</a>
*/
@Component
public class ScanHandler extends AbstractHandler {
@Override
public WxMpXmlOutMessage handle(WxMpXmlMessage wxMpXmlMessage, Map<String, Object> map,
WxMpService wxMpService, WxSessionManager wxSessionManager) throws WxErrorException {
// 扫码事件处理
return null;
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/handler/StoreCheckNotifyHandler.java 0 → 100644
package com.yongqi.xinrenli.handler;
import me.chanjar.weixin.common.session.WxSessionManager;
import me.chanjar.weixin.mp.api.WxMpService;
import me.chanjar.weixin.mp.bean.message.WxMpXmlMessage;
import me.chanjar.weixin.mp.bean.message.WxMpXmlOutMessage;
import org.springframework.stereotype.Component;
import java.util.Map;
/**
* 门店审核事件处理
*
* @author <a href="https://github.com/binarywang">Binary Wang</a>
*/
@Component
public class StoreCheckNotifyHandler extends AbstractHandler {
@Override
public WxMpXmlOutMessage handle(WxMpXmlMessage wxMessage,
Map<String, Object> context, WxMpService wxMpService,
WxSessionManager sessionManager) {
// TODO 处理门店审核事件
return null;
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/handler/SubscribeHandler.java 0 → 100644
package com.yongqi.xinrenli.handler;
import java.util.Map;
import com.yongqi.xinrenli.builder.TextBuilder;
import org.springframework.stereotype.Component;
import me.chanjar.weixin.common.error.WxErrorException;
import me.chanjar.weixin.common.session.WxSessionManager;
import me.chanjar.weixin.mp.api.WxMpService;
import me.chanjar.weixin.mp.bean.message.WxMpXmlMessage;
import me.chanjar.weixin.mp.bean.message.WxMpXmlOutMessage;
import me.chanjar.weixin.mp.bean.result.WxMpUser;
/**
* @author <a href="https://github.com/binarywang">Binary Wang</a>
*/
@Component
public class SubscribeHandler extends AbstractHandler {
@Override
public WxMpXmlOutMessage handle(WxMpXmlMessage wxMessage,
Map<String, Object> context, WxMpService weixinService,
WxSessionManager sessionManager) throws WxErrorException {
this.logger.info("新关注用户 OPENID: " + wxMessage.getFromUser());
// 获取微信用户基本信息
try {
WxMpUser userWxInfo = weixinService.getUserService()
.userInfo(wxMessage.getFromUser(), null);
if (userWxInfo != null) {
// TODO 可以添加关注用户到本地数据库
}
} catch (WxErrorException e) {
if (e.getError().getErrorCode() == 48001) {
this.logger.info("该公众号没有获取用户信息权限！");
}
}
WxMpXmlOutMessage responseResult = null;
try {
responseResult = this.handleSpecial(wxMessage);
} catch (Exception e) {
this.logger.error(e.getMessage(), e);
}
if (responseResult != null) {
return responseResult;
}
try {
return new TextBuilder().build("感谢关注", wxMessage, weixinService);
} catch (Exception e) {
this.logger.error(e.getMessage(), e);
}
return null;
}
/**
* 处理特殊请求，比如如果是扫码进来的，可以做相应处理
*/
private WxMpXmlOutMessage handleSpecial(WxMpXmlMessage wxMessage)
throws Exception {
//TODO
return null;
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/handler/UnsubscribeHandler.java 0 → 100644
package com.yongqi.xinrenli.handler;
import me.chanjar.weixin.common.session.WxSessionManager;
import me.chanjar.weixin.mp.api.WxMpService;
import me.chanjar.weixin.mp.bean.message.WxMpXmlMessage;
import me.chanjar.weixin.mp.bean.message.WxMpXmlOutMessage;
import org.springframework.stereotype.Component;
import java.util.Map;
/**
* @author <a href="https://github.com/binarywang">Binary Wang</a>
*/
@Component
public class UnsubscribeHandler extends AbstractHandler {
@Override
public WxMpXmlOutMessage handle(WxMpXmlMessage wxMessage,
Map<String, Object> context, WxMpService wxMpService,
WxSessionManager sessionManager) {
String openId = wxMessage.getFromUser();
this.logger.info("取消关注用户 OPENID: " + openId);
// TODO 可以更新本地数据库为取消关注状态
return null;
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/mapper/ArticleMapper.java deleted 100644 → 0
package com.yongqi.xinrenli.mapper;
import com.yongqi.xinrenli.domain.Article;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
/**
* <p>
* 文章表 Mapper 接口
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Mapper
public interface ArticleMapper extends BaseMapper<Article> {
}
xinrenli/src/main/java/com/yongqi/xinrenli/mapper/CouponMapper.java deleted 100644 → 0
package com.yongqi.xinrenli.mapper;
import com.yongqi.xinrenli.domain.Coupon;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
/**
* <p>
* 优惠卷表 Mapper 接口
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Mapper
public interface CouponMapper extends BaseMapper<Coupon> {
}
xinrenli/src/main/java/com/yongqi/xinrenli/mapper/DbArticleMapper.java 0 → 100644
package com.yongqi.xinrenli.mapper;
import com.yongqi.xinrenli.domain.DbArticle;
import com.yongqi.xinrenli.domain.vo.DbArticleVo;
import com.ruoyi.common.core.mapper.BaseMapperPlus;
/**
* 文章Mapper接口
*
* @author zyf
* @date 2023-03-09
*/
public interface DbArticleMapper extends BaseMapperPlus<DbArticleMapper, DbArticle, DbArticleVo> {
}
xinrenli/src/main/java/com/yongqi/xinrenli/mapper/DbCouponMapper.java 0 → 100644
package com.yongqi.xinrenli.mapper;
import com.yongqi.xinrenli.domain.DbCoupon;
import com.yongqi.xinrenli.domain.vo.DbCouponVo;
import com.ruoyi.common.core.mapper.BaseMapperPlus;
/**
* 优惠卷Mapper接口
*
* @author zyf
* @date 2023-03-09
*/
public interface DbCouponMapper extends BaseMapperPlus<DbCouponMapper, DbCoupon, DbCouponVo> {
}
xinrenli/src/main/java/com/yongqi/xinrenli/mapper/DbFileMapper.java 0 → 100644
package com.yongqi.xinrenli.mapper;
import com.yongqi.xinrenli.domain.DbFile;
import com.yongqi.xinrenli.domain.vo.DbFileVo;
import com.ruoyi.common.core.mapper.BaseMapperPlus;
/**
* 文件Mapper接口
*
* @author zyf
* @date 2023-03-09
*/
public interface DbFileMapper extends BaseMapperPlus<DbFileMapper, DbFile, DbFileVo> {
}
xinrenli/src/main/java/com/yongqi/xinrenli/mapper/DbInviterMapper.java 0 → 100644
package com.yongqi.xinrenli.mapper;
import com.yongqi.xinrenli.domain.DbInviter;
import com.yongqi.xinrenli.domain.vo.DbInviterVo;
import com.ruoyi.common.core.mapper.BaseMapperPlus;
/**
* 邀请Mapper接口
*
* @author zyf
* @date 2023-03-09
*/
public interface DbInviterMapper extends BaseMapperPlus<DbInviterMapper, DbInviter, DbInviterVo> {
}
xinrenli/src/main/java/com/yongqi/xinrenli/mapper/DbOrderMapper.java 0 → 100644
package com.yongqi.xinrenli.mapper;
import com.yongqi.xinrenli.domain.DbOrder;
import com.yongqi.xinrenli.domain.vo.DbOrderVo;
import com.ruoyi.common.core.mapper.BaseMapperPlus;
/**
* 订单Mapper接口
*
* @author zyf
* @date 2023-03-09
*/
public interface DbOrderMapper extends BaseMapperPlus<DbOrderMapper, DbOrder, DbOrderVo> {
}
xinrenli/src/main/java/com/yongqi/xinrenli/mapper/DbUserCommentMapper.java 0 → 100644
package com.yongqi.xinrenli.mapper;
import com.yongqi.xinrenli.domain.DbUserComment;
import com.yongqi.xinrenli.domain.vo.DbUserCommentVo;
import com.ruoyi.common.core.mapper.BaseMapperPlus;
/**
* 用户评论Mapper接口
*
* @author zyf
* @date 2023-03-09
*/
public interface DbUserCommentMapper extends BaseMapperPlus<DbUserCommentMapper, DbUserComment, DbUserCommentVo> {
}
xinrenli/src/main/java/com/yongqi/xinrenli/mapper/DbUserCouponMapper.java 0 → 100644
package com.yongqi.xinrenli.mapper;
import com.yongqi.xinrenli.domain.DbUserCoupon;
import com.yongqi.xinrenli.domain.vo.DbUserCouponVo;
import com.ruoyi.common.core.mapper.BaseMapperPlus;
/**
* 用户优惠券关联Mapper接口
*
* @author zyf
* @date 2023-03-09
*/
public interface DbUserCouponMapper extends BaseMapperPlus<DbUserCouponMapper, DbUserCoupon, DbUserCouponVo> {
}
xinrenli/src/main/java/com/yongqi/xinrenli/mapper/DbUserDiscountMapper.java 0 → 100644
package com.yongqi.xinrenli.mapper;
import com.yongqi.xinrenli.domain.DbUserDiscount;
import com.yongqi.xinrenli.domain.vo.DbUserDiscountVo;
import com.ruoyi.common.core.mapper.BaseMapperPlus;
/**
* 用户折扣Mapper接口
*
* @author zyf
* @date 2023-03-09
*/
public interface DbUserDiscountMapper extends BaseMapperPlus<DbUserDiscountMapper, DbUserDiscount, DbUserDiscountVo> {
}
xinrenli/src/main/java/com/yongqi/xinrenli/mapper/DbUserFeedbackMapper.java 0 → 100644
package com.yongqi.xinrenli.mapper;
import com.yongqi.xinrenli.domain.DbUserFeedback;
import com.yongqi.xinrenli.domain.vo.DbUserFeedbackVo;
import com.ruoyi.common.core.mapper.BaseMapperPlus;
/**
* 用户反馈Mapper接口
*
* @author zyf
* @date 2023-03-09
*/
public interface DbUserFeedbackMapper extends BaseMapperPlus<DbUserFeedbackMapper, DbUserFeedback, DbUserFeedbackVo> {
}
xinrenli/src/main/java/com/yongqi/xinrenli/mapper/DbWxUserMapper.java 0 → 100644
package com.yongqi.xinrenli.mapper;
import com.yongqi.xinrenli.domain.DbWxUser;
import com.yongqi.xinrenli.domain.vo.DbWxUserVo;
import com.ruoyi.common.core.mapper.BaseMapperPlus;
/**
* 微信用户Mapper接口
*
* @author zyf
* @date 2023-03-09
*/
public interface DbWxUserMapper extends BaseMapperPlus<DbWxUserMapper, DbWxUser, DbWxUserVo> {
}
xinrenli/src/main/java/com/yongqi/xinrenli/mapper/OrderMapper.java deleted 100644 → 0
package com.yongqi.xinrenli.mapper;
import com.yongqi.xinrenli.domain.Order;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.springframework.stereotype.Repository;
/**
* <p>
* 订单表 Mapper 接口
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
public interface OrderMapper extends BaseMapper<Order> {
}
xinrenli/src/main/java/com/yongqi/xinrenli/mapper/UserCommentMapper.java deleted 100644 → 0
package com.yongqi.xinrenli.mapper;
import com.yongqi.xinrenli.domain.UserComment;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
/**
* <p>
* 用户评论表 Mapper 接口
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Mapper
public interface UserCommentMapper extends BaseMapper<UserComment> {
}
xinrenli/src/main/java/com/yongqi/xinrenli/mapper/UserFeedbackMapper.java deleted 100644 → 0
package com.yongqi.xinrenli.mapper;
import com.yongqi.xinrenli.domain.UserFeedback;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
/**
* <p>
* 用户反馈表 Mapper 接口
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Mapper
public interface UserFeedbackMapper extends BaseMapper<UserFeedback> {
}
xinrenli/src/main/java/com/yongqi/xinrenli/mapper/WxUserMapper.java deleted 100644 → 0
package com.yongqi.xinrenli.mapper;
import com.yongqi.xinrenli.domain.WxUser;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
/**
* <p>
* 微信用户 Mapper 接口
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Mapper
public interface WxUserMapper extends BaseMapper<WxUser> {
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/IArticleService.java deleted 100644 → 0
package com.yongqi.xinrenli.service;
import com.yongqi.xinrenli.domain.Article;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 文章表 服务类
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
public interface IArticleService extends IService<Article> {
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/ICouponService.java deleted 100644 → 0
package com.yongqi.xinrenli.service;
import com.yongqi.xinrenli.domain.Coupon;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 优惠卷表 服务类
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
public interface ICouponService extends IService<Coupon> {
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/IDbArticleService.java 0 → 100644
package com.yongqi.xinrenli.service;
import com.yongqi.xinrenli.domain.DbArticle;
import com.yongqi.xinrenli.domain.vo.DbArticleVo;
import com.yongqi.xinrenli.domain.bo.DbArticleBo;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 文章Service接口
*
* @author zyf
* @date 2023-03-09
*/
public interface IDbArticleService {
/**
* 查询文章
*/
DbArticleVo queryById(Long id);
/**
* 查询文章列表
*/
TableDataInfo<DbArticleVo> queryPageList(DbArticleBo bo, PageQuery pageQuery);
/**
* 查询文章列表
*/
List<DbArticleVo> queryList(DbArticleBo bo);
/**
* 新增文章
*/
Boolean insertByBo(DbArticleBo bo);
/**
* 修改文章
*/
Boolean updateByBo(DbArticleBo bo);
/**
* 校验并批量删除文章信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/IDbCouponService.java 0 → 100644
package com.yongqi.xinrenli.service;
import com.yongqi.xinrenli.domain.DbCoupon;
import com.yongqi.xinrenli.domain.vo.DbCouponVo;
import com.yongqi.xinrenli.domain.bo.DbCouponBo;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 优惠卷Service接口
*
* @author zyf
* @date 2023-03-09
*/
public interface IDbCouponService {
/**
* 查询优惠卷
*/
DbCouponVo queryById(Long id);
/**
* 查询优惠卷列表
*/
TableDataInfo<DbCouponVo> queryPageList(DbCouponBo bo, PageQuery pageQuery);
/**
* 查询优惠卷列表
*/
List<DbCouponVo> queryList(DbCouponBo bo);
/**
* 新增优惠卷
*/
Boolean insertByBo(DbCouponBo bo);
/**
* 修改优惠卷
*/
Boolean updateByBo(DbCouponBo bo);
/**
* 校验并批量删除优惠卷信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/IDbFileService.java 0 → 100644
package com.yongqi.xinrenli.service;
import com.yongqi.xinrenli.domain.DbFile;
import com.yongqi.xinrenli.domain.vo.DbFileVo;
import com.yongqi.xinrenli.domain.bo.DbFileBo;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 文件Service接口
*
* @author zyf
* @date 2023-03-09
*/
public interface IDbFileService {
/**
* 查询文件
*/
DbFileVo queryById(Long id);
/**
* 查询文件列表
*/
TableDataInfo<DbFileVo> queryPageList(DbFileBo bo, PageQuery pageQuery);
/**
* 查询文件列表
*/
List<DbFileVo> queryList(DbFileBo bo);
/**
* 新增文件
*/
Boolean insertByBo(DbFileBo bo);
/**
* 修改文件
*/
Boolean updateByBo(DbFileBo bo);
/**
* 校验并批量删除文件信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/IDbInviterService.java 0 → 100644
package com.yongqi.xinrenli.service;
import com.yongqi.xinrenli.domain.DbInviter;
import com.yongqi.xinrenli.domain.vo.DbInviterVo;
import com.yongqi.xinrenli.domain.bo.DbInviterBo;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 邀请Service接口
*
* @author zyf
* @date 2023-03-09
*/
public interface IDbInviterService {
/**
* 查询邀请
*/
DbInviterVo queryById(Long id);
/**
* 查询邀请列表
*/
TableDataInfo<DbInviterVo> queryPageList(DbInviterBo bo, PageQuery pageQuery);
/**
* 查询邀请列表
*/
List<DbInviterVo> queryList(DbInviterBo bo);
/**
* 新增邀请
*/
Boolean insertByBo(DbInviterBo bo);
/**
* 修改邀请
*/
Boolean updateByBo(DbInviterBo bo);
/**
* 校验并批量删除邀请信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/IDbOrderService.java 0 → 100644
package com.yongqi.xinrenli.service;
import com.yongqi.xinrenli.domain.DbOrder;
import com.yongqi.xinrenli.domain.vo.DbOrderVo;
import com.yongqi.xinrenli.domain.bo.DbOrderBo;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 订单Service接口
*
* @author zyf
* @date 2023-03-09
*/
public interface IDbOrderService {
/**
* 查询订单
*/
DbOrderVo queryById(Long id);
/**
* 查询订单列表
*/
TableDataInfo<DbOrderVo> queryPageList(DbOrderBo bo, PageQuery pageQuery);
/**
* 查询订单列表
*/
List<DbOrderVo> queryList(DbOrderBo bo);
/**
* 新增订单
*/
Boolean insertByBo(DbOrderBo bo);
/**
* 修改订单
*/
Boolean updateByBo(DbOrderBo bo);
/**
* 校验并批量删除订单信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/IDbUserCommentService.java 0 → 100644
package com.yongqi.xinrenli.service;
import com.yongqi.xinrenli.domain.DbUserComment;
import com.yongqi.xinrenli.domain.vo.DbUserCommentVo;
import com.yongqi.xinrenli.domain.bo.DbUserCommentBo;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 用户评论Service接口
*
* @author zyf
* @date 2023-03-09
*/
public interface IDbUserCommentService {
/**
* 查询用户评论
*/
DbUserCommentVo queryById(Long id);
/**
* 查询用户评论列表
*/
TableDataInfo<DbUserCommentVo> queryPageList(DbUserCommentBo bo, PageQuery pageQuery);
/**
* 查询用户评论列表
*/
List<DbUserCommentVo> queryList(DbUserCommentBo bo);
/**
* 新增用户评论
*/
Boolean insertByBo(DbUserCommentBo bo);
/**
* 修改用户评论
*/
Boolean updateByBo(DbUserCommentBo bo);
/**
* 校验并批量删除用户评论信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/IDbUserCouponService.java 0 → 100644
package com.yongqi.xinrenli.service;
import com.yongqi.xinrenli.domain.DbUserCoupon;
import com.yongqi.xinrenli.domain.vo.DbUserCouponVo;
import com.yongqi.xinrenli.domain.bo.DbUserCouponBo;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 用户优惠券关联Service接口
*
* @author zyf
* @date 2023-03-09
*/
public interface IDbUserCouponService {
/**
* 查询用户优惠券关联
*/
DbUserCouponVo queryById(Long id);
/**
* 查询用户优惠券关联列表
*/
TableDataInfo<DbUserCouponVo> queryPageList(DbUserCouponBo bo, PageQuery pageQuery);
/**
* 查询用户优惠券关联列表
*/
List<DbUserCouponVo> queryList(DbUserCouponBo bo);
/**
* 新增用户优惠券关联
*/
Boolean insertByBo(DbUserCouponBo bo);
/**
* 修改用户优惠券关联
*/
Boolean updateByBo(DbUserCouponBo bo);
/**
* 校验并批量删除用户优惠券关联信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/IDbUserDiscountService.java 0 → 100644
package com.yongqi.xinrenli.service;
import com.yongqi.xinrenli.domain.DbUserDiscount;
import com.yongqi.xinrenli.domain.vo.DbUserDiscountVo;
import com.yongqi.xinrenli.domain.bo.DbUserDiscountBo;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 用户折扣Service接口
*
* @author zyf
* @date 2023-03-09
*/
public interface IDbUserDiscountService {
/**
* 查询用户折扣
*/
DbUserDiscountVo queryById(Long id);
/**
* 查询用户折扣列表
*/
TableDataInfo<DbUserDiscountVo> queryPageList(DbUserDiscountBo bo, PageQuery pageQuery);
/**
* 查询用户折扣列表
*/
List<DbUserDiscountVo> queryList(DbUserDiscountBo bo);
/**
* 新增用户折扣
*/
Boolean insertByBo(DbUserDiscountBo bo);
/**
* 修改用户折扣
*/
Boolean updateByBo(DbUserDiscountBo bo);
/**
* 校验并批量删除用户折扣信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/IDbUserFeedbackService.java 0 → 100644
package com.yongqi.xinrenli.service;
import com.yongqi.xinrenli.domain.DbUserFeedback;
import com.yongqi.xinrenli.domain.vo.DbUserFeedbackVo;
import com.yongqi.xinrenli.domain.bo.DbUserFeedbackBo;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 用户反馈Service接口
*
* @author zyf
* @date 2023-03-09
*/
public interface IDbUserFeedbackService {
/**
* 查询用户反馈
*/
DbUserFeedbackVo queryById(Long id);
/**
* 查询用户反馈列表
*/
TableDataInfo<DbUserFeedbackVo> queryPageList(DbUserFeedbackBo bo, PageQuery pageQuery);
/**
* 查询用户反馈列表
*/
List<DbUserFeedbackVo> queryList(DbUserFeedbackBo bo);
/**
* 新增用户反馈
*/
Boolean insertByBo(DbUserFeedbackBo bo);
/**
* 修改用户反馈
*/
Boolean updateByBo(DbUserFeedbackBo bo);
/**
* 校验并批量删除用户反馈信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/IDbWxUserService.java 0 → 100644
package com.yongqi.xinrenli.service;
import com.yongqi.xinrenli.domain.DbWxUser;
import com.yongqi.xinrenli.domain.vo.DbWxUserVo;
import com.yongqi.xinrenli.domain.bo.DbWxUserBo;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 微信用户Service接口
*
* @author zyf
* @date 2023-03-09
*/
public interface IDbWxUserService {
/**
* 查询微信用户
*/
DbWxUserVo queryById(Long id);
/**
* 查询微信用户列表
*/
TableDataInfo<DbWxUserVo> queryPageList(DbWxUserBo bo, PageQuery pageQuery);
/**
* 查询微信用户列表
*/
List<DbWxUserVo> queryList(DbWxUserBo bo);
/**
* 新增微信用户
*/
Boolean insertByBo(DbWxUserBo bo);
/**
* 修改微信用户
*/
Boolean updateByBo(DbWxUserBo bo);
/**
* 校验并批量删除微信用户信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/IOrderService.java deleted 100644 → 0
package com.yongqi.xinrenli.service;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yongqi.xinrenli.domain.Order;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yongqi.xinrenli.domain.bo.OrderBo;
import com.yongqi.xinrenli.domain.vo.OrderVo;
import java.util.List;
/**
* <p>
* 订单表 服务类
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
public interface IOrderService extends IService<Order> {
/**
* 新增用户需求订单
* @param orderBo
* @return
*/
boolean addOrder(OrderBo orderBo);
/**
* 取消订单通过id
* @param id
* @return
*/
boolean cancelOrderById(Long id);
/**
* 修改订单信息
* @param orderBo
* @return
*/
boolean updateOrder(OrderBo orderBo);
/**
* 通过id查询订单详情
* @param id
* @return
*/
OrderVo getOrderById(Long id);
/**
* 判断上传图片 视频 语音是否都为空
* @param order
* @return
*/
boolean isAllEmpty(OrderBo order);
/**
* 条件分页查询
* @param orderBo
* @return
*/
Page<OrderVo> getOrderByPage(OrderBo orderBo);
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/IUserCommentService.java deleted 100644 → 0
package com.yongqi.xinrenli.service;
import com.yongqi.xinrenli.domain.UserComment;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 用户评论表 服务类
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
public interface IUserCommentService extends IService<UserComment> {
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/IUserFeedbackService.java deleted 100644 → 0
package com.yongqi.xinrenli.service;
import com.yongqi.xinrenli.domain.UserFeedback;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 用户反馈表 服务类
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
public interface IUserFeedbackService extends IService<UserFeedback> {
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/IWxUserService.java deleted 100644 → 0
package com.yongqi.xinrenli.service;
import com.yongqi.xinrenli.domain.WxUser;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 微信用户 服务类
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
public interface IWxUserService extends IService<WxUser> {
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/impl/ArticleServiceImpl.java deleted 100644 → 0
package com.yongqi.xinrenli.service.impl;
import com.yongqi.xinrenli.domain.Article;
import com.yongqi.xinrenli.mapper.ArticleMapper;
import com.yongqi.xinrenli.service.IArticleService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 文章表 服务实现类
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Service
public class ArticleServiceImpl extends ServiceImpl<ArticleMapper, Article> implements IArticleService {
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/impl/CouponServiceImpl.java deleted 100644 → 0
package com.yongqi.xinrenli.service.impl;
import com.yongqi.xinrenli.domain.Coupon;
import com.yongqi.xinrenli.mapper.CouponMapper;
import com.yongqi.xinrenli.mapper.OrderMapper;
import com.yongqi.xinrenli.service.ICouponService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
* <p>
* 优惠卷表 服务实现类
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Service
public class CouponServiceImpl extends ServiceImpl<CouponMapper, Coupon> implements ICouponService {
@Autowired
private OrderMapper orderMapper;
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/impl/DbArticleServiceImpl.java 0 → 100644
package com.yongqi.xinrenli.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.yongqi.xinrenli.domain.bo.DbArticleBo;
import com.yongqi.xinrenli.domain.vo.DbArticleVo;
import com.yongqi.xinrenli.domain.DbArticle;
import com.yongqi.xinrenli.mapper.DbArticleMapper;
import com.yongqi.xinrenli.service.IDbArticleService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 文章Service业务层处理
*
* @author zyf
* @date 2023-03-09
*/
@RequiredArgsConstructor
@Service
public class DbArticleServiceImpl implements IDbArticleService {
private final DbArticleMapper baseMapper;
/**
* 查询文章
*/
@Override
public DbArticleVo queryById(Long id) {
return baseMapper.selectVoById(id);
}
/**
* 查询文章列表
*/
@Override
public TableDataInfo<DbArticleVo> queryPageList(DbArticleBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<DbArticle> lqw = buildQueryWrapper(bo);
Page<DbArticleVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询文章列表
*/
@Override
public List<DbArticleVo> queryList(DbArticleBo bo) {
LambdaQueryWrapper<DbArticle> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<DbArticle> buildQueryWrapper(DbArticleBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<DbArticle> lqw = Wrappers.lambdaQuery();
lqw.eq(StringUtils.isNotBlank(bo.getTitle()), DbArticle::getTitle, bo.getTitle());
lqw.eq(StringUtils.isNotBlank(bo.getContent()), DbArticle::getContent, bo.getContent());
lqw.eq(StringUtils.isNotBlank(bo.getCreateUser()), DbArticle::getCreateUser, bo.getCreateUser());
lqw.eq(StringUtils.isNotBlank(bo.getModifyUser()), DbArticle::getModifyUser, bo.getModifyUser());
lqw.eq(bo.getModifyTime() != null, DbArticle::getModifyTime, bo.getModifyTime());
lqw.eq(bo.getDeleteStatus() != null, DbArticle::getDeleteStatus, bo.getDeleteStatus());
return lqw;
}
/**
* 新增文章
*/
@Override
public Boolean insertByBo(DbArticleBo bo) {
DbArticle add = BeanUtil.toBean(bo, DbArticle.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改文章
*/
@Override
public Boolean updateByBo(DbArticleBo bo) {
DbArticle update = BeanUtil.toBean(bo, DbArticle.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(DbArticle entity) {
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除文章
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if (isValid) {
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/impl/DbCouponServiceImpl.java 0 → 100644
package com.yongqi.xinrenli.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.yongqi.xinrenli.domain.bo.DbCouponBo;
import com.yongqi.xinrenli.domain.vo.DbCouponVo;
import com.yongqi.xinrenli.domain.DbCoupon;
import com.yongqi.xinrenli.mapper.DbCouponMapper;
import com.yongqi.xinrenli.service.IDbCouponService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 优惠卷Service业务层处理
*
* @author zyf
* @date 2023-03-09
*/
@RequiredArgsConstructor
@Service
public class DbCouponServiceImpl implements IDbCouponService {
private final DbCouponMapper baseMapper;
/**
* 查询优惠卷
*/
@Override
public DbCouponVo queryById(Long id) {
return baseMapper.selectVoById(id);
}
/**
* 查询优惠卷列表
*/
@Override
public TableDataInfo<DbCouponVo> queryPageList(DbCouponBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<DbCoupon> lqw = buildQueryWrapper(bo);
Page<DbCouponVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询优惠卷列表
*/
@Override
public List<DbCouponVo> queryList(DbCouponBo bo) {
LambdaQueryWrapper<DbCoupon> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<DbCoupon> buildQueryWrapper(DbCouponBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<DbCoupon> lqw = Wrappers.lambdaQuery();
lqw.eq(StringUtils.isNotBlank(bo.getCouponType()), DbCoupon::getCouponType, bo.getCouponType());
lqw.eq(StringUtils.isNotBlank(bo.getFullSubtraction()), DbCoupon::getFullSubtraction, bo.getFullSubtraction());
lqw.eq(bo.getMinUsed() != null, DbCoupon::getMinUsed, bo.getMinUsed());
lqw.eq(bo.getEffectiveTime() != null, DbCoupon::getEffectiveTime, bo.getEffectiveTime());
lqw.eq(bo.getFailureTime() != null, DbCoupon::getFailureTime, bo.getFailureTime());
lqw.eq(StringUtils.isNotBlank(bo.getCreateUser()), DbCoupon::getCreateUser, bo.getCreateUser());
lqw.eq(StringUtils.isNotBlank(bo.getModifyUser()), DbCoupon::getModifyUser, bo.getModifyUser());
lqw.eq(bo.getModifyTime() != null, DbCoupon::getModifyTime, bo.getModifyTime());
lqw.eq(bo.getDeleteStatus() != null, DbCoupon::getDeleteStatus, bo.getDeleteStatus());
return lqw;
}
/**
* 新增优惠卷
*/
@Override
public Boolean insertByBo(DbCouponBo bo) {
DbCoupon add = BeanUtil.toBean(bo, DbCoupon.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改优惠卷
*/
@Override
public Boolean updateByBo(DbCouponBo bo) {
DbCoupon update = BeanUtil.toBean(bo, DbCoupon.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(DbCoupon entity) {
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除优惠卷
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if (isValid) {
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/impl/DbFileServiceImpl.java 0 → 100644
package com.yongqi.xinrenli.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.yongqi.xinrenli.domain.bo.DbFileBo;
import com.yongqi.xinrenli.domain.vo.DbFileVo;
import com.yongqi.xinrenli.domain.DbFile;
import com.yongqi.xinrenli.mapper.DbFileMapper;
import com.yongqi.xinrenli.service.IDbFileService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 文件Service业务层处理
*
* @author zyf
* @date 2023-03-09
*/
@RequiredArgsConstructor
@Service
public class DbFileServiceImpl implements IDbFileService {
private final DbFileMapper baseMapper;
/**
* 查询文件
*/
@Override
public DbFileVo queryById(Long id) {
return baseMapper.selectVoById(id);
}
/**
* 查询文件列表
*/
@Override
public TableDataInfo<DbFileVo> queryPageList(DbFileBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<DbFile> lqw = buildQueryWrapper(bo);
Page<DbFileVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询文件列表
*/
@Override
public List<DbFileVo> queryList(DbFileBo bo) {
LambdaQueryWrapper<DbFile> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<DbFile> buildQueryWrapper(DbFileBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<DbFile> lqw = Wrappers.lambdaQuery();
lqw.eq(StringUtils.isNotBlank(bo.getServiceType()), DbFile::getServiceType, bo.getServiceType());
lqw.eq(StringUtils.isNotBlank(bo.getUrl()), DbFile::getUrl, bo.getUrl());
lqw.eq(StringUtils.isNotBlank(bo.getFileType()), DbFile::getFileType, bo.getFileType());
lqw.eq(bo.getSort() != null, DbFile::getSort, bo.getSort());
lqw.eq(bo.getDeleteStatus() != null, DbFile::getDeleteStatus, bo.getDeleteStatus());
lqw.like(StringUtils.isNotBlank(bo.getCreateName()), DbFile::getCreateName, bo.getCreateName());
lqw.eq(bo.getModifyTime() != null, DbFile::getModifyTime, bo.getModifyTime());
lqw.like(StringUtils.isNotBlank(bo.getModifyName()), DbFile::getModifyName, bo.getModifyName());
return lqw;
}
/**
* 新增文件
*/
@Override
public Boolean insertByBo(DbFileBo bo) {
DbFile add = BeanUtil.toBean(bo, DbFile.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改文件
*/
@Override
public Boolean updateByBo(DbFileBo bo) {
DbFile update = BeanUtil.toBean(bo, DbFile.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(DbFile entity) {
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除文件
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if (isValid) {
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/impl/DbInviterServiceImpl.java 0 → 100644
package com.yongqi.xinrenli.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.yongqi.xinrenli.domain.bo.DbInviterBo;
import com.yongqi.xinrenli.domain.vo.DbInviterVo;
import com.yongqi.xinrenli.domain.DbInviter;
import com.yongqi.xinrenli.mapper.DbInviterMapper;
import com.yongqi.xinrenli.service.IDbInviterService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 邀请Service业务层处理
*
* @author zyf
* @date 2023-03-09
*/
@RequiredArgsConstructor
@Service
public class DbInviterServiceImpl implements IDbInviterService {
private final DbInviterMapper baseMapper;
/**
* 查询邀请
*/
@Override
public DbInviterVo queryById(Long id) {
return baseMapper.selectVoById(id);
}
/**
* 查询邀请列表
*/
@Override
public TableDataInfo<DbInviterVo> queryPageList(DbInviterBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<DbInviter> lqw = buildQueryWrapper(bo);
Page<DbInviterVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询邀请列表
*/
@Override
public List<DbInviterVo> queryList(DbInviterBo bo) {
LambdaQueryWrapper<DbInviter> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<DbInviter> buildQueryWrapper(DbInviterBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<DbInviter> lqw = Wrappers.lambdaQuery();
lqw.eq(bo.getInviterId() != null, DbInviter::getInviterId, bo.getInviterId());
lqw.like(StringUtils.isNotBlank(bo.getInviterName()), DbInviter::getInviterName, bo.getInviterName());
lqw.eq(bo.getInviteeId() != null, DbInviter::getInviteeId, bo.getInviteeId());
lqw.like(StringUtils.isNotBlank(bo.getInviteeName()), DbInviter::getInviteeName, bo.getInviteeName());
lqw.eq(bo.getStatus() != null, DbInviter::getStatus, bo.getStatus());
return lqw;
}
/**
* 新增邀请
*/
@Override
public Boolean insertByBo(DbInviterBo bo) {
DbInviter add = BeanUtil.toBean(bo, DbInviter.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改邀请
*/
@Override
public Boolean updateByBo(DbInviterBo bo) {
DbInviter update = BeanUtil.toBean(bo, DbInviter.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(DbInviter entity) {
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除邀请
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if (isValid) {
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/impl/DbOrderServiceImpl.java 0 → 100644
package com.yongqi.xinrenli.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.yongqi.xinrenli.domain.bo.DbOrderBo;
import com.yongqi.xinrenli.domain.vo.DbOrderVo;
import com.yongqi.xinrenli.domain.DbOrder;
import com.yongqi.xinrenli.mapper.DbOrderMapper;
import com.yongqi.xinrenli.service.IDbOrderService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 订单Service业务层处理
*
* @author zyf
* @date 2023-03-09
*/
@RequiredArgsConstructor
@Service
public class DbOrderServiceImpl implements IDbOrderService {
private final DbOrderMapper baseMapper;
/**
* 查询订单
*/
@Override
public DbOrderVo queryById(Long id) {
return baseMapper.selectVoById(id);
}
/**
* 查询订单列表
*/
@Override
public TableDataInfo<DbOrderVo> queryPageList(DbOrderBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<DbOrder> lqw = buildQueryWrapper(bo);
Page<DbOrderVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询订单列表
*/
@Override
public List<DbOrderVo> queryList(DbOrderBo bo) {
LambdaQueryWrapper<DbOrder> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<DbOrder> buildQueryWrapper(DbOrderBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<DbOrder> lqw = Wrappers.lambdaQuery();
lqw.eq(bo.getUserId() != null, DbOrder::getUserId, bo.getUserId());
lqw.eq(StringUtils.isNotBlank(bo.getTitle()), DbOrder::getTitle, bo.getTitle());
lqw.eq(StringUtils.isNotBlank(bo.getLinkman()), DbOrder::getLinkman, bo.getLinkman());
lqw.eq(StringUtils.isNotBlank(bo.getPhone()), DbOrder::getPhone, bo.getPhone());
lqw.eq(bo.getRepairTime() != null, DbOrder::getRepairTime, bo.getRepairTime());
lqw.eq(StringUtils.isNotBlank(bo.getRepairAddress()), DbOrder::getRepairAddress, bo.getRepairAddress());
lqw.eq(bo.getBudget() != null, DbOrder::getBudget, bo.getBudget());
lqw.eq(bo.getStatus() != null, DbOrder::getStatus, bo.getStatus());
lqw.eq(StringUtils.isNotBlank(bo.getCreateUser()), DbOrder::getCreateUser, bo.getCreateUser());
lqw.eq(StringUtils.isNotBlank(bo.getModifyUser()), DbOrder::getModifyUser, bo.getModifyUser());
lqw.eq(bo.getModifyTime() != null, DbOrder::getModifyTime, bo.getModifyTime());
lqw.eq(bo.getDeleteStatus() != null, DbOrder::getDeleteStatus, bo.getDeleteStatus());
return lqw;
}
/**
* 新增订单
*/
@Override
public Boolean insertByBo(DbOrderBo bo) {
DbOrder add = BeanUtil.toBean(bo, DbOrder.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改订单
*/
@Override
public Boolean updateByBo(DbOrderBo bo) {
DbOrder update = BeanUtil.toBean(bo, DbOrder.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(DbOrder entity) {
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除订单
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if (isValid) {
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/impl/DbUserCommentServiceImpl.java 0 → 100644
package com.yongqi.xinrenli.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.yongqi.xinrenli.domain.bo.DbUserCommentBo;
import com.yongqi.xinrenli.domain.vo.DbUserCommentVo;
import com.yongqi.xinrenli.domain.DbUserComment;
import com.yongqi.xinrenli.mapper.DbUserCommentMapper;
import com.yongqi.xinrenli.service.IDbUserCommentService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 用户评论Service业务层处理
*
* @author zyf
* @date 2023-03-09
*/
@RequiredArgsConstructor
@Service
public class DbUserCommentServiceImpl implements IDbUserCommentService {
private final DbUserCommentMapper baseMapper;
/**
* 查询用户评论
*/
@Override
public DbUserCommentVo queryById(Long id) {
return baseMapper.selectVoById(id);
}
/**
* 查询用户评论列表
*/
@Override
public TableDataInfo<DbUserCommentVo> queryPageList(DbUserCommentBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<DbUserComment> lqw = buildQueryWrapper(bo);
Page<DbUserCommentVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询用户评论列表
*/
@Override
public List<DbUserCommentVo> queryList(DbUserCommentBo bo) {
LambdaQueryWrapper<DbUserComment> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<DbUserComment> buildQueryWrapper(DbUserCommentBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<DbUserComment> lqw = Wrappers.lambdaQuery();
lqw.eq(bo.getArticleId() != null, DbUserComment::getArticleId, bo.getArticleId());
lqw.eq(bo.getUserId() != null, DbUserComment::getUserId, bo.getUserId());
lqw.eq(StringUtils.isNotBlank(bo.getContent()), DbUserComment::getContent, bo.getContent());
lqw.eq(StringUtils.isNotBlank(bo.getCreateUser()), DbUserComment::getCreateUser, bo.getCreateUser());
lqw.eq(StringUtils.isNotBlank(bo.getModifyUser()), DbUserComment::getModifyUser, bo.getModifyUser());
lqw.eq(bo.getModifyTime() != null, DbUserComment::getModifyTime, bo.getModifyTime());
lqw.eq(bo.getDeleteStatus() != null, DbUserComment::getDeleteStatus, bo.getDeleteStatus());
return lqw;
}
/**
* 新增用户评论
*/
@Override
public Boolean insertByBo(DbUserCommentBo bo) {
DbUserComment add = BeanUtil.toBean(bo, DbUserComment.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改用户评论
*/
@Override
public Boolean updateByBo(DbUserCommentBo bo) {
DbUserComment update = BeanUtil.toBean(bo, DbUserComment.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(DbUserComment entity) {
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除用户评论
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if (isValid) {
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/impl/DbUserCouponServiceImpl.java 0 → 100644
package com.yongqi.xinrenli.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.yongqi.xinrenli.domain.bo.DbUserCouponBo;
import com.yongqi.xinrenli.domain.vo.DbUserCouponVo;
import com.yongqi.xinrenli.domain.DbUserCoupon;
import com.yongqi.xinrenli.mapper.DbUserCouponMapper;
import com.yongqi.xinrenli.service.IDbUserCouponService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 用户优惠券关联Service业务层处理
*
* @author zyf
* @date 2023-03-09
*/
@RequiredArgsConstructor
@Service
public class DbUserCouponServiceImpl implements IDbUserCouponService {
private final DbUserCouponMapper baseMapper;
/**
* 查询用户优惠券关联
*/
@Override
public DbUserCouponVo queryById(Long id) {
return baseMapper.selectVoById(id);
}
/**
* 查询用户优惠券关联列表
*/
@Override
public TableDataInfo<DbUserCouponVo> queryPageList(DbUserCouponBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<DbUserCoupon> lqw = buildQueryWrapper(bo);
Page<DbUserCouponVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询用户优惠券关联列表
*/
@Override
public List<DbUserCouponVo> queryList(DbUserCouponBo bo) {
LambdaQueryWrapper<DbUserCoupon> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<DbUserCoupon> buildQueryWrapper(DbUserCouponBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<DbUserCoupon> lqw = Wrappers.lambdaQuery();
lqw.eq(bo.getCouponId() != null, DbUserCoupon::getCouponId, bo.getCouponId());
lqw.eq(bo.getUserId() != null, DbUserCoupon::getUserId, bo.getUserId());
lqw.eq(bo.getUseStatus() != null, DbUserCoupon::getUseStatus, bo.getUseStatus());
lqw.eq(bo.getModifyTime() != null, DbUserCoupon::getModifyTime, bo.getModifyTime());
return lqw;
}
/**
* 新增用户优惠券关联
*/
@Override
public Boolean insertByBo(DbUserCouponBo bo) {
DbUserCoupon add = BeanUtil.toBean(bo, DbUserCoupon.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改用户优惠券关联
*/
@Override
public Boolean updateByBo(DbUserCouponBo bo) {
DbUserCoupon update = BeanUtil.toBean(bo, DbUserCoupon.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(DbUserCoupon entity) {
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除用户优惠券关联
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if (isValid) {
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/impl/DbUserDiscountServiceImpl.java 0 → 100644
package com.yongqi.xinrenli.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.yongqi.xinrenli.domain.bo.DbUserDiscountBo;
import com.yongqi.xinrenli.domain.vo.DbUserDiscountVo;
import com.yongqi.xinrenli.domain.DbUserDiscount;
import com.yongqi.xinrenli.mapper.DbUserDiscountMapper;
import com.yongqi.xinrenli.service.IDbUserDiscountService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 用户折扣Service业务层处理
*
* @author zyf
* @date 2023-03-09
*/
@RequiredArgsConstructor
@Service
public class DbUserDiscountServiceImpl implements IDbUserDiscountService {
private final DbUserDiscountMapper baseMapper;
/**
* 查询用户折扣
*/
@Override
public DbUserDiscountVo queryById(Long id) {
return baseMapper.selectVoById(id);
}
/**
* 查询用户折扣列表
*/
@Override
public TableDataInfo<DbUserDiscountVo> queryPageList(DbUserDiscountBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<DbUserDiscount> lqw = buildQueryWrapper(bo);
Page<DbUserDiscountVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询用户折扣列表
*/
@Override
public List<DbUserDiscountVo> queryList(DbUserDiscountBo bo) {
LambdaQueryWrapper<DbUserDiscount> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<DbUserDiscount> buildQueryWrapper(DbUserDiscountBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<DbUserDiscount> lqw = Wrappers.lambdaQuery();
lqw.eq(bo.getUserId() != null, DbUserDiscount::getUserId, bo.getUserId());
lqw.eq(bo.getDiscountRatio() != null, DbUserDiscount::getDiscountRatio, bo.getDiscountRatio());
lqw.eq(bo.getUseStatus() != null, DbUserDiscount::getUseStatus, bo.getUseStatus());
lqw.eq(bo.getModifyTime() != null, DbUserDiscount::getModifyTime, bo.getModifyTime());
return lqw;
}
/**
* 新增用户折扣
*/
@Override
public Boolean insertByBo(DbUserDiscountBo bo) {
DbUserDiscount add = BeanUtil.toBean(bo, DbUserDiscount.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改用户折扣
*/
@Override
public Boolean updateByBo(DbUserDiscountBo bo) {
DbUserDiscount update = BeanUtil.toBean(bo, DbUserDiscount.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(DbUserDiscount entity) {
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除用户折扣
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if (isValid) {
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/impl/DbUserFeedbackServiceImpl.java 0 → 100644
package com.yongqi.xinrenli.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.yongqi.xinrenli.domain.bo.DbUserFeedbackBo;
import com.yongqi.xinrenli.domain.vo.DbUserFeedbackVo;
import com.yongqi.xinrenli.domain.DbUserFeedback;
import com.yongqi.xinrenli.mapper.DbUserFeedbackMapper;
import com.yongqi.xinrenli.service.IDbUserFeedbackService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 用户反馈Service业务层处理
*
* @author zyf
* @date 2023-03-09
*/
@RequiredArgsConstructor
@Service
public class DbUserFeedbackServiceImpl implements IDbUserFeedbackService {
private final DbUserFeedbackMapper baseMapper;
/**
* 查询用户反馈
*/
@Override
public DbUserFeedbackVo queryById(Long id) {
return baseMapper.selectVoById(id);
}
/**
* 查询用户反馈列表
*/
@Override
public TableDataInfo<DbUserFeedbackVo> queryPageList(DbUserFeedbackBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<DbUserFeedback> lqw = buildQueryWrapper(bo);
Page<DbUserFeedbackVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询用户反馈列表
*/
@Override
public List<DbUserFeedbackVo> queryList(DbUserFeedbackBo bo) {
LambdaQueryWrapper<DbUserFeedback> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<DbUserFeedback> buildQueryWrapper(DbUserFeedbackBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<DbUserFeedback> lqw = Wrappers.lambdaQuery();
lqw.eq(bo.getUserId() != null, DbUserFeedback::getUserId, bo.getUserId());
lqw.eq(StringUtils.isNotBlank(bo.getTitle()), DbUserFeedback::getTitle, bo.getTitle());
lqw.eq(StringUtils.isNotBlank(bo.getContent()), DbUserFeedback::getContent, bo.getContent());
lqw.eq(StringUtils.isNotBlank(bo.getCreateUser()), DbUserFeedback::getCreateUser, bo.getCreateUser());
lqw.eq(StringUtils.isNotBlank(bo.getModifyUser()), DbUserFeedback::getModifyUser, bo.getModifyUser());
lqw.eq(bo.getModifyTime() != null, DbUserFeedback::getModifyTime, bo.getModifyTime());
lqw.eq(bo.getDeleteStatus() != null, DbUserFeedback::getDeleteStatus, bo.getDeleteStatus());
return lqw;
}
/**
* 新增用户反馈
*/
@Override
public Boolean insertByBo(DbUserFeedbackBo bo) {
DbUserFeedback add = BeanUtil.toBean(bo, DbUserFeedback.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改用户反馈
*/
@Override
public Boolean updateByBo(DbUserFeedbackBo bo) {
DbUserFeedback update = BeanUtil.toBean(bo, DbUserFeedback.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(DbUserFeedback entity) {
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除用户反馈
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if (isValid) {
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/impl/DbWxUserServiceImpl.java 0 → 100644
package com.yongqi.xinrenli.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.yongqi.xinrenli.domain.bo.DbWxUserBo;
import com.yongqi.xinrenli.domain.vo.DbWxUserVo;
import com.yongqi.xinrenli.domain.DbWxUser;
import com.yongqi.xinrenli.mapper.DbWxUserMapper;
import com.yongqi.xinrenli.service.IDbWxUserService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 微信用户Service业务层处理
*
* @author zyf
* @date 2023-03-09
*/
@RequiredArgsConstructor
@Service
public class DbWxUserServiceImpl implements IDbWxUserService {
private final DbWxUserMapper baseMapper;
/**
* 查询微信用户
*/
@Override
public DbWxUserVo queryById(Long id) {
return baseMapper.selectVoById(id);
}
/**
* 查询微信用户列表
*/
@Override
public TableDataInfo<DbWxUserVo> queryPageList(DbWxUserBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<DbWxUser> lqw = buildQueryWrapper(bo);
Page<DbWxUserVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询微信用户列表
*/
@Override
public List<DbWxUserVo> queryList(DbWxUserBo bo) {
LambdaQueryWrapper<DbWxUser> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<DbWxUser> buildQueryWrapper(DbWxUserBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<DbWxUser> lqw = Wrappers.lambdaQuery();
lqw.eq(StringUtils.isNotBlank(bo.getOpenId()), DbWxUser::getOpenId, bo.getOpenId());
lqw.eq(bo.getHeadOrNot() != null, DbWxUser::getHeadOrNot, bo.getHeadOrNot());
lqw.like(StringUtils.isNotBlank(bo.getNickname()), DbWxUser::getNickname, bo.getNickname());
lqw.eq(bo.getSex() != null, DbWxUser::getSex, bo.getSex());
lqw.eq(StringUtils.isNotBlank(bo.getProvince()), DbWxUser::getProvince, bo.getProvince());
lqw.eq(StringUtils.isNotBlank(bo.getCity()), DbWxUser::getCity, bo.getCity());
lqw.eq(StringUtils.isNotBlank(bo.getCountry()), DbWxUser::getCountry, bo.getCountry());
lqw.eq(StringUtils.isNotBlank(bo.getHeadImgUrl()), DbWxUser::getHeadImgUrl, bo.getHeadImgUrl());
lqw.eq(StringUtils.isNotBlank(bo.getUnionId()), DbWxUser::getUnionId, bo.getUnionId());
lqw.eq(StringUtils.isNotBlank(bo.getMobile()), DbWxUser::getMobile, bo.getMobile());
lqw.eq(StringUtils.isNotBlank(bo.getAuthMobile()), DbWxUser::getAuthMobile, bo.getAuthMobile());
lqw.eq(StringUtils.isNotBlank(bo.getMallCode()), DbWxUser::getMallCode, bo.getMallCode());
lqw.eq(StringUtils.isNotBlank(bo.getUserCode()), DbWxUser::getUserCode, bo.getUserCode());
lqw.eq(StringUtils.isNotBlank(bo.getSessionKey()), DbWxUser::getSessionKey, bo.getSessionKey());
lqw.eq(bo.getWechatSubscribe() != null, DbWxUser::getWechatSubscribe, bo.getWechatSubscribe());
lqw.eq(bo.getCancelSubscribe() != null, DbWxUser::getCancelSubscribe, bo.getCancelSubscribe());
lqw.eq(StringUtils.isNotBlank(bo.getWechatOriginalId()), DbWxUser::getWechatOriginalId, bo.getWechatOriginalId());
lqw.eq(bo.getOrderNum() != null, DbWxUser::getOrderNum, bo.getOrderNum());
lqw.eq(bo.getCumulativeConsumption() != null, DbWxUser::getCumulativeConsumption, bo.getCumulativeConsumption());
lqw.eq(bo.getLastConsumptionTime() != null, DbWxUser::getLastConsumptionTime, bo.getLastConsumptionTime());
lqw.eq(StringUtils.isNotBlank(bo.getCreateCode()), DbWxUser::getCreateCode, bo.getCreateCode());
lqw.eq(bo.getModifyTime() != null, DbWxUser::getModifyTime, bo.getModifyTime());
lqw.eq(StringUtils.isNotBlank(bo.getModifyBy()), DbWxUser::getModifyBy, bo.getModifyBy());
lqw.eq(StringUtils.isNotBlank(bo.getModifyCode()), DbWxUser::getModifyCode, bo.getModifyCode());
lqw.eq(bo.getDeleteFlag() != null, DbWxUser::getDeleteFlag, bo.getDeleteFlag());
return lqw;
}
/**
* 新增微信用户
*/
@Override
public Boolean insertByBo(DbWxUserBo bo) {
DbWxUser add = BeanUtil.toBean(bo, DbWxUser.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改微信用户
*/
@Override
public Boolean updateByBo(DbWxUserBo bo) {
DbWxUser update = BeanUtil.toBean(bo, DbWxUser.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(DbWxUser entity) {
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除微信用户
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if (isValid) {
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/impl/OrderServiceImpl.java deleted 100644 → 0
package com.yongqi.xinrenli.service.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.json.JSON;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.yongqi.xinrenli.domain.Order;
import com.yongqi.xinrenli.domain.bo.OrderBo;
import com.yongqi.xinrenli.domain.vo.OrderVo;
import com.yongqi.xinrenli.mapper.OrderMapper;
import com.yongqi.xinrenli.service.IOrderService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.weaver.ast.Or;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
/**
* <p>
* 订单表 服务实现类
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Service
@Slf4j
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements IOrderService {
@Override
public boolean addOrder(OrderBo orderBo) {
Order order = BeanUtil.toBean(orderBo, Order.class);
//图片地址转为json数据存储
order.setImageSrc(JSONUtil.toJsonStr(orderBo.getImageSrc()));
return this.save(order);
}
@Override
public boolean cancelOrderById(Long id) {
return this.removeById(id);
}
@Override
public boolean updateOrder(OrderBo orderBo) {
Order order = BeanUtil.toBean(orderBo, Order.class);
//图片地址转为json数据存储
order.setImageSrc(JSONUtil.toJsonStr(orderBo.getImageSrc()));
//测试
log.info("wanglei-order:{}", order);
return this.updateById(order);
}
@Override
public OrderVo getOrderById(Long id) {
Order order = this.getById(id);
//若不存在则返回null
if (order == null) {
return null;
}
//将order转为vo
OrderVo orderVo = BeanUtil.toBean(order, OrderVo.class);
//vo中将Json转为列表
orderVo.setImageSrc(JSONUtil.toList(order.getImageSrc(), String.class));
return orderVo;
}
@Override
public Page<OrderVo> getOrderByPage(OrderBo orderBo) {
Page<Order> orderPage = new Page<>(orderBo.getCurrentPage(), orderBo.getPageSize());
Page<OrderVo> voPage = new Page<>(orderBo.getCurrentPage(), orderBo.getPageSize());
//创建查询条件
QueryWrapper<Order> wrapper = new QueryWrapper<>();
wrapper.lambda().like(null != orderBo.getLinkman() && !"".equals(orderBo.getLinkman()), Order::getLinkman, orderBo.getLinkman())
.like(null != orderBo.getPhone() && !"".equals(orderBo.getPhone()), Order::getPhone, orderBo.getPhone())
.eq(null != orderBo.getRepairTime(), Order::getRepairTime, orderBo.getRepairTime())
.eq(null != orderBo.getStatus(), Order::getStatus, orderBo.getStatus());
this.page(orderPage, wrapper);
List<Order> orderList = orderPage.getRecords();
List<OrderVo> voList = new ArrayList<>();
//遍历将图片地址转为列表 同时添加到voList
for (Order order : orderList) {
OrderVo orderVo = BeanUtil.toBean(order, OrderVo.class);
orderVo.setImageSrc(JSONUtil.toList(order.getImageSrc(), String.class));
voList.add(orderVo);
}
//copy属性
BeanUtil.copyProperties(orderPage, voPage);
voPage.setRecords(voList);
return voPage;
}
@Override
public boolean isAllEmpty(OrderBo order) {
int flag = 0;
if (order.getImageSrc() != null && !"".equals(order.getImageSrc()) && order.getImageSrc().size() != 0) {
flag++;
}
if (order.getVideoSrc() != null && !"".equals(order.getVideoSrc())) {
flag++;
}
if (order.getAudioSrc() != null && !"".equals(order.getAudioSrc())) {
flag++;
}
if (flag > 0) {
return false;
}
return true;
}
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/impl/UserCommentServiceImpl.java deleted 100644 → 0
package com.yongqi.xinrenli.service.impl;
import com.yongqi.xinrenli.domain.UserComment;
import com.yongqi.xinrenli.mapper.UserCommentMapper;
import com.yongqi.xinrenli.service.IUserCommentService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 用户评论表 服务实现类
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Service
public class UserCommentServiceImpl extends ServiceImpl<UserCommentMapper, UserComment> implements IUserCommentService {
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/impl/UserFeedbackServiceImpl.java deleted 100644 → 0
package com.yongqi.xinrenli.service.impl;
import com.yongqi.xinrenli.domain.UserFeedback;
import com.yongqi.xinrenli.mapper.UserFeedbackMapper;
import com.yongqi.xinrenli.service.IUserFeedbackService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 用户反馈表 服务实现类
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Service
public class UserFeedbackServiceImpl extends ServiceImpl<UserFeedbackMapper, UserFeedback> implements IUserFeedbackService {
}
xinrenli/src/main/java/com/yongqi/xinrenli/service/impl/WxUserServiceImpl.java deleted 100644 → 0
package com.yongqi.xinrenli.service.impl;
import com.yongqi.xinrenli.domain.WxUser;
import com.yongqi.xinrenli.mapper.WxUserMapper;
import com.yongqi.xinrenli.service.IWxUserService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 微信用户 服务实现类
* </p>
*
* @author wanglei
* @since 2023-03-02
*/
@Service
public class WxUserServiceImpl extends ServiceImpl<WxUserMapper, WxUser> implements IWxUserService {
}
xinrenli/src/main/java/com/yongqi/xinrenli/utils/JsonUtils.java 0 → 100644
package com.yongqi.xinrenli.utils;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
/**
* @author <a href="https://github.com/binarywang">Binary Wang</a>
*/
public class JsonUtils {
public static String toJson(Object obj) {
Gson gson = new GsonBuilder()
.setPrettyPrinting()
.disableHtmlEscaping()
.create();
return gson.toJson(obj);
}
}
xinrenli/src/main/resources/mapper/ArticleMapper.xml deleted 100644 → 0
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yongqi.xinrenli.mapper.ArticleMapper">
</mapper>
xinrenli/src/main/resources/mapper/CouponMapper.xml deleted 100644 → 0
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yongqi.xinrenli.mapper.CouponMapper">
</mapper>
xinrenli/src/main/resources/mapper/OrderMapper.xml deleted 100644 → 0
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yongqi.xinrenli.mapper.OrderMapper">
</mapper>
xinrenli/src/main/resources/mapper/UserCommentMapper.xml deleted 100644 → 0
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yongqi.xinrenli.mapper.UserCommentMapper">
</mapper>
xinrenli/src/main/resources/mapper/UserFeedbackMapper.xml deleted 100644 → 0
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yongqi.xinrenli.mapper.UserFeedbackMapper">
</mapper>
xinrenli/src/main/resources/mapper/WxUserMapper.xml deleted 100644 → 0
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yongqi.xinrenli.mapper.WxUserMapper">
</mapper>
xinrenli/src/main/resources/mapper/package-info.md deleted 100644 → 0
java包使用 `.` 分割 resource 目录使用 `/` 分割
<br>
此文件目的 防止文件夹粘连找不到 `xml` 文件
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment