Skip to content

向汉 / uc-engine

Go to a project
Toggle navigation
Toggle navigation pinning
Commit 3d32c2d8 3d32c2d8dddeb912dd910d902865b3631d1ef50d by xianghan@topdraw.cn
Options

初始化项目 

;
1 parent 35b568f7
Expand all
Inline Side-by-side
Showing 268 changed files with 4768 additions and 0 deletions
# 积分台账表
CREATE TABLE `uc_points_standing_book` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
`points_produce` bigint(20) NOT NULL COMMENT '积分生产',
`points_consume` bigint(20) NOT NULL COMMENT '积分消耗',
`points_available` bigint(20) NOT NULL COMMENT '可用总积分',
`points_expire` bigint(20) NOT NULL COMMENT '积分过期',
`day` varchar(16) DEFAULT NULL COMMENT '日期',
`create_time` datetime DEFAULT NULL COMMENT '创建时间',
`update_time` datetime DEFAULT NULL COMMENT '创建时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='积分台账表';
# 永久权益表
CREATE TABLE `uc_permanent_rights` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'ID',
`code` varchar(64) NOT NULL COMMENT '标识',
`name` varchar(255) NOT NULL COMMENT '名称',
`type` tinyint(4) DEFAULT NULL COMMENT '永久权益类型 0：vip；1：会员等级',
`level` tinyint(4) DEFAULT NULL COMMENT '等级（当权益类型为vip时，对应vip值，当权益类型为会员等级时，对应等级index）',
`item_discount` decimal(10,2) NOT NULL DEFAULT '0.00' COMMENT '商品折扣，10代表10% off，范围为0-100',
`extra_points` decimal(10,2) NOT NULL DEFAULT '0.00' COMMENT '额外积分比率，范围为0-1000',
`ad_disabled` tinyint(4) NOT NULL DEFAULT '0' COMMENT '免广告',
`extra_activity_ticket` tinyint(4) NOT NULL DEFAULT '0' COMMENT '额外活动参与机会',
`free_trial` tinyint(4) NOT NULL DEFAULT '0' COMMENT '免费试看',
`zone_sds` tinyint(4) NOT NULL DEFAULT '0' COMMENT '上电视专区权益',
`create_time` datetime DEFAULT NULL COMMENT '创建时间',
`update_time` datetime DEFAULT NULL COMMENT '更新时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='永久权益表';
CREATE TABLE `uc_points_standing_book` (
`id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键',
`points_produce` bigint NOT NULL COMMENT '积分生产',
`points_consume` bigint NOT NULL COMMENT '积分消耗',
`points_available` bigint NOT NULL COMMENT '可用总积分',
`points_expire` bigint NOT NULL COMMENT '积分过期',
`day` varchar(16) DEFAULT NULL COMMENT '日期',
`create_time` datetime DEFAULT NULL COMMENT '创建时间',
`update_time` datetime DEFAULT NULL COMMENT '创建时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='积分台账表'
#优惠券表
CREATE TABLE `m_coupon` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
`code` varchar(64) NOT NULL COMMENT '标识',
`title` varchar(255) NOT NULL COMMENT '名称',
`images` varchar(1024) DEFAULT NULL COMMENT '图片',
`stock` int(11) DEFAULT '-1' COMMENT '发行量，-1代表不限量',
`remain_stock` int(11) '-1' NULL COMMENT '剩余量，-1代表不限量',
`use_type` tinyint(4) DEFAULT '1' COMMENT '优惠形式：1：金额；2：折扣',
`denomination` decimal(10,2) DEFAULT NULL COMMENT '面额',
`discount` decimal(10,2) DEFAULT NULL COMMENT '折扣',
`user_range` tinyint(4) DEFAULT '2' COMMENT '适用用户范围：1：新用户；2：全体用户；3：指定用户分组',
`groups` varchar(1024) DEFAULT NULL COMMENT '用户分组，逗号分隔',
`collect_limit` tinyint(4) DEFAULT '1' COMMENT '限领次数 -1：无限次； >0：具体次数',
`threshold_type` tinyint(4) DEFAULT '1' COMMENT '适用门槛：1：无门槛；2：满减形式',
`amount_threshold` decimal(10,2) DEFAULT null COMMENT '满减门槛',
`item_range` tinyint(4) DEFAULT '1' COMMENT '产品范围：1：全部商品；2：指定商品',
`effect_type` tinyint(4) DEFAULT null COMMENT '生效形式：1：固定日期；2：相对日期',
`start_time` datetime DEFAULT NULL COMMENT '生效时间',
`expire_time` datetime DEFAULT NULL COMMENT '过期时间',
`valid_days` int(11) DEFAULT NULL COMMENT '自领取当日，几天内有效',
`description` varchar(255) DEFAULT NULL COMMENT '使用说明',
`status` tinyint(4) DEFAULT null COMMENT '状态 0：未开始，1:启用；2：停用',
`create_time` datetime DEFAULT NULL COMMENT '创建时间',
`update_time` datetime DEFAULT NULL COMMENT '更新时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT=' 优惠券表';
#优惠券
CREATE TABLE `m_coupon_history` (
`id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键',
`coupon_id` bigint DEFAULT NULL COMMENT '优惠券id',
`user_id` bigint DEFAULT NULL COMMENT '领券用户id',
`coupon_code` varchar(64) DEFAULT NULL COMMENT '优惠券code',
`user_nickname` varchar(255) DEFAULT NULL COMMENT '领取人昵称',
`receive_time` datetime DEFAULT NULL COMMENT '领取时间',
`expire_time` datetime DEFAULT NULL COMMENT '失效时间',
`use_status` int DEFAULT NULL COMMENT '使用状态 0：未使用；1：已使用；-1：已过期',
`use_time` datetime DEFAULT NULL COMMENT '使用时间',
`order_detail_id` bigint DEFAULT NULL COMMENT '订单详情id',
`create_time` datetime DEFAULT NULL COMMENT '创建时间',
`update_time` datetime DEFAULT NULL COMMENT '更新时间',
PRIMARY KEY (`id`) USING BTREE,
KEY `idx_member_id` (`user_id`) USING BTREE,
KEY `idx_coupon_id` (`coupon_id`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=134 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci ROW_FORMAT=DYNAMIC COMMENT='优惠券领取、使用历史记录表'
\ No newline at end of file
m_coupon
m_coupon_history
tr_rights
tr_rights_histroy
tr_task
tr_task_template
uc_exp_history
uc_exp_detail
uc_permanent_rights
uc_member_related_info
uc_member_address
uc_member_profile
uc_member_level
uc_member
uc_points_standing_book
uc_points_available
uc_points_detail_history
uc_points_detail
uc_user_weixin
uc_user_tv
\ No newline at end of file
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>member-service</artifactId>
<groupId>com.topdraw</groupId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>member-service-api</artifactId>
<properties>
</properties>
<dependencies>
<!--代码生成器-->
<dependency>
<groupId>com.topdraw</groupId>
<artifactId>code-generator</artifactId>
<version>3.1.0</version>
</dependency>
</dependencies>
</project>
\ No newline at end of file
package com.topdraw.module.mq;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.validation.constraints.NotNull;
import java.io.Serializable;
/**
*
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class DataSyncMsg implements Serializable {
// 事件类型(用户的实际操作)
@NotNull
private String eventType;
// 消息体
private MsgData msg;
// 其他属性
private String extraData;
/**
* 消息体
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public static class MsgData {
private String remarks; //备注
@NotNull
private Integer event; // 具体事件 行为事件类型 1：登录；2：观影；3：参与活动；4：订购；10：跨屏绑定；11：积分转移；30：积分兑换商品；98：系统操作；99：其他
@NotNull
private Long memberId; // 会员id
@NotNull
private Integer deviceType; //设备类型 1：大屏；2：小屏（微信）3.小屏（xx）
@NotNull
private String appCode; //用户对应的应用code
private Long accountId; // 账号id
private Long orderId;
private Long activityId;
private Long mediaId;
private Long itemId;
}
}
package com.topdraw.module.mq;
import lombok.Getter;
// 实体类型
@Getter
public enum EntityType {
// 用户
PERSON,
// 会员
MEMBER,
// 小屏-微信
WEIXIN_USER,
// 大屏
VIS_USER,
// 地址
PERSON_ADDRESS
}
package com.topdraw.module.mq;
// 关注的事件
public enum EventType {
// 关注
SUBSCRIBE,
// 取消关注
UN_SUBSCRIBE,
// 绑定
BIND,
// 取消绑定
UN_BIND,
// 变更主账号
C_M_ACCOUNT,
// 获取积分
GAIN_POINT,
// 消耗积分
CONSUME_POINT,
// 观影
VIEWING,
// 登录
LOGIN,
// 订购产品包
SUBSCRIBE_PRODUCT_PACKAGE
}
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>member-service</artifactId>
<groupId>com.topdraw</groupId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>member-service-impl</artifactId>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
<jjwt.version>0.9.1</jjwt.version>
</properties>
<dependencies>
<!--redisson-->
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson</artifactId>
<version>3.16.3</version>
</dependency>
<!--api-->
<dependency>
<groupId>com.topdraw</groupId>
<artifactId>member-service-api</artifactId>
<version>${parent.version}</version>
</dependency>
<!--代码生成器-->
<dependency>
<groupId>com.topdraw</groupId>
<artifactId>code-generator</artifactId>
<version>3.1.0</version>
</dependency>
<!-- Spring boot 热部署 : 此热部署会遇到 java.lang.ClassCastException 异常 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<optional>true</optional>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</dependency>
<!--Mysql依赖包，版本差异，需单独引入-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.26</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!-- 支持AES/CBC/PKCS7Padding，用于微信小程序登录数据解密 -->
<dependency>
<groupId>org.bouncycastle</groupId>
<artifactId>bcprov-jdk16</artifactId>
<version>1.46</version>
</dependency>
<!--消息队列相关依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
<!--重试-->
<dependency>
<groupId>org.springframework.retry</groupId>
<artifactId>spring-retry</artifactId>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
</dependency>
<dependency>
<groupId>commons-codec</groupId>
<artifactId>commons-codec</artifactId>
<version>1.9</version>
</dependency>
</dependencies>
<profiles>
<profile>
<!-- 本地开发环境 -->
<id>dev</id>
<properties>
<profiles.active>dev</profiles.active>
</properties>
<activation>
<!-- 默认的，不加参数时执行这个profile -->
<activeByDefault>true</activeByDefault>
</activation>
</profile>
<profile>
<!-- 生产环境 -->
<id>prod</id>
<properties>
<profiles.active>prod</profiles.active>
<modifier>-prod</modifier>
</properties>
</profile>
</profiles>
<build>
<finalName>member-service</finalName>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<fork>true</fork>
</configuration>
</plugin>
<!-- 跳过单元测试 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<configuration>
<skipTests>true</skipTests>
</configuration>
</plugin>
<!-- 复制指定配置文件到指定目录 -->
<plugin>
<artifactId>maven-resources-plugin</artifactId>
<executions>
<execution>
<id>copy-resources</id>
<phase>package</phase>
<goals>
<goal>copy-resources</goal>
</goals>
<configuration>
<resources>
<resource>
<directory>src/main/resources/config</directory>
<includes>
<include>application.yml</include>
<include>application-${profiles.active}.yml</include>
</includes>
</resource>
</resources>
<outputDirectory>${project.build.directory}/config</outputDirectory>
</configuration>
</execution>
</executions>
</plugin>
<!-- jar包内剔除所有配置文件 -->
<plugin>
<artifactId>maven-jar-plugin</artifactId>
<configuration>
<!--不打入jar包的文件类型或者路径-->
<excludes>
<exclude>config/**</exclude>
</excludes>
</configuration>
</plugin>
</plugins>
</build>
</project>
\ No newline at end of file
package com.topdraw;
import com.topdraw.utils.SpringContextHolder;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.context.annotation.Bean;
import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
import org.springframework.retry.annotation.EnableRetry;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.transaction.annotation.EnableTransactionManagement;
/**
* @author XiangHan
* @version 0.0.1
*/
@EnableJpaAuditing
@EnableAsync
@SpringBootApplication(exclude = {SecurityAutoConfiguration.class})
@EnableTransactionManagement
@EnableRetry
public class MemberServiceApplication extends SpringBootServletInitializer {
public static void main(String[] args) {
SpringApplication.run(MemberServiceApplication.class, args);
}
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
return builder.sources(MemberServiceApplication.class);
}
@Bean
public SpringContextHolder springContextHolder() {
return new SpringContextHolder();
}
}
package com.topdraw.aspect;
import com.alibaba.fastjson.JSON;
import com.topdraw.mq.domain.TableOperationMsg;
import com.topdraw.mq.producer.MessageProducer;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import javax.annotation.Resource;
import java.lang.reflect.Method;
@Component
@Slf4j
@Aspect
public class AsyncMqProducer {
private static final Logger LOG = LoggerFactory.getLogger(AsyncMqProducer.class);
@Autowired
MessageProducer messageProducer;
@Resource(name = "executorTask")
ThreadPoolTaskExecutor threadPoolTaskExecutor;
@Pointcut(value = "@annotation(asyncMqSend)")
public void sendMqMsg(AsyncMqSend asyncMqSend){
LOG.info("AsyncMqProducer ===>>> sendMqMsg ====>> start");
}
@After("sendMqMsg(asyncMqSend)")
public void doAfter(JoinPoint joinPoint, AsyncMqSend asyncMqSend){
LOG.info("AsyncMqProducer ===>>> doAfter ====>> start");
boolean open = asyncMqSend.open();
if (open) {
try {
this.doTask(joinPoint,asyncMqSend);
} catch (Throwable e) {
e.printStackTrace();
}
}
LOG.info("AsyncMqProducer ===>>> doAfter ====>> end ===>> " );
}
private void doTask(JoinPoint joinPoint, AsyncMqSend asyncMqSend) {
LOG.info("AsyncMqProducer ===>>> doTask ====>> start ===>> " );
String entityName = asyncMqSend.entityName();
String methodName = asyncMqSend.method();
Object defaultServiceImpl = joinPoint.getTarget();
String defaultServiceImplName = defaultServiceImpl.getClass().getName();
MethodSignature signature = (MethodSignature)joinPoint.getSignature();
Method method = signature.getMethod();
String defaultMethodName = method.getName();
Object[] args = joinPoint.getArgs();
Object arg = args[0];
String defaultEntityName = arg.getClass().getName();
TableOperationMsg tableOperationMsg = new TableOperationMsg();
tableOperationMsg.setMethodName(StringUtils.isEmpty(methodName)?defaultMethodName:methodName);
tableOperationMsg.setEntityBody(JSON.toJSONString(arg));
tableOperationMsg.setInterfaceName(defaultServiceImplName);
tableOperationMsg.setEntityName(StringUtils.isEmpty(entityName)?defaultEntityName:entityName);
boolean async = asyncMqSend.async();
if (async) {
// 异步
this.sendMqMessage(tableOperationMsg);
} else {
// 同步
this.sendMqMessage(tableOperationMsg);
}
LOG.info("AsyncMqProducer ===>>> doTask ====>> end ===>> " );
}
private void sendMqMessage(TableOperationMsg tableOperationMsg){
this.messageProducer.sendFanoutMessage(JSON.toJSONString(tableOperationMsg));
}
}
package com.topdraw.aspect;
import org.springframework.amqp.core.ExchangeTypes;
import java.lang.annotation.*;
/**
* 在对应的方法上添加此注解，表示对应方法结束后
* 进行异步发送消息到mq中
*
* @author XiangHan
* @date 2021-10-30
*/
@Documented
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface AsyncMqSend {
/** true:开启 false:关闭 */
boolean open() default true;
/** true:异步 false:同步 */
boolean async() default true;
/** 接口实现 */
String serviceImpl() default "";
/** 对应的方法 */
String method() default "";
/** 实体名 */
String entityName() default "";
/** 交换机 */
String exchangeName() default "";
/** 队列名 */
String routeKeyName() default "";
/**交换机类型 */
String exchangeType() default ExchangeTypes.DIRECT;
}
package com.topdraw.business.basicdata.coupon.domain;
import lombok.Data;
import lombok.experimental.Accessors;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import javax.persistence.*;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;
import java.sql.Timestamp;
import java.math.BigDecimal;
import java.io.Serializable;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Entity
@Data
@EntityListeners(AuditingEntityListener.class)
@Accessors(chain = true)
@Table(name="m_coupon")
public class Coupon implements Serializable {
// id
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
// 标识
@Column(name = "code", nullable = false)
private String code;
// 名称
@Column(name = "title", nullable = false)
private String title;
// 图片
@Column(name = "images")
private String images;
// 发行量，-1代表不限量
@Column(name = "stock")
private Integer stock;
// 剩余量，-1代表不限量
@Column(name = "remain_stock")
private Integer remainStock;
// 优惠形式：1：现金；2：折扣
@Column(name = "use_type")
private Integer useType;
// 面额
@Column(name = "denomination")
private BigDecimal denomination;
// 折扣
@Column(name = "discount")
private BigDecimal discount;
// 适用用户范围：1：新用户；2：全体用户
@Column(name = "user_range")
private Integer userRange;
// 限领次数 -1：无限次； >0：具体次数
@Column(name = "collect_limit")
private Integer collectLimit;
// 适用门槛：1：无门槛；2：满减形式
@Column(name = "threshold_type")
private Integer thresholdType;
// 满减门槛
@Column(name = "amount_threshold")
private BigDecimal amountThreshold;
// 产品范围：1：全部商品；2：指定商品
@Column(name = "item_range")
private Integer itemRange;
// 生效形式：1：固定日期；2：相对日期
@Column(name = "effect_type")
private Integer effectType;
// 生效时间
@Column(name = "start_time")
private Timestamp startTime;
// 过期时间
@Column(name = "expire_time")
private Timestamp expireTime;
// 自领取当日，几天内有效
@Column(name = "valid_days")
private Integer validDays;
// 使用说明
@Column(name = "description")
private String description;
// 状态0：未开始，1:启用；2：停用
@Column(name = "status")
private Integer status;
// 创建时间
@CreatedDate
@Column(name = "create_time")
private Timestamp createTime;
// 更新时间
@LastModifiedDate
@Column(name = "update_time")
private Timestamp updateTime;
public void copy(Coupon source){
BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
}
}
package com.topdraw.business.basicdata.coupon.history.domain;
import lombok.Data;
import lombok.experimental.Accessors;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import javax.persistence.*;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;
import java.sql.Timestamp;
import java.io.Serializable;
/**
* @author XiangHan
* @date 2021-10-23
*/
@Entity
@Data
@EntityListeners(AuditingEntityListener.class)
@Accessors(chain = true)
@Table(name="m_coupon_history")
public class CouponHistory implements Serializable {
// 主键
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
// 优惠券id
@Column(name = "coupon_id")
private Long couponId;
// 领券用户id（对应账号）
@Column(name = "user_id")
private Long userId;
// 优惠券code
@Column(name = "coupon_code")
private String couponCode;
// 领取人昵称
@Column(name = "user_nickname")
private String userNickname;
// 领取时间
@Column(name = "receive_time")
private Timestamp receiveTime;
// 失效时间
@Column(name = "expire_time")
private Timestamp expireTime;
// 使用状态 0：未使用；1：已使用；-1：已过期
@Column(name = "use_status")
private Integer useStatus;
// 使用时间
@Column(name = "use_time")
private Timestamp useTime;
// 订单详情id
@Column(name = "order_detail_id")
private Long orderDetailId;
// 创建时间
@CreatedDate
@Column(name = "create_time")
private Timestamp createTime;
// 更新时间
@LastModifiedDate
@Column(name = "update_time")
private Timestamp updateTime;
public void copy(CouponHistory source){
BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
}
}
package com.topdraw.business.basicdata.coupon.history.repository;
import com.topdraw.business.basicdata.coupon.history.domain.CouponHistory;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import java.sql.Timestamp;
import java.util.Optional;
/**
* @author XiangHan
* @date 2021-10-23
*/
public interface CouponHistoryRepository extends JpaRepository<CouponHistory, Long>, JpaSpecificationExecutor<CouponHistory> {
Long countByUserId(Long userId);
Long countByUserIdAndExpireTimeBefore(Long userId, Timestamp now);
Long countByUserIdAndExpireTimeBetween(Long userId, Timestamp now, Timestamp expireTime);
}
package com.topdraw.business.basicdata.coupon.history.rest;
import com.topdraw.common.ResultInfo;
import com.topdraw.annotation.Log;
import com.topdraw.business.basicdata.coupon.history.domain.CouponHistory;
import com.topdraw.business.basicdata.coupon.history.service.CouponHistoryService;
import com.topdraw.business.basicdata.coupon.history.service.dto.CouponHistoryQueryCriteria;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Pageable;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import io.swagger.annotations.*;
import java.io.IOException;
import javax.servlet.http.HttpServletResponse;
/**
* @author XiangHan
* @date 2021-10-23
*/
@Api(tags = "CouponHistory管理")
@RestController
@RequestMapping("/api/CouponHistory")
public class CouponHistoryController {
@Autowired
private CouponHistoryService CouponHistoryService;
@GetMapping
@ApiOperation("查询CouponHistory")
public ResultInfo getCouponHistorys(CouponHistoryQueryCriteria criteria, Pageable pageable) {
return ResultInfo.successPage(CouponHistoryService.queryAll(criteria,pageable));
}
@GetMapping(value = "/all")
@ApiOperation("查询所有CouponHistory")
public ResultInfo getCouponHistorys(CouponHistoryQueryCriteria criteria) {
return ResultInfo.success(CouponHistoryService.queryAll(criteria));
}
@Log
@PostMapping
@ApiOperation("新增CouponHistory")
public ResultInfo create(@Validated @RequestBody CouponHistory resources) {
CouponHistoryService.create(resources);
return ResultInfo.success();
}
@Log
@PutMapping
@ApiOperation("修改CouponHistory")
public ResultInfo update(@Validated @RequestBody CouponHistory resources) {
CouponHistoryService.update(resources);
return ResultInfo.success();
}
@Log
@DeleteMapping(value = "/{id}")
@ApiOperation("删除CouponHistory")
public ResultInfo delete(@PathVariable Long id) {
CouponHistoryService.delete(id);
return ResultInfo.success();
}
}
package com.topdraw.business.basicdata.coupon.history.service;
import com.topdraw.business.basicdata.coupon.history.domain.CouponHistory;
import com.topdraw.business.basicdata.coupon.history.service.dto.CouponHistoryDTO;
import com.topdraw.business.basicdata.coupon.history.service.dto.CouponHistoryQueryCriteria;
import org.springframework.data.domain.Pageable;
import java.sql.Timestamp;
import java.util.Map;
import java.util.List;
import java.io.IOException;
import javax.servlet.http.HttpServletResponse;
/**
* @author XiangHan
* @date 2021-10-23
*/
public interface CouponHistoryService {
/**
* 查询数据分页
* @param criteria 条件参数
* @param pageable 分页参数
* @return Map<String,Object>
*/
Map<String,Object> queryAll(CouponHistoryQueryCriteria criteria, Pageable pageable);
/**
* 查询所有数据不分页
* @param criteria 条件参数
* @return List<CouponHistoryDTO>
*/
List<CouponHistoryDTO> queryAll(CouponHistoryQueryCriteria criteria);
/**
* 根据ID查询
* @param id ID
* @return CouponHistoryDTO
*/
CouponHistoryDTO findById(Long id);
void create(CouponHistory resources);
void update(CouponHistory resources);
void delete(Long id);
Long countByUserId(Long userId);
Long countByUserIdAndExpireTimeBefore(Long userId, Timestamp now);
Long countByUserIdAndExpireTimeBetween(Long userId, Timestamp now, Timestamp expireTime);
}
package com.topdraw.business.basicdata.coupon.history.service.dto;
import lombok.Data;
import java.sql.Timestamp;
import java.io.Serializable;
/**
* @author XiangHan
* @date 2021-10-23
*/
@Data
public class CouponHistoryDTO implements Serializable {
// 主键
private Long id;
// 优惠券id
private Long couponId;
// 领券用户id（对应账号）
private Long userId;
// 优惠券code
private String couponCode;
// 领取人昵称
private String userNickname;
// 领取时间
private Timestamp receiveTime;
// 失效时间
private Timestamp expireTime;
// 使用状态 0：未使用；1：已使用；-1：已过期
private Integer useStatus;
// 使用时间
private Timestamp useTime;
// 订单详情id
private Long orderDetailId;
// 创建时间
private Timestamp createTime;
// 更新时间
private Timestamp updateTime;
}
package com.topdraw.business.basicdata.coupon.history.service.dto;
import lombok.Data;
import com.topdraw.annotation.Query;
/**
* @author XiangHan
* @date 2021-10-23
*/
@Data
public class CouponHistoryQueryCriteria{
}
package com.topdraw.business.basicdata.coupon.history.service.impl;
import com.topdraw.aspect.AsyncMqSend;
import com.topdraw.business.basicdata.coupon.history.domain.CouponHistory;
import com.topdraw.utils.ValidationUtil;
import com.topdraw.business.basicdata.coupon.history.repository.CouponHistoryRepository;
import com.topdraw.business.basicdata.coupon.history.service.CouponHistoryService;
import com.topdraw.business.basicdata.coupon.history.service.dto.CouponHistoryDTO;
import com.topdraw.business.basicdata.coupon.history.service.dto.CouponHistoryQueryCriteria;
import com.topdraw.business.basicdata.coupon.history.service.mapper.CouponHistoryMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.util.Assert;
import com.topdraw.utils.PageUtil;
import com.topdraw.utils.QueryHelp;
import java.sql.Timestamp;
import java.util.List;
import java.util.Map;
/**
* @author XiangHan
* @date 2021-10-23
*/
@Service
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
public class CouponHistoryServiceImpl implements CouponHistoryService {
@Autowired
private CouponHistoryRepository CouponHistoryRepository;
@Autowired
private CouponHistoryMapper CouponHistoryMapper;
@Override
public Map<String, Object> queryAll(CouponHistoryQueryCriteria criteria, Pageable pageable) {
Page<CouponHistory> page = CouponHistoryRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
return PageUtil.toPage(page.map(CouponHistoryMapper::toDto));
}
@Override
public List<CouponHistoryDTO> queryAll(CouponHistoryQueryCriteria criteria) {
return CouponHistoryMapper.toDto(CouponHistoryRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
}
@Override
public CouponHistoryDTO findById(Long id) {
CouponHistory CouponHistory = CouponHistoryRepository.findById(id).orElseGet(CouponHistory::new);
ValidationUtil.isNull(CouponHistory.getId(),"CouponHistory","id",id);
return CouponHistoryMapper.toDto(CouponHistory);
}
@Override
@Transactional(rollbackFor = Exception.class)
@AsyncMqSend()
public void create(CouponHistory resources) {
CouponHistoryRepository.save(resources);
}
@Override
@Transactional(rollbackFor = Exception.class)
@AsyncMqSend()
public void update(CouponHistory resources) {
CouponHistory CouponHistory = CouponHistoryRepository.findById(resources.getId()).orElseGet(CouponHistory::new);
ValidationUtil.isNull( CouponHistory.getId(),"CouponHistory","id",resources.getId());
CouponHistory.copy(resources);
CouponHistoryRepository.save(CouponHistory);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void delete(Long id) {
Assert.notNull(id, "The given id must not be null!");
CouponHistory CouponHistory = CouponHistoryRepository.findById(id).orElseThrow(
() -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", CouponHistory.class, id), 1));
CouponHistoryRepository.delete(CouponHistory);
}
@Override
public Long countByUserId(Long userId) {
return this.CouponHistoryRepository.countByUserId(userId);
}
@Override
public Long countByUserIdAndExpireTimeBefore(Long userId, Timestamp now) {
return this.CouponHistoryRepository.countByUserIdAndExpireTimeBefore(userId,now);
}
@Override
public Long countByUserIdAndExpireTimeBetween(Long userId, Timestamp now, Timestamp expireTime) {
return this.CouponHistoryRepository.countByUserIdAndExpireTimeBetween(userId,now,expireTime);
}
}
package com.topdraw.business.basicdata.coupon.history.service.mapper;
import com.topdraw.base.BaseMapper;
import com.topdraw.business.basicdata.coupon.history.domain.CouponHistory;
import com.topdraw.business.basicdata.coupon.history.service.dto.CouponHistoryDTO;
import org.mapstruct.Mapper;
import org.mapstruct.ReportingPolicy;
/**
* @author XiangHan
* @date 2021-10-23
*/
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface CouponHistoryMapper extends BaseMapper<CouponHistoryDTO, CouponHistory> {
}
package com.topdraw.business.basicdata.coupon.repository;
import com.topdraw.business.basicdata.coupon.domain.Coupon;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import java.util.Optional;
/**
* @author XiangHan
* @date 2021-10-22
*/
public interface CouponRepository extends JpaRepository<Coupon, Long>, JpaSpecificationExecutor<Coupon> {
Optional<Coupon> findFirstByCode(String code);
}
package com.topdraw.business.basicdata.coupon.rest;
import com.topdraw.common.ResultInfo;
import com.topdraw.annotation.Log;
import com.topdraw.business.basicdata.coupon.domain.Coupon;
import com.topdraw.business.basicdata.coupon.service.CouponService;
import com.topdraw.business.basicdata.coupon.service.dto.CouponQueryCriteria;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Pageable;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import io.swagger.annotations.*;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Api(tags = "Coupon管理")
@RestController
@RequestMapping("/api/Coupon")
public class CouponController {
@Autowired
private CouponService CouponService;
@GetMapping
@ApiOperation("查询Coupon")
public ResultInfo getCoupons(CouponQueryCriteria criteria, Pageable pageable) {
return ResultInfo.successPage(CouponService.queryAll(criteria,pageable));
}
@GetMapping(value = "/all")
@ApiOperation("查询所有Coupon")
public ResultInfo getCoupons(CouponQueryCriteria criteria) {
return ResultInfo.success(CouponService.queryAll(criteria));
}
@Log
@PostMapping
@ApiOperation("新增Coupon")
public ResultInfo create(@Validated @RequestBody Coupon resources) {
CouponService.create(resources);
return ResultInfo.success();
}
@Log
@PutMapping
@ApiOperation("修改Coupon")
public ResultInfo update(@Validated @RequestBody Coupon resources) {
CouponService.update(resources);
return ResultInfo.success();
}
@Log
@DeleteMapping(value = "/{id}")
@ApiOperation("删除Coupon")
public ResultInfo delete(@PathVariable Long id) {
CouponService.delete(id);
return ResultInfo.success();
}
@GetMapping(value = "/getByCode/{code}")
@ApiOperation(value = "根据标识查询")
public ResultInfo getByCode(@PathVariable String code) {
return ResultInfo.success(CouponService.getByCode(code));
}
}
package com.topdraw.business.basicdata.coupon.service;
import com.topdraw.business.basicdata.coupon.domain.Coupon;
import com.topdraw.business.basicdata.coupon.service.dto.CouponDTO;
import com.topdraw.business.basicdata.coupon.service.dto.CouponQueryCriteria;
import org.springframework.data.domain.Pageable;
import java.util.Map;
import java.util.List;
/**
* @author XiangHan
* @date 2021-10-22
*/
public interface CouponService {
/**
* 查询数据分页
* @param criteria 条件参数
* @param pageable 分页参数
* @return Map<String,Object>
*/
Map<String,Object> queryAll(CouponQueryCriteria criteria, Pageable pageable);
/**
* 查询所有数据不分页
* @param criteria 条件参数
* @return List<CouponDTO>
*/
List<CouponDTO> queryAll(CouponQueryCriteria criteria);
/**
* 根据ID查询
* @param id ID
* @return CouponDTO
*/
CouponDTO findById(Long id);
void create(Coupon resources);
void update(Coupon resources);
void delete(Long id);
/**
* Code校验
* @param code
* @return CouponDTO
*/
CouponDTO getByCode(String code);
}
package com.topdraw.business.basicdata.coupon.service.dto;
import lombok.Data;
import java.sql.Timestamp;
import java.math.BigDecimal;
import java.io.Serializable;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class CouponDTO implements Serializable {
// id
private Long id;
// 标识
private String code;
// 名称
private String title;
// 图片
private String images;
// 发行量，-1代表不限量
private Integer stock;
// 剩余量，-1代表不限量
private Integer remainStock;
// 优惠形式：1：现金；2：折扣
private Integer useType;
// 面额
private BigDecimal denomination;
// 折扣
private BigDecimal discount;
// 适用用户范围：1：新用户；2：全体用户
private Integer userRange;
// 限领次数 -1：无限次； >0：具体次数
private Integer collectLimit;
// 适用门槛：1：无门槛；2：满减形式
private Integer thresholdType;
// 满减门槛
private BigDecimal amountThreshold;
// 产品范围：1：全部商品；2：指定商品
private Integer itemRange;
// 生效形式：1：固定日期；2：相对日期
private Integer effectType;
// 生效时间
private Timestamp startTime;
// 过期时间
private Timestamp expireTime;
// 自领取当日，几天内有效
private Integer validDays;
// 使用说明
private String description;
// 状态0：未开始，1:启用；2：停用
private Integer status;
// 创建时间
private Timestamp createTime;
// 更新时间
private Timestamp updateTime;
}
package com.topdraw.business.basicdata.coupon.service.dto;
import lombok.Data;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class CouponQueryCriteria{
}
package com.topdraw.business.basicdata.coupon.service.impl;
import com.topdraw.aspect.AsyncMqSend;
import com.topdraw.business.basicdata.coupon.domain.Coupon;
import com.topdraw.util.RedissonUtil;
import com.topdraw.utils.ValidationUtil;
import com.topdraw.business.basicdata.coupon.repository.CouponRepository;
import com.topdraw.business.basicdata.coupon.service.CouponService;
import com.topdraw.business.basicdata.coupon.service.dto.CouponDTO;
import com.topdraw.business.basicdata.coupon.service.dto.CouponQueryCriteria;
import com.topdraw.business.basicdata.coupon.service.mapper.CouponMapper;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.util.Assert;
import com.topdraw.utils.PageUtil;
import com.topdraw.utils.QueryHelp;
import com.topdraw.utils.StringUtils;
import java.util.List;
import java.util.Map;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Service
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
public class CouponServiceImpl implements CouponService {
@Autowired
private CouponRepository CouponRepository;
@Autowired
private CouponMapper CouponMapper;
@Autowired
private RedissonClient redissonClient;
@Override
public Map<String, Object> queryAll(CouponQueryCriteria criteria, Pageable pageable) {
Page<Coupon> page = CouponRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
return PageUtil.toPage(page.map(CouponMapper::toDto));
}
@Override
public List<CouponDTO> queryAll(CouponQueryCriteria criteria) {
return CouponMapper.toDto(CouponRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
}
@Override
public CouponDTO findById(Long id) {
Coupon Coupon = CouponRepository.findById(id).orElseGet(Coupon::new);
ValidationUtil.isNull(Coupon.getId(),"Coupon","id",id);
return CouponMapper.toDto(Coupon);
}
@Override
@Transactional(rollbackFor = Exception.class)
@AsyncMqSend()
public void create(Coupon resources) {
CouponRepository.save(resources);
}
@Override
@Transactional(rollbackFor = Exception.class)
@AsyncMqSend()
public void update(Coupon resources) {
RLock rLock = this.redissonClient.getLock(resources.getId().toString());
try {
RedissonUtil.lock(rLock);
Coupon Coupon = CouponRepository.findById(resources.getId()).orElseGet(Coupon::new);
ValidationUtil.isNull( Coupon.getId(),"Coupon","id",resources.getId());
Coupon.copy(resources);
CouponRepository.save(Coupon);
} catch (Exception e) {
e.printStackTrace();
throw e;
} finally {
RedissonUtil.unlock(rLock);
}
}
@Override
@Transactional(rollbackFor = Exception.class)
@AsyncMqSend()
public void delete(Long id) {
Assert.notNull(id, "The given id must not be null!");
Coupon Coupon = CouponRepository.findById(id).orElseThrow(
() -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", Coupon.class, id), 1));
CouponRepository.delete(Coupon);
}
@Override
public CouponDTO getByCode(String code) {
return StringUtils.isNotEmpty(code) ? CouponMapper.toDto(CouponRepository.findFirstByCode(code).orElseGet(Coupon::new))
: new CouponDTO();
}
}
package com.topdraw.business.basicdata.coupon.service.mapper;
import com.topdraw.base.BaseMapper;
import com.topdraw.business.basicdata.coupon.domain.Coupon;
import com.topdraw.business.basicdata.coupon.service.dto.CouponDTO;
import org.mapstruct.Mapper;
import org.mapstruct.ReportingPolicy;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface CouponMapper extends BaseMapper<CouponDTO, Coupon> {
}
package com.topdraw.business.basicdata.exp.detail.domain;
import lombok.Data;
import lombok.experimental.Accessors;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import javax.persistence.*;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;
import java.sql.Timestamp;
import java.io.Serializable;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Entity
@Data
@EntityListeners(AuditingEntityListener.class)
@Accessors(chain = true)
@Table(name="uc_exp_detail")
public class ExpDetail implements Serializable {
// 主键
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
// 标识
@Column(name = "code", nullable = false)
private String code;
// 应用code
@Column(name = "app_code")
private String appCode;
// 会员id
@Column(name = "member_id", nullable = false)
private Long memberId;
// 账号id
@Column(name = "account_id")
private Long accountId;
// 原始成长值
@Column(name = "original_exp", nullable = false)
private Long originalExp;
// 结果成长值
@Column(name = "result_exp", nullable = false)
private Long resultExp;
// 成长值变化，一般为正数
@Column(name = "exp", nullable = false)
private Long exp;
// 设备类型 1：大屏；2：小屏（微信）3.小屏（xx）
@Column(name = "device_type", nullable = false)
private Integer deviceType;
// 行为事件类型 1：登录；2：观影；3：参与活动；4：订购；10：跨屏绑定；98：系统操作；99：其他
@Column(name = "evt_type", nullable = false)
private Integer evtType;
// 订单id（针对订购操作）
@Column(name = "order_id")
private Long orderId;
// 节目id（针对观影操作）
@Column(name = "media_id")
private Long mediaId;
// 活动id（针对参与活动）
@Column(name = "activity_id")
private Long activityId;
// 成长值变化描述，用于管理侧显示
@Column(name = "description", nullable = false)
private String description;
// 创建时间
@CreatedDate
@Column(name = "create_time")
private Timestamp createTime;
// 更新时间
@LastModifiedDate
@Column(name = "update_time")
private Timestamp updateTime;
public void copy(ExpDetail source){
BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
}
}
package com.topdraw.business.basicdata.exp.detail.repository;
import com.topdraw.business.basicdata.exp.detail.domain.ExpDetail;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import java.util.Optional;
/**
* @author XiangHan
* @date 2021-10-22
*/
public interface ExpDetailRepository extends JpaRepository<ExpDetail, Long>, JpaSpecificationExecutor<ExpDetail> {
Optional<ExpDetail> findFirstByCode(String code);
}
package com.topdraw.business.basicdata.exp.detail.rest;
import com.topdraw.common.ResultInfo;
import com.topdraw.annotation.Log;
import com.topdraw.business.basicdata.exp.detail.domain.ExpDetail;
import com.topdraw.business.basicdata.exp.detail.service.ExpDetailService;
import com.topdraw.business.basicdata.exp.detail.service.dto.ExpDetailQueryCriteria;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Pageable;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import io.swagger.annotations.*;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Api(tags = "ExpDetail管理")
@RestController
@RequestMapping("/api/ExpDetail")
public class ExpDetailController {
@Autowired
private ExpDetailService ExpDetailService;
@GetMapping
@ApiOperation("查询ExpDetail")
public ResultInfo getExpDetails(ExpDetailQueryCriteria criteria, Pageable pageable) {
return ResultInfo.successPage(ExpDetailService.queryAll(criteria,pageable));
}
@GetMapping(value = "/all")
@ApiOperation("查询所有ExpDetail")
public ResultInfo getExpDetails(ExpDetailQueryCriteria criteria) {
return ResultInfo.success(ExpDetailService.queryAll(criteria));
}
@Log
@PostMapping
@ApiOperation("新增ExpDetail")
public ResultInfo create(@Validated @RequestBody ExpDetail resources) {
ExpDetailService.create(resources);
return ResultInfo.success();
}
@Log
@PutMapping
@ApiOperation("修改ExpDetail")
public ResultInfo update(@Validated @RequestBody ExpDetail resources) {
ExpDetailService.update(resources);
return ResultInfo.success();
}
@Log
@DeleteMapping(value = "/{id}")
@ApiOperation("删除ExpDetail")
public ResultInfo delete(@PathVariable Long id) {
ExpDetailService.delete(id);
return ResultInfo.success();
}
@GetMapping(value = "/getByCode/{code}")
@ApiOperation(value = "根据标识查询")
public ResultInfo getByCode(@PathVariable String code) {
return ResultInfo.success(ExpDetailService.getByCode(code));
}
}
package com.topdraw.business.basicdata.exp.detail.service;
import com.topdraw.business.basicdata.exp.detail.domain.ExpDetail;
import com.topdraw.business.basicdata.exp.detail.service.dto.ExpDetailDTO;
import com.topdraw.business.basicdata.exp.detail.service.dto.ExpDetailQueryCriteria;
import org.springframework.data.domain.Pageable;
import java.util.Map;
import java.util.List;
/**
* @author XiangHan
* @date 2021-10-22
*/
public interface ExpDetailService {
/**
* 查询数据分页
* @param criteria 条件参数
* @param pageable 分页参数
* @return Map<String,Object>
*/
Map<String,Object> queryAll(ExpDetailQueryCriteria criteria, Pageable pageable);
/**
* 查询所有数据不分页
* @param criteria 条件参数
* @return List<ExpDetailDTO>
*/
List<ExpDetailDTO> queryAll(ExpDetailQueryCriteria criteria);
/**
* 根据ID查询
* @param id ID
* @return ExpDetailDTO
*/
ExpDetailDTO findById(Long id);
void create(ExpDetail resources);
void update(ExpDetail resources);
void delete(Long id);
/**
* Code校验
* @param code
* @return ExpDetailDTO
*/
ExpDetailDTO getByCode(String code);
}
package com.topdraw.business.basicdata.exp.detail.service.dto;
import lombok.Data;
import java.sql.Timestamp;
import java.io.Serializable;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class ExpDetailDTO implements Serializable {
// 主键
private Long id;
// 标识
private String code;
// 应用code
private String appCode;
// 会员id
private Long memberId;
// 账号id
private Long accountId;
// 原始成长值
private Long originalExp;
// 结果成长值
private Long resultExp;
// 成长值变化，一般为正数
private Long exp;
// 设备类型 1：大屏；2：小屏（微信）3.小屏（xx）
private Integer deviceType;
// 行为事件类型 1：登录；2：观影；3：参与活动；4：订购；10：跨屏绑定；98：系统操作；99：其他
private Integer evtType;
// 订单id（针对订购操作）
private Long orderId;
// 节目id（针对观影操作）
private Long mediaId;
// 活动id（针对参与活动）
private Long activityId;
// 成长值变化描述，用于管理侧显示
private String description;
// 创建时间
private Timestamp createTime;
// 更新时间
private Timestamp updateTime;
}
package com.topdraw.business.basicdata.exp.detail.service.dto;
import lombok.Data;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class ExpDetailQueryCriteria{
}
package com.topdraw.business.basicdata.exp.detail.service.impl;
import com.topdraw.aspect.AsyncMqSend;
import com.topdraw.business.basicdata.exp.detail.domain.ExpDetail;
import com.topdraw.utils.ValidationUtil;
import com.topdraw.business.basicdata.exp.detail.repository.ExpDetailRepository;
import com.topdraw.business.basicdata.exp.detail.service.ExpDetailService;
import com.topdraw.business.basicdata.exp.detail.service.dto.ExpDetailDTO;
import com.topdraw.business.basicdata.exp.detail.service.dto.ExpDetailQueryCriteria;
import com.topdraw.business.basicdata.exp.detail.service.mapper.ExpDetailMapper;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.util.Assert;
import com.topdraw.utils.PageUtil;
import com.topdraw.utils.QueryHelp;
import com.topdraw.utils.StringUtils;
import java.util.List;
import java.util.Map;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Service
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
public class ExpDetailServiceImpl implements ExpDetailService {
@Autowired
private ExpDetailRepository ExpDetailRepository;
@Autowired
private ExpDetailMapper ExpDetailMapper;
@Autowired
private RedissonClient redissonClient;
@Override
public Map<String, Object> queryAll(ExpDetailQueryCriteria criteria, Pageable pageable) {
Page<ExpDetail> page = ExpDetailRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
return PageUtil.toPage(page.map(ExpDetailMapper::toDto));
}
@Override
public List<ExpDetailDTO> queryAll(ExpDetailQueryCriteria criteria) {
return ExpDetailMapper.toDto(ExpDetailRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
}
@Override
public ExpDetailDTO findById(Long id) {
ExpDetail ExpDetail = ExpDetailRepository.findById(id).orElseGet(ExpDetail::new);
ValidationUtil.isNull(ExpDetail.getId(),"ExpDetail","id",id);
return ExpDetailMapper.toDto(ExpDetail);
}
@Override
@Transactional(rollbackFor = Exception.class)
@AsyncMqSend()
public void create(ExpDetail resources) {
ExpDetailRepository.save(resources);
}
@Override
@Transactional(rollbackFor = Exception.class)
@AsyncMqSend()
public void update(ExpDetail resources) {
RLock rLock = this.redissonClient.getLock(resources.getId().toString());
try {
ExpDetail ExpDetail = ExpDetailRepository.findById(resources.getId()).orElseGet(ExpDetail::new);
ValidationUtil.isNull( ExpDetail.getId(),"ExpDetail","id",resources.getId());
ExpDetail.copy(resources);
ExpDetailRepository.save(ExpDetail);
} catch (Exception e) {
e.printStackTrace();
throw e;
} finally {
rLock.unlock();
}
}
@Override
@Transactional(rollbackFor = Exception.class)
@AsyncMqSend()
public void delete(Long id) {
Assert.notNull(id, "The given id must not be null!");
ExpDetail ExpDetail = ExpDetailRepository.findById(id).orElseThrow(
() -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", ExpDetail.class, id), 1));
ExpDetailRepository.delete(ExpDetail);
}
@Override
public ExpDetailDTO getByCode(String code) {
return StringUtils.isNotEmpty(code) ? ExpDetailMapper.toDto(ExpDetailRepository.findFirstByCode(code).orElseGet(ExpDetail::new))
: new ExpDetailDTO();
}
}
package com.topdraw.business.basicdata.exp.detail.service.mapper;
import com.topdraw.base.BaseMapper;
import com.topdraw.business.basicdata.exp.detail.domain.ExpDetail;
import com.topdraw.business.basicdata.exp.detail.service.dto.ExpDetailDTO;
import org.mapstruct.Mapper;
import org.mapstruct.ReportingPolicy;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface ExpDetailMapper extends BaseMapper<ExpDetailDTO, ExpDetail> {
}
package com.topdraw.business.basicdata.exp.history.domain;
import lombok.Data;
import lombok.experimental.Accessors;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import javax.persistence.*;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;
import java.sql.Timestamp;
import java.io.Serializable;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Entity
@Data
@EntityListeners(AuditingEntityListener.class)
@Accessors(chain = true)
@Table(name="uc_exp_history")
public class ExpHistory implements Serializable {
// 主键
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
// 标识
@Column(name = "code", nullable = false)
private String code;
// 会员id
@Column(name = "member_id", nullable = false)
private Long memberId;
// 账号id
@Column(name = "account_id")
private Long accountId;
// 原始成长值
@Column(name = "original_exp", nullable = false)
private Long originalExp;
// 结果成长值
@Column(name = "result_exp", nullable = false)
private Long resultExp;
// 成长值变化，一般为正数
@Column(name = "exp", nullable = false)
private Long exp;
// 设备类型 1：大屏；2：小屏（微信）3.小屏（xx）4.系统赠送
@Column(name = "device_type", nullable = false)
private Integer deviceType;
// 行为事件类型 1：登录；2：观影；3：参与活动；4：订购；10：跨屏绑定；98：系统操作；99：其他
@Column(name = "evt_type", nullable = false)
private Integer evtType;
// 订单id（针对订购操作）
@Column(name = "order_id")
private Long orderId;
// 节目id（针对观影操作）
@Column(name = "media_id")
private Long mediaId;
// 活动id（针对参与活动）
@Column(name = "activity_id")
private Long activityId;
// 成长值变化描述，用于管理侧显示
@Column(name = "description", nullable = false)
private String description;
// 创建时间
@CreatedDate
@Column(name = "create_time")
private Timestamp createTime;
// 更新时间
@LastModifiedDate
@Column(name = "update_time")
private Timestamp updateTime;
public void copy(ExpHistory source){
BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
}
}
package com.topdraw.business.basicdata.exp.history.repository;
import com.topdraw.business.basicdata.exp.history.domain.ExpHistory;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import java.util.Optional;
/**
* @author XiangHan
* @date 2021-10-22
*/
public interface ExpHistoryRepository extends JpaRepository<ExpHistory, Long>, JpaSpecificationExecutor<ExpHistory> {
Optional<ExpHistory> findFirstByCode(String code);
}
package com.topdraw.business.basicdata.exp.history.rest;
import com.topdraw.common.ResultInfo;
import com.topdraw.annotation.Log;
import com.topdraw.business.basicdata.exp.history.domain.ExpHistory;
import com.topdraw.business.basicdata.exp.history.service.ExpHistoryService;
import com.topdraw.business.basicdata.exp.history.service.dto.ExpHistoryQueryCriteria;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Pageable;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import io.swagger.annotations.*;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Api(tags = "ExpHistory管理")
@RestController
@RequestMapping("/api/ExpHistory")
public class ExpHistoryController {
@Autowired
private ExpHistoryService ExpHistoryService;
@GetMapping
@ApiOperation("查询ExpHistory")
public ResultInfo getExpHistorys(ExpHistoryQueryCriteria criteria, Pageable pageable) {
return ResultInfo.successPage(ExpHistoryService.queryAll(criteria,pageable));
}
@GetMapping(value = "/all")
@ApiOperation("查询所有ExpHistory")
public ResultInfo getExpHistorys(ExpHistoryQueryCriteria criteria) {
return ResultInfo.success(ExpHistoryService.queryAll(criteria));
}
@Log
@PostMapping
@ApiOperation("新增ExpHistory")
public ResultInfo create(@Validated @RequestBody ExpHistory resources) {
ExpHistoryService.create(resources);
return ResultInfo.success();
}
@Log
@PutMapping
@ApiOperation("修改ExpHistory")
public ResultInfo update(@Validated @RequestBody ExpHistory resources) {
ExpHistoryService.update(resources);
return ResultInfo.success();
}
@Log
@DeleteMapping(value = "/{id}")
@ApiOperation("删除ExpHistory")
public ResultInfo delete(@PathVariable Long id) {
ExpHistoryService.delete(id);
return ResultInfo.success();
}
@GetMapping(value = "/getByCode/{code}")
@ApiOperation(value = "根据标识查询")
public ResultInfo getByCode(@PathVariable String code) {
return ResultInfo.success(ExpHistoryService.getByCode(code));
}
}
package com.topdraw.business.basicdata.exp.history.service;
import com.topdraw.business.basicdata.exp.history.domain.ExpHistory;
import com.topdraw.business.basicdata.exp.history.service.dto.ExpHistoryDTO;
import com.topdraw.business.basicdata.exp.history.service.dto.ExpHistoryQueryCriteria;
import org.springframework.data.domain.Pageable;
import java.util.Map;
import java.util.List;
/**
* @author XiangHan
* @date 2021-10-22
*/
public interface ExpHistoryService {
/**
* 查询数据分页
* @param criteria 条件参数
* @param pageable 分页参数
* @return Map<String,Object>
*/
Map<String,Object> queryAll(ExpHistoryQueryCriteria criteria, Pageable pageable);
/**
* 查询所有数据不分页
* @param criteria 条件参数
* @return List<ExpHistoryDTO>
*/
List<ExpHistoryDTO> queryAll(ExpHistoryQueryCriteria criteria);
/**
* 根据ID查询
* @param id ID
* @return ExpHistoryDTO
*/
ExpHistoryDTO findById(Long id);
void create(ExpHistory resources);
void update(ExpHistory resources);
void delete(Long id);
/**
* Code校验
* @param code
* @return ExpHistoryDTO
*/
ExpHistoryDTO getByCode(String code);
}
package com.topdraw.business.basicdata.exp.history.service.dto;
import lombok.Data;
import java.sql.Timestamp;
import java.io.Serializable;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class ExpHistoryDTO implements Serializable {
// 主键
private Long id;
// 标识
private String code;
// 会员id
private Long memberId;
// 账号id
private Long accountId;
// 原始成长值
private Long originalExp;
// 结果成长值
private Long resultExp;
// 成长值变化，一般为正数
private Long exp;
// 设备类型 1：大屏；2：小屏（微信）3.小屏（xx）4.系统赠送
private Integer deviceType;
// 行为事件类型 1：登录；2：观影；3：参与活动；4：订购；10：跨屏绑定；98：系统操作；99：其他
private Integer evtType;
// 订单id（针对订购操作）
private Long orderId;
// 节目id（针对观影操作）
private Long mediaId;
// 活动id（针对参与活动）
private Long activityId;
// 成长值变化描述，用于管理侧显示
private String description;
// 创建时间
private Timestamp createTime;
// 更新时间
private Timestamp updateTime;
}
package com.topdraw.business.basicdata.exp.history.service.dto;
import lombok.Data;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class ExpHistoryQueryCriteria{
}
package com.topdraw.business.basicdata.exp.history.service.impl;
import com.topdraw.aspect.AsyncMqSend;
import com.topdraw.business.basicdata.exp.history.domain.ExpHistory;
import com.topdraw.utils.ValidationUtil;
import com.topdraw.business.basicdata.exp.history.repository.ExpHistoryRepository;
import com.topdraw.business.basicdata.exp.history.service.ExpHistoryService;
import com.topdraw.business.basicdata.exp.history.service.dto.ExpHistoryDTO;
import com.topdraw.business.basicdata.exp.history.service.dto.ExpHistoryQueryCriteria;
import com.topdraw.business.basicdata.exp.history.service.mapper.ExpHistoryMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.util.Assert;
import com.topdraw.utils.PageUtil;
import com.topdraw.utils.QueryHelp;
import com.topdraw.utils.StringUtils;
import java.util.List;
import java.util.Map;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Service
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
public class ExpHistoryServiceImpl implements ExpHistoryService {
@Autowired
private ExpHistoryRepository ExpHistoryRepository;
@Autowired
private ExpHistoryMapper ExpHistoryMapper;
@Override
public Map<String, Object> queryAll(ExpHistoryQueryCriteria criteria, Pageable pageable) {
Page<ExpHistory> page = ExpHistoryRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
return PageUtil.toPage(page.map(ExpHistoryMapper::toDto));
}
@Override
public List<ExpHistoryDTO> queryAll(ExpHistoryQueryCriteria criteria) {
return ExpHistoryMapper.toDto(ExpHistoryRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
}
@Override
public ExpHistoryDTO findById(Long id) {
ExpHistory ExpHistory = ExpHistoryRepository.findById(id).orElseGet(ExpHistory::new);
ValidationUtil.isNull(ExpHistory.getId(),"ExpHistory","id",id);
return ExpHistoryMapper.toDto(ExpHistory);
}
@Override
@Transactional(rollbackFor = Exception.class)
// @AsyncMqSend()
public void create(ExpHistory resources) {
ExpHistoryRepository.save(resources);
}
@Override
@Transactional(rollbackFor = Exception.class)
@AsyncMqSend()
public void update(ExpHistory resources) {
ExpHistory ExpHistory = ExpHistoryRepository.findById(resources.getId()).orElseGet(ExpHistory::new);
ValidationUtil.isNull( ExpHistory.getId(),"ExpHistory","id",resources.getId());
ExpHistory.copy(resources);
ExpHistoryRepository.save(ExpHistory);
}
@Override
@Transactional(rollbackFor = Exception.class)
@AsyncMqSend()
public void delete(Long id) {
Assert.notNull(id, "The given id must not be null!");
ExpHistory ExpHistory = ExpHistoryRepository.findById(id).orElseThrow(
() -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", ExpHistory.class, id), 1));
ExpHistoryRepository.delete(ExpHistory);
}
@Override
public ExpHistoryDTO getByCode(String code) {
return StringUtils.isNotEmpty(code) ? ExpHistoryMapper.toDto(ExpHistoryRepository.findFirstByCode(code).orElseGet(ExpHistory::new))
: new ExpHistoryDTO();
}
}
package com.topdraw.business.basicdata.exp.history.service.mapper;
import com.topdraw.base.BaseMapper;
import com.topdraw.business.basicdata.exp.history.domain.ExpHistory;
import com.topdraw.business.basicdata.exp.history.service.dto.ExpHistoryDTO;
import org.mapstruct.Mapper;
import org.mapstruct.ReportingPolicy;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface ExpHistoryMapper extends BaseMapper<ExpHistoryDTO, ExpHistory> {
}
package com.topdraw.business.basicdata.member.address.domain;
import lombok.Data;
import lombok.experimental.Accessors;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import javax.persistence.*;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;
import java.sql.Timestamp;
import java.io.Serializable;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Entity
@Data
@EntityListeners(AuditingEntityListener.class)
@Accessors(chain = true)
@Table(name="uc_member_address")
public class MemberAddress implements Serializable {
// 主键
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
// 会员id
@Column(name = "member_id", nullable = false)
private Long memberId;
// 类型 1：家；2：公司；3：学校
@Column(name = "type", nullable = false)
private Integer type;
// 是否默认地址
@Column(name = "is_default", nullable = false)
private Integer isDefault;
// 显示顺序
@Column(name = "sequence")
private Integer sequence;
// 状态 0：不可用；1-可用
@Column(name = "status", nullable = false)
private Integer status;
// 联系人姓名
@Column(name = "contactor", nullable = false)
private String contactor;
// 联系人电话
@Column(name = "cellphone", nullable = false)
private String cellphone;
// 国家
@Column(name = "country", nullable = false)
private String country;
// 省份
@Column(name = "province", nullable = false)
private String province;
// 城市
@Column(name = "city", nullable = false)
private String city;
// 区县
@Column(name = "district", nullable = false)
private String district;
// 地址
@Column(name = "address", nullable = false)
private String address;
// 邮编
@Column(name = "zip_code")
private String zipCode;
// 创建时间
@CreatedDate
@Column(name = "create_time")
private Timestamp createTime;
// 更新时间
@LastModifiedDate
@Column(name = "update_time")
private Timestamp updateTime;
public void copy(MemberAddress source){
BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
}
}
package com.topdraw.business.basicdata.member.address.repository;
import com.topdraw.business.basicdata.member.address.domain.MemberAddress;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
/**
* @author XiangHan
* @date 2021-10-22
*/
public interface MemberAddressRepository extends JpaRepository<MemberAddress, Long>, JpaSpecificationExecutor<MemberAddress> {
}
package com.topdraw.business.basicdata.member.address.rest;
import com.topdraw.common.ResultInfo;
import com.topdraw.annotation.Log;
import com.topdraw.business.basicdata.member.address.domain.MemberAddress;
import com.topdraw.business.basicdata.member.address.service.MemberAddressService;
import com.topdraw.business.basicdata.member.address.service.dto.MemberAddressQueryCriteria;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Pageable;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import io.swagger.annotations.*;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Api(tags = "MemberAddress管理")
@RestController
@RequestMapping("/api/MemberAddress")
public class MemberAddressController {
@Autowired
private MemberAddressService MemberAddressService;
@GetMapping(value = "/pageMemberAddress")
@ApiOperation("查询MemberAddress")
public ResultInfo pageMemberAddress(MemberAddressQueryCriteria criteria, Pageable pageable) {
return ResultInfo.successPage(MemberAddressService.queryAll(criteria,pageable));
}
@GetMapping(value = "/findById/{id}")
@ApiOperation("查询指定MemberAddress")
public ResultInfo findById(@PathVariable(value = "id") Long id) {
return ResultInfo.success(MemberAddressService.findById(id));
}
@Log
@PostMapping(value = "/create")
@ApiOperation("新增MemberAddress")
public ResultInfo create(@Validated @RequestBody MemberAddress resources) {
MemberAddressService.create(resources);
return ResultInfo.success();
}
@Log
@PutMapping(value = "/update")
@ApiOperation("修改MemberAddress")
public ResultInfo update(@Validated @RequestBody MemberAddress resources) {
MemberAddressService.update(resources);
return ResultInfo.success();
}
@Log
@DeleteMapping(value = "/delete/{id}")
@ApiOperation("删除MemberAddress")
public ResultInfo delete(@PathVariable Long id) {
MemberAddressService.delete(id);
return ResultInfo.success();
}
}
package com.topdraw.business.basicdata.member.address.service;
import com.topdraw.business.basicdata.member.address.domain.MemberAddress;
import com.topdraw.business.basicdata.member.address.service.dto.MemberAddressDTO;
import com.topdraw.business.basicdata.member.address.service.dto.MemberAddressQueryCriteria;
import org.springframework.data.domain.Pageable;
import java.util.Map;
import java.util.List;
/**
* @author XiangHan
* @date 2021-10-22
*/
public interface MemberAddressService {
/**
* 查询数据分页
* @param criteria 条件参数
* @param pageable 分页参数
* @return Map<String,Object>
*/
Map<String,Object> queryAll(MemberAddressQueryCriteria criteria, Pageable pageable);
/**
* 查询所有数据不分页
* @param criteria 条件参数
* @return List<MemberAddressDTO>
*/
List<MemberAddressDTO> queryAll(MemberAddressQueryCriteria criteria);
/**
* 根据ID查询
* @param id ID
* @return MemberAddressDTO
*/
MemberAddressDTO findById(Long id);
void create(MemberAddress resources);
void update(MemberAddress resources);
void delete(Long id);
}
package com.topdraw.business.basicdata.member.address.service.dto;
import lombok.Data;
import java.sql.Timestamp;
import java.io.Serializable;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class MemberAddressDTO implements Serializable {
// 主键
private Long id;
// 会员id
private Long memberId;
// 类型 1：家；2：公司；3：学校
private Integer type;
// 是否默认地址
private Integer isDefault;
// 显示顺序
private Integer sequence;
// 状态 0：不可用；1-可用
private Integer status;
// 联系人姓名
private String contactor;
// 联系人电话
private String cellphone;
// 国家
private String country;
// 省份
private String province;
// 城市
private String city;
// 区县
private String district;
// 地址
private String address;
// 邮编
private String zipCode;
// 创建时间
private Timestamp createTime;
// 更新时间
private Timestamp updateTime;
}
package com.topdraw.business.basicdata.member.address.service.dto;
import com.topdraw.annotation.Query;
import lombok.Data;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class MemberAddressQueryCriteria{
@Query
private Long memberId;
}
package com.topdraw.business.basicdata.member.address.service.impl;
import com.topdraw.aspect.AsyncMqSend;
import com.topdraw.business.basicdata.member.address.domain.MemberAddress;
import com.topdraw.utils.ValidationUtil;
import com.topdraw.business.basicdata.member.address.repository.MemberAddressRepository;
import com.topdraw.business.basicdata.member.address.service.MemberAddressService;
import com.topdraw.business.basicdata.member.address.service.dto.MemberAddressDTO;
import com.topdraw.business.basicdata.member.address.service.dto.MemberAddressQueryCriteria;
import com.topdraw.business.basicdata.member.address.service.mapper.MemberAddressMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.util.Assert;
import com.topdraw.utils.PageUtil;
import com.topdraw.utils.QueryHelp;
import java.util.List;
import java.util.Map;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Service
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
public class MemberAddressServiceImpl implements MemberAddressService {
@Autowired
private MemberAddressRepository MemberAddressRepository;
@Autowired
private MemberAddressMapper MemberAddressMapper;
@Override
public Map<String, Object> queryAll(MemberAddressQueryCriteria criteria, Pageable pageable) {
Page<MemberAddress> page = MemberAddressRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
return PageUtil.toPage(page.map(MemberAddressMapper::toDto));
}
@Override
public List<MemberAddressDTO> queryAll(MemberAddressQueryCriteria criteria) {
return MemberAddressMapper.toDto(MemberAddressRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
}
@Override
public MemberAddressDTO findById(Long id) {
MemberAddress MemberAddress = MemberAddressRepository.findById(id).orElseGet(MemberAddress::new);
ValidationUtil.isNull(MemberAddress.getId(),"MemberAddress","id",id);
return MemberAddressMapper.toDto(MemberAddress);
}
@Override
@Transactional(rollbackFor = Exception.class)
@AsyncMqSend()
public void create(MemberAddress resources) {
MemberAddressRepository.save(resources);
}
@Override
@Transactional(rollbackFor = Exception.class)
@AsyncMqSend()
public void update(MemberAddress resources) {
MemberAddress MemberAddress = MemberAddressRepository.findById(resources.getId()).orElseGet(MemberAddress::new);
ValidationUtil.isNull( MemberAddress.getId(),"MemberAddress","id",resources.getId());
MemberAddress.copy(resources);
MemberAddressRepository.save(MemberAddress);
}
@Override
@Transactional(rollbackFor = Exception.class)
@AsyncMqSend()
public void delete(Long id) {
Assert.notNull(id, "The given id must not be null!");
MemberAddress MemberAddress = MemberAddressRepository.findById(id).orElseThrow(
() -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", MemberAddress.class, id), 1));
MemberAddressRepository.delete(MemberAddress);
}
}
package com.topdraw.business.basicdata.member.address.service.mapper;
import com.topdraw.base.BaseMapper;
import com.topdraw.business.basicdata.member.address.domain.MemberAddress;
import com.topdraw.business.basicdata.member.address.service.dto.MemberAddressDTO;
import org.mapstruct.Mapper;
import org.mapstruct.ReportingPolicy;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface MemberAddressMapper extends BaseMapper<MemberAddressDTO, MemberAddress> {
}
package com.topdraw.business.basicdata.member.domain;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import lombok.Data;
import lombok.experimental.Accessors;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;
import javax.persistence.*;
import java.io.Serializable;
import java.sql.Timestamp;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Entity
@Data
@EntityListeners(AuditingEntityListener.class)
@Accessors(chain = true)
@Table(name="uc_member")
public class Member implements Serializable {
// 主键
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
// 标识
@Column(name = "code", nullable = false)
private String code;
// 类型 1：大屏；2：小屏
@Column(name = "`type`", nullable = false)
private Integer type;
// 状态 0：不可用；1：可用
@Column(name = "`status`", nullable = false)
private Integer status;
// 昵称 base64
@Column(name = "nickname")
private String nickname;
// 描述
@Column(name = "description")
private String description;
// 性别 0：女；1：男；-1：未知
@Column(name = "gender", nullable = false)
private Integer gender;
// 生日
@Column(name = "birthday")
private String birthday;
// 头像
@Column(name = "avatar_url")
private String avatarUrl;
// 分组信息
@Column(name = "`groups`")
private String groups;
// 标签
@Column(name = "tags")
private String tags;
// 是否会员 0：非会员；1：会员
@Column(name = "vip", nullable = false)
private Integer vip;
// 会员等级（对应level表的level字段，非id）
@Column(name = "`level`", nullable = false)
private Integer level;
// 成长值
@Column(name = "`exp`")
private Long exp;
// 当前积分
@Column(name = "`points`")
private Long points;
// 即将到期积分（一个月内）
@Column(name = "due_points")
private Long duePoints;
// 优惠券数量
@Column(name = "coupon_amount")
private Long couponAmount;
// 即将过期优惠券数量
@Column(name = "due_coupon_amount")
private Long dueCouponAmount;
// iptv账号id
@Column(name = "user_iptv_id")
private Long userIptvId;
// 绑定IPTV平台 0：未知；1：电信；2：移动；3：联通
@Column(name = "bind_iptv_platform_type")
private Integer bindIptvPlatformType;
// iptv账号绑定时间
@Column(name = "bind_iptv_time")
private Timestamp bindIptvTime;
// 创建时间
@CreatedDate
@Column(name = "create_time")
private Timestamp createTime;
// 更新时间
@LastModifiedDate
@Column(name = "update_time")
private Timestamp updateTime;
// 是否在黑名单 1：是；0否
// @Column(name = "black_status")
// private Integer blackStatus;
public void copy(Member source){
BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
}
}
package com.topdraw.business.basicdata.member.level.domain;
import lombok.Data;
import lombok.experimental.Accessors;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import javax.persistence.*;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;
import java.sql.Timestamp;
import java.io.Serializable;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Entity
@Data
@EntityListeners(AuditingEntityListener.class)
@Accessors(chain = true)
@Table(name="uc_member_level")
public class MemberLevel implements Serializable {
// 主键
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
// 标识
@Column(name = "code", nullable = false)
private String code;
// 名称
@Column(name = "name", nullable = false)
private String name;
// 状态 0：未启用；1：启用
@Column(name = "status", nullable = false)
private Integer status;
// 对应成长值
@Column(name = "exp_value", nullable = false)
private Long expValue;
// 等级（不可重复，数字越大等级越高）
@Column(name = "level", nullable = false)
private Integer level;
// 会员徽标
@Column(name = "icon_url")
private String iconUrl;
// 描述
@Column(name = "description")
private String description;
// 对应任务id，通过此字段可获得该等级所对应的权益
@Column(name = "task_id")
private Long taskId;
// 创建时间
@CreatedDate
@Column(name = "create_time")
private Timestamp createTime;
// 更新时间
@LastModifiedDate
@Column(name = "update_time")
private Timestamp updateTime;
public void copy(MemberLevel source){
BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
}
}
package com.topdraw.business.basicdata.member.level.repository;
import com.topdraw.business.basicdata.member.level.domain.MemberLevel;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import java.util.List;
import java.util.Optional;
/**
* @author XiangHan
* @date 2021-10-22
*/
public interface MemberLevelRepository extends JpaRepository<MemberLevel, Long>, JpaSpecificationExecutor<MemberLevel> {
Optional<MemberLevel> findFirstByCode(String code);
List<MemberLevel> findByLevelAndStatus(Integer level, Integer status);
}
package com.topdraw.business.basicdata.member.level.rest;
import com.topdraw.common.ResultInfo;
import com.topdraw.annotation.Log;
import com.topdraw.business.basicdata.member.level.domain.MemberLevel;
import com.topdraw.business.basicdata.member.level.service.MemberLevelService;
import com.topdraw.business.basicdata.member.level.service.dto.MemberLevelQueryCriteria;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Pageable;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import io.swagger.annotations.*;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Api(tags = "MemberLevel管理")
@RestController
@RequestMapping("/api/MemberLevel")
public class MemberLevelController {
@Autowired
private MemberLevelService MemberLevelService;
@GetMapping
@ApiOperation("查询MemberLevel")
public ResultInfo getMemberLevels(MemberLevelQueryCriteria criteria, Pageable pageable) {
return ResultInfo.successPage(MemberLevelService.queryAll(criteria,pageable));
}
@GetMapping(value = "/all")
@ApiOperation("查询所有MemberLevel")
public ResultInfo getMemberLevels(MemberLevelQueryCriteria criteria) {
return ResultInfo.success(MemberLevelService.queryAll(criteria));
}
@Log
@PostMapping
@ApiOperation("新增MemberLevel")
public ResultInfo create(@Validated @RequestBody MemberLevel resources) {
MemberLevelService.create(resources);
return ResultInfo.success();
}
@Log
@PutMapping
@ApiOperation("修改MemberLevel")
public ResultInfo update(@Validated @RequestBody MemberLevel resources) {
MemberLevelService.update(resources);
return ResultInfo.success();
}
@Log
@DeleteMapping(value = "/{id}")
@ApiOperation("删除MemberLevel")
public ResultInfo delete(@PathVariable Long id) {
MemberLevelService.delete(id);
return ResultInfo.success();
}
@GetMapping(value = "/getByCode/{code}")
@ApiOperation(value = "根据标识查询")
public ResultInfo getByCode(@PathVariable String code) {
return ResultInfo.success(MemberLevelService.getByCode(code));
}
}
package com.topdraw.business.basicdata.member.level.service;
import com.topdraw.business.basicdata.member.level.domain.MemberLevel;
import com.topdraw.business.basicdata.member.level.service.dto.MemberLevelDTO;
import com.topdraw.business.basicdata.member.level.service.dto.MemberLevelQueryCriteria;
import org.springframework.data.domain.Pageable;
import java.util.Map;
import java.util.List;
/**
* @author XiangHan
* @date 2021-10-22
*/
public interface MemberLevelService {
/**
* 查询数据分页
* @param criteria 条件参数
* @param pageable 分页参数
* @return Map<String,Object>
*/
Map<String,Object> queryAll(MemberLevelQueryCriteria criteria, Pageable pageable);
/**
* 查询所有数据不分页
* @param criteria 条件参数
* @return List<MemberLevelDTO>
*/
List<MemberLevelDTO> queryAll(MemberLevelQueryCriteria criteria);
/**
* 根据ID查询
* @param id ID
* @return MemberLevelDTO
*/
MemberLevelDTO findById(Long id);
void create(MemberLevel resources);
void update(MemberLevel resources);
void delete(Long id);
/**
* Code校验
* @param code
* @return MemberLevelDTO
*/
MemberLevelDTO getByCode(String code);
List<MemberLevelDTO> findLevelAndStatus(Integer i, Integer status);
}
package com.topdraw.business.basicdata.member.level.service.dto;
import lombok.Data;
import java.sql.Timestamp;
import java.io.Serializable;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class MemberLevelDTO implements Serializable {
// 主键
private Long id;
// 标识
private String code;
// 名称
private String name;
// 状态 0：未启用；1：启用
private Integer status;
// 对应成长值
private Long expValue;
// 等级（不可重复，数字越大等级越高）
private Integer level;
// 会员徽标
private String iconUrl;
// 描述
private String description;
// 对应任务id，通过此字段可获得该等级所对应的权益
private Long taskId;
// 创建时间
private Timestamp createTime;
// 更新时间
private Timestamp updateTime;
}
package com.topdraw.business.basicdata.member.level.service.dto;
import lombok.Data;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class MemberLevelQueryCriteria{
}
package com.topdraw.business.basicdata.member.level.service.impl;
import com.topdraw.aspect.AsyncMqSend;
import com.topdraw.business.basicdata.member.level.domain.MemberLevel;
import com.topdraw.utils.ValidationUtil;
import com.topdraw.business.basicdata.member.level.repository.MemberLevelRepository;
import com.topdraw.business.basicdata.member.level.service.MemberLevelService;
import com.topdraw.business.basicdata.member.level.service.dto.MemberLevelDTO;
import com.topdraw.business.basicdata.member.level.service.dto.MemberLevelQueryCriteria;
import com.topdraw.business.basicdata.member.level.service.mapper.MemberLevelMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.util.Assert;
import com.topdraw.utils.PageUtil;
import com.topdraw.utils.QueryHelp;
import com.topdraw.utils.StringUtils;
import java.util.List;
import java.util.Map;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Service
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
public class MemberLevelServiceImpl implements MemberLevelService {
@Autowired
private MemberLevelRepository MemberLevelRepository;
@Autowired
private MemberLevelMapper MemberLevelMapper;
@Override
public Map<String, Object> queryAll(MemberLevelQueryCriteria criteria, Pageable pageable) {
Page<MemberLevel> page = MemberLevelRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
return PageUtil.toPage(page.map(MemberLevelMapper::toDto));
}
@Override
public List<MemberLevelDTO> queryAll(MemberLevelQueryCriteria criteria) {
return MemberLevelMapper.toDto(MemberLevelRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
}
@Override
public MemberLevelDTO findById(Long id) {
MemberLevel MemberLevel = MemberLevelRepository.findById(id).orElseGet(MemberLevel::new);
ValidationUtil.isNull(MemberLevel.getId(),"MemberLevel","id",id);
return MemberLevelMapper.toDto(MemberLevel);
}
@Override
@Transactional(rollbackFor = Exception.class)
@AsyncMqSend()
public void create(MemberLevel resources) {
MemberLevelRepository.save(resources);
}
@Override
@Transactional(rollbackFor = Exception.class)
@AsyncMqSend()
public void update(MemberLevel resources) {
MemberLevel MemberLevel = MemberLevelRepository.findById(resources.getId()).orElseGet(MemberLevel::new);
ValidationUtil.isNull( MemberLevel.getId(),"MemberLevel","id",resources.getId());
MemberLevel.copy(resources);
MemberLevelRepository.save(MemberLevel);
}
@Override
@Transactional(rollbackFor = Exception.class)
@AsyncMqSend()
public void delete(Long id) {
Assert.notNull(id, "The given id must not be null!");
MemberLevel MemberLevel = MemberLevelRepository.findById(id).orElseThrow(
() -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", MemberLevel.class, id), 1));
MemberLevelRepository.delete(MemberLevel);
}
@Override
public MemberLevelDTO getByCode(String code) {
return StringUtils.isNotEmpty(code) ? MemberLevelMapper.toDto(MemberLevelRepository.findFirstByCode(code).orElseGet(MemberLevel::new))
: new MemberLevelDTO();
}
@Override
public List<MemberLevelDTO> findLevelAndStatus(Integer level, Integer status) {
return MemberLevelMapper.toDto(MemberLevelRepository.findByLevelAndStatus(level,status));
}
}
package com.topdraw.business.basicdata.member.level.service.mapper;
import com.topdraw.base.BaseMapper;
import com.topdraw.business.basicdata.member.level.domain.MemberLevel;
import com.topdraw.business.basicdata.member.level.service.dto.MemberLevelDTO;
import org.mapstruct.Mapper;
import org.mapstruct.ReportingPolicy;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface MemberLevelMapper extends BaseMapper<MemberLevelDTO, MemberLevel> {
}
package com.topdraw.business.basicdata.member.profile;
public interface DoSaveMemberProfileGroup {
}
package com.topdraw.business.basicdata.member.profile;
public interface DoUpdateMemberProfileGroup {
}
package com.topdraw.business.basicdata.member.profile.domain;
import com.topdraw.business.basicdata.member.profile.DoSaveMemberProfileGroup;
import com.topdraw.business.basicdata.member.profile.DoUpdateMemberProfileGroup;
import lombok.Data;
import lombok.experimental.Accessors;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import javax.persistence.*;
import javax.validation.constraints.NotNull;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;
import java.sql.Timestamp;
import java.io.Serializable;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Entity
@Data
@EntityListeners(AuditingEntityListener.class)
@Accessors(chain = true)
@Table(name="uc_member_profile")
public class MemberProfile implements Serializable {
// 主键
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
@NotNull(message = "【id】 not be null!!" , groups = DoUpdateMemberProfileGroup.class)
private Long id;
// 会员id
@NotNull(message = "【memberId】 not be null!!" , groups = DoSaveMemberProfileGroup.class)
@Column(name = "member_id", nullable = false)
private Long memberId;
// 姓名
@Column(name = "realname")
private String realname;
// 性别 0：女； 1：男 -1：未知
@Column(name = "gender", nullable = false)
@NotNull(message = "【gender】 not be null!!" , groups = {DoSaveMemberProfileGroup.class})
private Integer gender;
// 生日
@NotNull(message = "【memberId】 not be null!!" , groups = DoSaveMemberProfileGroup.class)
@Column(name = "birthday", nullable = false)
private Timestamp birthday;
// 星座
@Column(name = "constellation")
private String constellation;
// 身份证
@NotNull(message = "【idCard】 not be null!!" , groups = DoSaveMemberProfileGroup.class)
@Column(name = "id_card", nullable = false)
private String idCard;
// 电子邮件
@Column(name = "email")
private String email;
// 国家
@Column(name = "country")
private String country;
// 省份
@Column(name = "province")
private String province;
// 城市
@Column(name = "city")
private String city;
// 区县
@Column(name = "district")
private String district;
// 描述
@Column(name = "description")
private String description;
// 创建时间
@CreatedDate
@Column(name = "create_time")
private Timestamp createTime;
// 更新时间
@LastModifiedDate
@Column(name = "update_time")
private Timestamp updateTime;
public void copy(MemberProfile source){
BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
}
}
package com.topdraw.business.basicdata.member.profile.repository;
import com.topdraw.business.basicdata.member.profile.domain.MemberProfile;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
/**
* @author XiangHan
* @date 2021-10-22
*/
public interface MemberProfileRepository extends JpaRepository<MemberProfile, Long>, JpaSpecificationExecutor<MemberProfile> {
}
package com.topdraw.business.basicdata.member.profile.rest;
import com.topdraw.common.ResultInfo;
import com.topdraw.annotation.Log;
import com.topdraw.business.basicdata.member.profile.domain.MemberProfile;
import com.topdraw.business.basicdata.member.profile.service.MemberProfileService;
import com.topdraw.business.basicdata.member.profile.service.dto.MemberProfileQueryCriteria;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Pageable;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import io.swagger.annotations.*;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Api(tags = "MemberProfile管理")
@RestController
@RequestMapping("/api/MemberProfile")
public class MemberProfileController {
@Autowired
private MemberProfileService MemberProfileService;
/*@GetMapping
@ApiOperation("查询MemberProfile")
public ResultInfo getMemberProfiles(MemberProfileQueryCriteria criteria, Pageable pageable) {
return ResultInfo.successPage(MemberProfileService.queryAll(criteria,pageable));
}
@GetMapping(value = "/all")
@ApiOperation("查询所有MemberProfile")
public ResultInfo getMemberProfiles(MemberProfileQueryCriteria criteria) {
return ResultInfo.success(MemberProfileService.queryAll(criteria));
}*/
@Log
@PostMapping
@ApiOperation("新增MemberProfile")
public ResultInfo create(@Validated @RequestBody MemberProfile resources) {
MemberProfileService.create(resources);
return ResultInfo.success();
}
@Log
@PutMapping
@ApiOperation("修改MemberProfile")
public ResultInfo update(@Validated @RequestBody MemberProfile resources) {
MemberProfileService.update(resources);
return ResultInfo.success();
}
@Log
@DeleteMapping(value = "/{id}")
@ApiOperation("删除MemberProfile")
public ResultInfo delete(@PathVariable Long id) {
MemberProfileService.delete(id);
return ResultInfo.success();
}
}
package com.topdraw.business.basicdata.member.profile.service;
import com.topdraw.business.basicdata.member.profile.domain.MemberProfile;
import com.topdraw.business.basicdata.member.profile.service.dto.MemberProfileDTO;
import com.topdraw.business.basicdata.member.profile.service.dto.MemberProfileQueryCriteria;
import org.springframework.data.domain.Pageable;
import java.util.Map;
import java.util.List;
/**
* @author XiangHan
* @date 2021-10-22
*/
public interface MemberProfileService {
/**
* 查询数据分页
* @param criteria 条件参数
* @param pageable 分页参数
* @return Map<String,Object>
*/
Map<String,Object> queryAll(MemberProfileQueryCriteria criteria, Pageable pageable);
/**
* 查询所有数据不分页
* @param criteria 条件参数
* @return List<MemberProfileDTO>
*/
List<MemberProfileDTO> queryAll(MemberProfileQueryCriteria criteria);
/**
* 根据ID查询
* @param id ID
* @return MemberProfileDTO
*/
MemberProfileDTO findById(Long id);
void create(MemberProfile resources);
void update(MemberProfile resources);
void delete(Long id);
}
package com.topdraw.business.basicdata.member.profile.service.dto;
import lombok.Data;
import java.sql.Timestamp;
import java.io.Serializable;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class MemberProfileDTO implements Serializable {
// 主键
private Long id;
// 会员id
private Long memberId;
// 姓名
private String realname;
// 性别 0：女； 1：男 -1：未知
private Integer gender;
// 生日
private Timestamp birthday;
// 星座
private String constellation;
// 身份证
private String idCard;
// 电子邮件
private String email;
// 国家
private String country;
// 省份
private String province;
// 城市
private String city;
// 区县
private String district;
// 描述
private String description;
// 创建时间
private Timestamp createTime;
// 更新时间
private Timestamp updateTime;
}
package com.topdraw.business.basicdata.member.profile.service.dto;
import lombok.Data;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class MemberProfileQueryCriteria{
}
package com.topdraw.business.basicdata.member.profile.service.impl;
import com.topdraw.aspect.AsyncMqSend;
import com.topdraw.business.basicdata.member.profile.domain.MemberProfile;
import com.topdraw.utils.ValidationUtil;
import com.topdraw.business.basicdata.member.profile.repository.MemberProfileRepository;
import com.topdraw.business.basicdata.member.profile.service.MemberProfileService;
import com.topdraw.business.basicdata.member.profile.service.dto.MemberProfileDTO;
import com.topdraw.business.basicdata.member.profile.service.dto.MemberProfileQueryCriteria;
import com.topdraw.business.basicdata.member.profile.service.mapper.MemberProfileMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.util.Assert;
import com.topdraw.utils.PageUtil;
import com.topdraw.utils.QueryHelp;
import java.util.List;
import java.util.Map;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Service
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
public class MemberProfileServiceImpl implements MemberProfileService {
@Autowired
private MemberProfileRepository MemberProfileRepository;
@Autowired
private MemberProfileMapper MemberProfileMapper;
@Override
public Map<String, Object> queryAll(MemberProfileQueryCriteria criteria, Pageable pageable) {
Page<MemberProfile> page = MemberProfileRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
return PageUtil.toPage(page.map(MemberProfileMapper::toDto));
}
@Override
public List<MemberProfileDTO> queryAll(MemberProfileQueryCriteria criteria) {
return MemberProfileMapper.toDto(MemberProfileRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
}
@Override
public MemberProfileDTO findById(Long id) {
MemberProfile MemberProfile = MemberProfileRepository.findById(id).orElseGet(MemberProfile::new);
ValidationUtil.isNull(MemberProfile.getId(),"MemberProfile","id",id);
return MemberProfileMapper.toDto(MemberProfile);
}
@Override
@Transactional(rollbackFor = Exception.class)
@AsyncMqSend()
public void create(MemberProfile resources) {
MemberProfileRepository.save(resources);
}
@Override
@Transactional(rollbackFor = Exception.class)
@AsyncMqSend()
public void update(MemberProfile resources) {
MemberProfile MemberProfile = MemberProfileRepository.findById(resources.getId()).orElseGet(MemberProfile::new);
ValidationUtil.isNull( MemberProfile.getId(),"MemberProfile","id",resources.getId());
MemberProfile.copy(resources);
MemberProfileRepository.save(MemberProfile);
}
@Override
@Transactional(rollbackFor = Exception.class)
@AsyncMqSend()
public void delete(Long id) {
Assert.notNull(id, "The given id must not be null!");
MemberProfile MemberProfile = MemberProfileRepository.findById(id).orElseThrow(
() -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", MemberProfile.class, id), 1));
MemberProfileRepository.delete(MemberProfile);
}
}
package com.topdraw.business.basicdata.member.profile.service.mapper;
import com.topdraw.base.BaseMapper;
import com.topdraw.business.basicdata.member.profile.domain.MemberProfile;
import com.topdraw.business.basicdata.member.profile.service.dto.MemberProfileDTO;
import org.mapstruct.Mapper;
import org.mapstruct.ReportingPolicy;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface MemberProfileMapper extends BaseMapper<MemberProfileDTO, MemberProfile> {
}
package com.topdraw.business.basicdata.member.relatedinfo.domain;
import lombok.Data;
import lombok.experimental.Accessors;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import javax.persistence.*;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;
import java.sql.Timestamp;
import java.io.Serializable;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Entity
@Data
@EntityListeners(AuditingEntityListener.class)
@Accessors(chain = true)
@Table(name="uc_member_related_info")
public class MemberRelatedInfo implements Serializable {
// ID
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
// 会员id
@Column(name = "member_id", nullable = false)
private Long memberId;
// 人物关系 0：子女；1：父母
@Column(name = "type")
private Integer type;
// 手机号
@Column(name = "cellphone")
private String cellphone;
// 身份证号
@Column(name = "id_card")
private String idCard;
// 姓名
@Column(name = "name")
private String name;
// 性别 0：女；1：男；-1：未知
@Column(name = "sex")
private Integer sex;
// 创建时间
@CreatedDate
@Column(name = "create_time")
private Timestamp createTime;
// 更新时间
@LastModifiedDate
@Column(name = "update_time")
private Timestamp updateTime;
public void copy(MemberRelatedInfo source){
BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
}
}
package com.topdraw.business.basicdata.member.relatedinfo.repository;
import com.topdraw.business.basicdata.member.relatedinfo.domain.MemberRelatedInfo;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
/**
* @author XiangHan
* @date 2021-10-22
*/
public interface MemberRelatedInfoRepository extends JpaRepository<MemberRelatedInfo, Long>, JpaSpecificationExecutor<MemberRelatedInfo> {
}
package com.topdraw.business.basicdata.member.relatedinfo.rest;
import com.topdraw.common.ResultInfo;
import com.topdraw.annotation.Log;
import com.topdraw.business.basicdata.member.relatedinfo.domain.MemberRelatedInfo;
import com.topdraw.business.basicdata.member.relatedinfo.service.MemberRelatedInfoService;
import com.topdraw.business.basicdata.member.relatedinfo.service.dto.MemberRelatedInfoQueryCriteria;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import io.swagger.annotations.*;
/**
* @author XiangHan /api/MemberRelatedInfo
* @date 2021-10-22
*/
@Api(tags = "MemberRelatedInfo管理")
@RestController
@RequestMapping("/api/MemberRelatedInfo")
public class MemberRelatedInfoController {
@Autowired
private MemberRelatedInfoService MemberRelatedInfoService;
@GetMapping(value = "/pageMemberRelatedInfos")
@ApiOperation("查询MemberRelatedInfo")
public ResultInfo pageMemberRelatedInfos(@Validated MemberRelatedInfoQueryCriteria criteria, Pageable pageable) {
return ResultInfo.successPage(MemberRelatedInfoService.queryAll(criteria,pageable));
}
@Log
@PostMapping(value = "/create")
@ApiOperation("新增MemberRelatedInfo")
public ResultInfo create(@Validated @RequestBody MemberRelatedInfo resources) {
MemberRelatedInfoService.create(resources);
return ResultInfo.success();
}
@Log
@PutMapping(value = "/update")
@ApiOperation("修改MemberRelatedInfo")
public ResultInfo update(@Validated @RequestBody MemberRelatedInfo resources) {
MemberRelatedInfoService.update(resources);
return ResultInfo.success();
}
@GetMapping(value = "/findById/{id}")
@ApiOperation("查询指定MemberRelatedInfo")
public ResultInfo findById(@PathVariable("id") Long id) {
return ResultInfo.success(MemberRelatedInfoService.findById(id));
}
@Log
@DeleteMapping(value = "/delete//{id}")
@ApiOperation("删除MemberRelatedInfo")
public ResultInfo delete(@PathVariable Long id) {
MemberRelatedInfoService.delete(id);
return ResultInfo.success();
}
}
package com.topdraw.business.basicdata.member.relatedinfo.service;
import com.topdraw.business.basicdata.member.relatedinfo.domain.MemberRelatedInfo;
import com.topdraw.business.basicdata.member.relatedinfo.service.dto.MemberRelatedInfoDTO;
import com.topdraw.business.basicdata.member.relatedinfo.service.dto.MemberRelatedInfoQueryCriteria;
import org.springframework.data.domain.Pageable;
import java.util.Map;
import java.util.List;
/**
* @author XiangHan
* @date 2021-10-22
*/
public interface MemberRelatedInfoService {
/**
* 查询数据分页
* @param criteria 条件参数
* @param pageable 分页参数
* @return Map<String,Object>
*/
Map<String,Object> queryAll(MemberRelatedInfoQueryCriteria criteria, Pageable pageable);
/**
* 查询所有数据不分页
* @param criteria 条件参数
* @return List<MemberRelatedInfoDTO>
*/
List<MemberRelatedInfoDTO> queryAll(MemberRelatedInfoQueryCriteria criteria);
/**
* 根据ID查询
* @param id ID
* @return MemberRelatedInfoDTO
*/
MemberRelatedInfoDTO findById(Long id);
void create(MemberRelatedInfo resources);
void update(MemberRelatedInfo resources);
void delete(Long id);
}
package com.topdraw.business.basicdata.member.relatedinfo.service.dto;
import lombok.Data;
import java.sql.Timestamp;
import java.io.Serializable;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class MemberRelatedInfoDTO implements Serializable {
// ID
private Long id;
// 会员id
private Long memberId;
// 人物关系 0：子女；1：父母
private Integer type;
// 手机号
private String cellphone;
// 身份证号
private String idCard;
// 姓名
private String name;
// 性别 0：女；1：男；-1：未知
private Integer sex;
// 创建时间
private Timestamp createTime;
// 更新时间
private Timestamp updateTime;
}
package com.topdraw.business.basicdata.member.relatedinfo.service.dto;
import com.topdraw.annotation.Query;
import lombok.Data;
import javax.validation.constraints.NotNull;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class MemberRelatedInfoQueryCriteria{
@Query
private Long memberId;
}
package com.topdraw.business.basicdata.member.relatedinfo.service.impl;
import com.topdraw.aspect.AsyncMqSend;
import com.topdraw.business.basicdata.member.relatedinfo.domain.MemberRelatedInfo;
import com.topdraw.utils.ValidationUtil;
import com.topdraw.business.basicdata.member.relatedinfo.repository.MemberRelatedInfoRepository;
import com.topdraw.business.basicdata.member.relatedinfo.service.MemberRelatedInfoService;
import com.topdraw.business.basicdata.member.relatedinfo.service.dto.MemberRelatedInfoDTO;
import com.topdraw.business.basicdata.member.relatedinfo.service.dto.MemberRelatedInfoQueryCriteria;
import com.topdraw.business.basicdata.member.relatedinfo.service.mapper.MemberRelatedInfoMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.util.Assert;
import com.topdraw.utils.PageUtil;
import com.topdraw.utils.QueryHelp;
import java.util.List;
import java.util.Map;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Service
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
public class MemberRelatedInfoServiceImpl implements MemberRelatedInfoService {
@Autowired
private MemberRelatedInfoRepository MemberRelatedInfoRepository;
@Autowired
private MemberRelatedInfoMapper MemberRelatedInfoMapper;
@Override
public Map<String, Object> queryAll(MemberRelatedInfoQueryCriteria criteria, Pageable pageable) {
Page<MemberRelatedInfo> page = MemberRelatedInfoRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
return PageUtil.toPage(page.map(MemberRelatedInfoMapper::toDto));
}
@Override
public List<MemberRelatedInfoDTO> queryAll(MemberRelatedInfoQueryCriteria criteria) {
return MemberRelatedInfoMapper.toDto(MemberRelatedInfoRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
}
@Override
public MemberRelatedInfoDTO findById(Long id) {
MemberRelatedInfo MemberRelatedInfo = MemberRelatedInfoRepository.findById(id).orElseGet(MemberRelatedInfo::new);
ValidationUtil.isNull(MemberRelatedInfo.getId(),"MemberRelatedInfo","id",id);
return MemberRelatedInfoMapper.toDto(MemberRelatedInfo);
}
@Override
@Transactional(rollbackFor = Exception.class)
@AsyncMqSend()
public void create(MemberRelatedInfo resources) {
MemberRelatedInfoRepository.save(resources);
}
@Override
@Transactional(rollbackFor = Exception.class)
@AsyncMqSend()
public void update(MemberRelatedInfo resources) {
MemberRelatedInfo MemberRelatedInfo = MemberRelatedInfoRepository.findById(resources.getId()).orElseGet(MemberRelatedInfo::new);
ValidationUtil.isNull( MemberRelatedInfo.getId(),"MemberRelatedInfo","id",resources.getId());
MemberRelatedInfo.copy(resources);
MemberRelatedInfoRepository.save(MemberRelatedInfo);
}
@Override
@Transactional(rollbackFor = Exception.class)
@AsyncMqSend()
public void delete(Long id) {
Assert.notNull(id, "The given id must not be null!");
MemberRelatedInfo MemberRelatedInfo = MemberRelatedInfoRepository.findById(id).orElseThrow(
() -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", MemberRelatedInfo.class, id), 1));
MemberRelatedInfoRepository.delete(MemberRelatedInfo);
}
}
package com.topdraw.business.basicdata.member.relatedinfo.service.mapper;
import com.topdraw.base.BaseMapper;
import com.topdraw.business.basicdata.member.relatedinfo.domain.MemberRelatedInfo;
import com.topdraw.business.basicdata.member.relatedinfo.service.dto.MemberRelatedInfoDTO;
import org.mapstruct.Mapper;
import org.mapstruct.ReportingPolicy;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface MemberRelatedInfoMapper extends BaseMapper<MemberRelatedInfoDTO, MemberRelatedInfo> {
}
package com.topdraw.business.basicdata.member.repository;
import com.topdraw.business.basicdata.member.domain.Member;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import java.util.Optional;
/**
* @author XiangHan
* @date 2021-10-22
*/
public interface MemberRepository extends JpaRepository<Member, Long>, JpaSpecificationExecutor<Member> {
Optional<Member> findFirstByCode(String code);
}
package com.topdraw.business.basicdata.member.rest;
import com.topdraw.annotation.Log;
import com.topdraw.business.basicdata.member.domain.Member;
import com.topdraw.business.basicdata.member.service.MemberService;
import com.topdraw.business.basicdata.member.service.dto.MemberQueryCriteria;
import com.topdraw.common.ResultInfo;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Pageable;
import org.springframework.util.Assert;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Api(tags = "Member管理")
@RestController
@RequestMapping("/api/member")
public class MemberController {
@Autowired
private MemberService memberService;
/* @GetMapping(value = "/pageMembers")
@ApiOperation("查询Member")
public ResultInfo pageMembers(MemberQueryCriteria criteria, Pageable pageable) {
return ResultInfo.successPage(memberService.queryAll(criteria,pageable));
}
@GetMapping(value = "/findById/{id}")
@ApiOperation("查询指定Member")
public ResultInfo findById(@PathVariable("id") Long id) {
return ResultInfo.success(memberService.findById(id));
}
*/
@Log
@PostMapping(value = "/create")
@ApiOperation("新增Member")
public ResultInfo create(@Validated @RequestBody Member resources) {
Long id = memberService.create(resources);
return ResultInfo.success(id);
}
@Log
@PutMapping(value = "/doUpdateVip")
@ApiOperation("修改Member等级")
public ResultInfo doUpdateVip(Long memberId , Integer vip) {
Assert.isNull(memberId,"MemberController -->> doUpdateVip -->>【memberId】 not be null!!");
Assert.isNull(vip,"MemberController -->> doUpdateVip -->>【memberId】 not be null!!");
Member member = new Member();
member.setId(memberId);
member.setVip(vip);
memberService.update(member);
return ResultInfo.success();
}
@Log
@PutMapping(value = "/update")
@ApiOperation("修改Member")
public ResultInfo update(@Validated @RequestBody Member resources) {
memberService.update(resources);
return ResultInfo.success();
}
@GetMapping(value = "/getByCode/{code}")
@ApiOperation(value = "根据标识查询")
public ResultInfo getByCode(@PathVariable String code) {
return ResultInfo.success(memberService.getByCode(code));
}
}
package com.topdraw.business.basicdata.member.service;
import com.topdraw.business.basicdata.member.domain.Member;
import com.topdraw.business.basicdata.member.service.dto.MemberDTO;
import com.topdraw.business.basicdata.member.service.dto.MemberQueryCriteria;
import org.springframework.data.domain.Pageable;
import java.util.List;
import java.util.Map;
/**
* @author XiangHan
* @date 2021-10-22
*/
public interface MemberService {
/**
* 查询数据分页
* @param criteria 条件参数
* @param pageable 分页参数
* @return Map<String,Object>
*/
Map<String,Object> queryAll(MemberQueryCriteria criteria, Pageable pageable);
/**
* 查询所有数据不分页
* @param criteria 条件参数
* @return List<MemberDTO>
*/
List<MemberDTO> queryAll(MemberQueryCriteria criteria);
/**
* 根据ID查询
* @param id ID
* @return MemberDTO
*/
MemberDTO findById(Long id);
Long create(Member resources);
void update(Member resources);
void delete(Long id);
/**
* Code校验
* @param code
* @return MemberDTO
*/
MemberDTO getByCode(String code);
}
package com.topdraw.business.basicdata.member.service.dto;
import lombok.Data;
import java.io.Serializable;
import java.sql.Timestamp;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class MemberDTO implements Serializable {
// 主键
private Long id;
// 标识
private String code;
// 类型 1：大屏；2：小屏
private Integer type;
// 状态 0：不可用；1：可用
private Integer status;
// 昵称 base64
private String nickname;
// 描述
private String description;
// 性别 0：女；1：男；-1：未知
private Integer gender;
// 生日
private String birthday;
// 头像
private String avatarUrl;
// 分组信息
private String groups;
// 标签
private String tags;
// 是否会员 0：非会员；1：会员
private Integer vip;
// 会员等级（对应level表的level字段，非id）
private Integer level;
// 成长值
private Long exp;
// 当前积分
private Long points;
// 即将到期积分（一个月内）
private Long duePoints;
// 优惠券数量
private Long couponAmount;
// 即将过期优惠券数量
private Long dueCouponAmount;
// iptv账号id
private Long userIptvId;
// 绑定IPTV平台 0：未知；1：电信；2：移动；3：联通
private Integer bindIptvPlatformType;
// iptv账号绑定时间
private Timestamp bindIptvTime;
// 创建时间
private Timestamp createTime;
// 更新时间
private Timestamp updateTime;
// 是否在黑名单 1：是；0否
// private Integer blackStatus;
}
package com.topdraw.business.basicdata.member.service.dto;
import com.topdraw.annotation.Query;
import lombok.Data;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class MemberQueryCriteria{
@Query(type = Query.Type.LEFT_LIKE)
private String code;
// 类型 1：大屏；2：小屏
@Query(type = Query.Type.EQUAL)
private Integer type;
// 状态 0：不可用；1：可用
@Query(type = Query.Type.EQUAL)
private Integer status;
// 昵称 base64
@Query(type = Query.Type.LEFT_LIKE)
private String nickname;
// 性别 0：女；1：男；-1：未知
@Query(type = Query.Type.EQUAL)
private Integer gender;
// 分组信息
@Query(type = Query.Type.EQUAL)
private String groups;
// 标签
@Query(type = Query.Type.IN)
private String tags;
// 是否会员 0：非会员；1：会员
@Query(type = Query.Type.EQUAL)
private Integer vip;
// 会员等级（对应level表的level字段，非id）
@Query(type = Query.Type.EQUAL)
private Integer level;
// iptv账号id
@Query(type = Query.Type.EQUAL)
private Long userIptvId;
// 绑定IPTV平台 0：未知；1：电信；2：移动；3：联通
@Query(type = Query.Type.IN)
private Integer bindIptvPlatformType;
}
package com.topdraw.business.basicdata.member.service.impl;
import com.topdraw.aspect.AsyncMqSend;
import com.topdraw.business.basicdata.member.domain.Member;
import com.topdraw.business.basicdata.member.repository.MemberRepository;
import com.topdraw.business.basicdata.member.service.MemberService;
import com.topdraw.business.basicdata.member.service.dto.MemberDTO;
import com.topdraw.business.basicdata.member.service.dto.MemberQueryCriteria;
import com.topdraw.business.basicdata.member.service.mapper.MemberMapper;
import com.topdraw.mq.config.RabbitMqConfig;
import com.topdraw.util.IdWorker;
import com.topdraw.util.RedissonUtil;
import com.topdraw.util.TimestampUtil;
import com.topdraw.utils.PageUtil;
import com.topdraw.utils.QueryHelp;
import com.topdraw.utils.StringUtils;
import com.topdraw.utils.ValidationUtil;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;
import java.util.List;
import java.util.Map;
import java.util.Objects;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Service
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
public class MemberServiceImpl implements MemberService {
@Autowired
private MemberRepository memberRepository;
@Autowired
private MemberMapper memberMapper;
@Autowired
private RedissonClient redissonClient;
@Override
public Map<String, Object> queryAll(MemberQueryCriteria criteria, Pageable pageable) {
Page<Member> page = memberRepository.findAll((root, criteriaQuery, criteriaBuilder)
-> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
return PageUtil.toPage(page.map(memberMapper::toDto));
}
@Override
public List<MemberDTO> queryAll(MemberQueryCriteria criteria) {
return memberMapper.toDto(memberRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
}
@Override
public MemberDTO findById(Long id) {
Member member = memberRepository.findById(id).orElseGet(Member::new);
ValidationUtil.isNull(member.getId(),"Member","id",id);
return memberMapper.toDto(member);
}
@Override
@Transactional(rollbackFor = Exception.class)
@AsyncMqSend()
public Long create(Member resources) {
Member member = this.checkMemberData(resources);
memberRepository.save(member);
return member.getId();
}
private Member checkMemberData(Member member) {
Long defaultValue = 0L;
member.setCode(String.valueOf(IdWorker.generator()));
Integer gender = member.getGender();
member.setGender(Objects.nonNull(gender) ? gender : 0);
Integer type = member.getType();
member.setType(Objects.nonNull(type) ? type:-1);
Integer status = member.getStatus();
member.setStatus(Objects.nonNull(status) ? status:1);
Integer vip = member.getVip();
member.setVip(Objects.nonNull(vip) ? status:0);
Integer level = member.getLevel();
member.setLevel(Objects.nonNull(level) ? level:0);
member.setExp(defaultValue);
member.setPoints(defaultValue);
member.setDuePoints(defaultValue);
member.setCouponAmount(defaultValue);
member.setDueCouponAmount(defaultValue);
return member;
}
@Override
@Transactional(rollbackFor = Exception.class)
@AsyncMqSend()
public void update(Member resources) {
RLock rLock = this.redissonClient.getLock("updateMember" + resources.getId().toString());
try {
RedissonUtil.lock(rLock);
Member member = memberRepository.findById(resources.getId()).orElseGet(Member::new);
ValidationUtil.isNull(member.getId(), "Member", "id", resources.getId());
member.copy(resources);
memberRepository.save(member);
} catch (Exception e) {
e.printStackTrace();
throw e;
} finally {
RedissonUtil.unlock(rLock);
}
}
@Override
@Transactional(rollbackFor = Exception.class)
@AsyncMqSend()
public void delete(Long id) {
Assert.notNull(id, "The given id must not be null!");
Member member = memberRepository.findById(id).orElseThrow(
() -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", Member.class, id), 1));
memberRepository.delete(member);
}
@Override
public MemberDTO getByCode(String code) {
return StringUtils.isNotEmpty(code) ? memberMapper.toDto(memberRepository.findFirstByCode(code).orElseGet(Member::new))
: new MemberDTO();
}
}
package com.topdraw.business.basicdata.member.service.mapper;
import com.topdraw.base.BaseMapper;
import com.topdraw.business.basicdata.member.domain.Member;
import com.topdraw.business.basicdata.member.service.dto.MemberDTO;
import org.mapstruct.Mapper;
import org.mapstruct.ReportingPolicy;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface MemberMapper extends BaseMapper<MemberDTO, Member> {
}
package com.topdraw.business.basicdata.points.available.domain;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import lombok.experimental.Accessors;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import javax.persistence.*;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;
import java.sql.Timestamp;
import java.util.UUID;
import java.io.Serializable;
/**
* 每天定时扫描可用积分表，将过期积分删除，并及时更新积分明细表和积分总额表
*
* @author XiangHan
* @date 2021-10-23
*/
@Entity
@Data
@EntityListeners(AuditingEntityListener.class)
@Accessors(chain = true)
@Table(name="uc_points_available")
public class PointsAvailable implements Serializable {
// 主键
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
// 标识
@Column(name = "code")
private String code;
// 积分类型 0：通用型
@Column(name = "points_type")
private Integer pointsType;
// 设备类型 1：大屏；2：小屏（微信）3.小屏（xx）
@Column(name = "device_type")
private Integer deviceType;
// 会员id
@Column(name = "member_id", nullable = false)
private Long memberId;
// 积分值
@Column(name = "points")
private Long points;
// 过期时间
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@Column(name = "expire_time")
private Timestamp expireTime;
// 描述
@Column(name = "description")
private String description;
// 创建时间
@CreatedDate
@Column(name = "create_time")
private Timestamp createTime;
// 更新时间
@LastModifiedDate
@Column(name = "update_time")
private Timestamp updateTime;
public void copy(PointsAvailable source){
BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
}
}
package com.topdraw.business.basicdata.points.available.repository;
import com.topdraw.business.basicdata.points.available.domain.PointsAvailable;
import com.topdraw.business.basicdata.points.available.service.dto.PointsAvailableDTO;
import com.topdraw.business.basicdata.points.available.service.dto.PointsAvailableQueryCriteria;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.transaction.annotation.Transactional;
import java.sql.Timestamp;
import java.util.Date;
import java.util.List;
import java.util.Optional;
/**
* @author XiangHan
* @date 2021-10-23
*/
public interface PointsAvailableRepository extends JpaRepository<PointsAvailable, Long>, JpaSpecificationExecutor<PointsAvailable> {
Optional<PointsAvailable> findFirstByCode(String code);
List<PointsAvailableDTO> findByMemberId(Long memberId);
List<PointsAvailable> findByMemberIdAndExpireTimeBefore(Long memberId , Date now);
/**
* 即将过期的积分
* @param memberId
* @param factor
* @return
*/
@Query(value = "SELECT sum(upa.points) AS pointsExpire from uc_points_available upa where upa.member_id = ?1 " +
" and (TO_DAYS(expire_time) - TO_DAYS(NOW())) <= ?2 "
,nativeQuery = true)
Long findSoonExpireTime(Long memberId, Integer factor);
/**
* 总积分
* @param criteria
* @return
*/
@Deprecated
@Query(value = "SELECT sum(upa.points) AS pointsProduce FROM uc_points_available upa WHERE (TO_DAYS(create_time)+1) = TO_DAYS(NOW())"
,nativeQuery = true)
Long findEveryDayPointsProduce(PointsAvailableQueryCriteria criteria);
/**
* 可用总积分
* @param criteria
* @return
*/
@Deprecated
@Query(value = "SELECT sum(upa.points) AS pointsAvailable FROM uc_points_available upa WHERE (TO_DAYS(create_time)+1) = TO_DAYS(NOW())"
,nativeQuery = true)
Long findEveryDayPointsAvailable(PointsAvailableQueryCriteria criteria);
/**
* 过期总积分
* @param criteria
* @return
*/
@Deprecated
@Query(value = "SELECT sum(upa.points) AS pointsExpire from uc_points_available upa where (TO_DAYS(create_time)+1) = TO_DAYS(NOW()) " +
" and TO_DAYS(expire_time) < TO_DAYS(NOW())"
,nativeQuery = true)
Long findEveryDayPointsExpire(PointsAvailableQueryCriteria criteria);
/**
* 获取可用积分
* @param memberId
* @return
*/
@Query(value = "SELECT sum(upa.points) AS pointsExpire from uc_points_available upa where upa.member_id = ?1 and upa.expire_time >= now()"
,nativeQuery = true)
long findAvailablePointsByMemberId(long memberId);
List<PointsAvailable> findByMemberIdOrderByExpireTime(Long memberId);
@Transactional
@Modifying
@Query(value = "delete from uc_points_available where id in ?1" ,nativeQuery = true)
void deleteBatchByIds(List<Long> id);
List<PointsAvailable> findByExpireTimeBefore(Timestamp now);
}
package com.topdraw.business.basicdata.points.available.rest;
import com.topdraw.common.ResultInfo;
import com.topdraw.annotation.Log;
import com.topdraw.business.basicdata.points.available.domain.PointsAvailable;
import com.topdraw.business.basicdata.points.available.service.PointsAvailableService;
import com.topdraw.business.basicdata.points.available.service.dto.PointsAvailableQueryCriteria;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Pageable;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import io.swagger.annotations.*;
import java.io.IOException;
import javax.servlet.http.HttpServletResponse;
/**
* @author XiangHan
* @date 2021-10-23
*/
//@Api(tags = "PointsAvailable管理")
//@RestController
//@RequestMapping("/api/PointsAvailable")
public class PointsAvailableController {
/*@Autowired
private PointsAvailableService PointsAvailableService;
@GetMapping
@ApiOperation("查询PointsAvailable")
public ResultInfo getPointsAvailables(PointsAvailableQueryCriteria criteria, Pageable pageable) {
return ResultInfo.successPage(PointsAvailableService.queryAll(criteria,pageable));
}
@GetMapping(value = "/all")
@ApiOperation("查询所有PointsAvailable")
public ResultInfo getPointsAvailables(PointsAvailableQueryCriteria criteria) {
return ResultInfo.success(PointsAvailableService.queryAll(criteria));
}
@Log
@PostMapping
@ApiOperation("新增PointsAvailable")
public ResultInfo create(@Validated @RequestBody PointsAvailable resources) {
PointsAvailableService.create(resources);
return ResultInfo.success();
}
@Log
@PutMapping
@ApiOperation("修改PointsAvailable")
public ResultInfo update(@Validated @RequestBody PointsAvailable resources) {
PointsAvailableService.update(resources);
return ResultInfo.success();
}
@Log
@DeleteMapping(value = "/{id}")
@ApiOperation("删除PointsAvailable")
public ResultInfo delete(@PathVariable Long id) {
PointsAvailableService.delete(id);
return ResultInfo.success();
}
@GetMapping(value = "/getByCode/{code}")
@ApiOperation(value = "根据标识查询")
public ResultInfo getByCode(@PathVariable String code) {
return ResultInfo.success(PointsAvailableService.getByCode(code));
}*/
}
package com.topdraw.business.basicdata.points.available.service;
import com.topdraw.business.basicdata.points.available.domain.PointsAvailable;
import com.topdraw.business.basicdata.points.available.service.dto.PointsAvailableDTO;
import com.topdraw.business.basicdata.points.available.service.dto.PointsAvailableQueryCriteria;
import com.topdraw.business.process.domian.TempPoints;
import org.springframework.data.domain.Pageable;
import java.sql.Timestamp;
import java.util.Date;
import java.util.Map;
import java.util.List;
import java.io.IOException;
import javax.servlet.http.HttpServletResponse;
/**
* @author XiangHan
* @date 2021-10-23
*/
public interface PointsAvailableService {
/**
* 查询数据分页
* @param criteria 条件参数
* @param pageable 分页参数
* @return Map<String,Object>
*/
Map<String,Object> queryAll(PointsAvailableQueryCriteria criteria, Pageable pageable);
/**
* 查询所有数据不分页
* @param criteria 条件参数
* @return List<PointsAvailableDTO>
*/
List<PointsAvailableDTO> queryAll(PointsAvailableQueryCriteria criteria);
/**
* 根据ID查询
* @param id ID
* @return PointsAvailableDTO
*/
PointsAvailableDTO findById(Long id);
/**
*
* @param resources
*/
void create(PointsAvailable resources);
/**
*
* @param resources
*/
void update(PointsAvailable resources);
/**
*
* @param id
*/
void delete(Long id);
/**
*
* @param id
*/
void deleteBatchByIds(List<Long> id);
/**
* Code校验
* @param code
* @return PointsAvailableDTO
*/
PointsAvailableDTO getByCode(String code);
/**
* 已过期的积分
* @param memberId
* @param timestamp
* @return
*/
List<PointsAvailableDTO> findByMemberIdAndExpireTimeBefore(Long memberId, Date timestamp);
/**
* 即将过期的积分
* @param memberId 会员id
* @param factor 阈值
* @return
*/
Long findSoonExpireTime(Long memberId,Integer factor);
/**
* 查询数据分页
* @param criteria 条件参数
* @param pageable 分页参数
* @return Map<String,Object>
*/
Map<String,Object> findByMemberIdAndExpireTimeBefore(PointsAvailableQueryCriteria criteria, Pageable pageable);
/**
*
* @param memberId
* @return
*/
List<PointsAvailableDTO> findByMemberIdOrderByExpireTime(Long memberId);
/**
* 可用总积分
* @param criteria 条件参数
* @return Map<String,Object>
*/
Long findEveryDayPointsAvailable(PointsAvailableQueryCriteria criteria);
/**
* 总积分
* @param criteria
* @return
*/
Long findEveryDayPointsProduce(PointsAvailableQueryCriteria criteria);
/**
* 积分消耗
* @param criteria
* @return
*/
Long findEveryDayPointsConsume(PointsAvailableQueryCriteria criteria);
/**
* 积分过期
* @param criteria
* @return
*/
Long findEveryDayPointsExpire(PointsAvailableQueryCriteria criteria);
long findAvailablePointsByMemberId(long memberId);
List<PointsAvailableDTO> findByExpireTimeBefore(Timestamp now);
}
This diff is collapsed. Click to expand it.