Skip to content

向汉 / uc-consumer

Go to a project
Toggle navigation
Toggle navigation pinning
Commit 98e6049d 98e6049d90d71a66e164c14792ebe031e7d72bdf by xianghan@topdraw.cn
Options

init project

1 parent 9f9cab09
Expand all
Inline Side-by-side
Showing 188 changed files with 4732 additions and 0 deletions
1 <?xml version="1.0" encoding="UTF-8"?>
2 <project xmlns="http://maven.apache.org/POM/4.0.0"
3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5 <modelVersion>4.0.0</modelVersion>
6
7 <groupId>com.topdraw</groupId>
8 <artifactId>member-engine</artifactId>
9 <version>0.0.1-SNAPSHOT</version>
10
11 <properties>
12 <maven.compiler.source>8</maven.compiler.source>
13 <maven.compiler.target>8</maven.compiler.target>
14 <jjwt.version>0.9.1</jjwt.version>
15 </properties>
16
17 <parent>
18 <groupId>org.springframework.boot</groupId>
19 <artifactId>spring-boot-starter-parent</artifactId>
20 <version>2.2.10.RELEASE</version>
21 <relativePath/>
22 </parent>
23
24 <dependencies>
25
26 <!--代码生成器-->
27 <dependency>
28 <groupId>com.topdraw</groupId>
29 <artifactId>code-generator</artifactId>
30 <version>3.1.0</version>
31 </dependency>
32
33 <!-- Spring boot 热部署 : 此热部署会遇到 java.lang.ClassCastException 异常 -->
34 <dependency>
35 <groupId>org.springframework.boot</groupId>
36 <artifactId>spring-boot-devtools</artifactId>
37 <optional>true</optional>
38 <scope>runtime</scope>
39 </dependency>
40
41 <dependency>
42 <groupId>org.springframework.boot</groupId>
43 <artifactId>spring-boot-starter-test</artifactId>
44 </dependency>
45
46 <!--Mysql依赖包，版本差异，需单独引入-->
47 <dependency>
48 <groupId>mysql</groupId>
49 <artifactId>mysql-connector-java</artifactId>
50 <version>8.0.26</version>
51 </dependency>
52
53 <dependency>
54 <groupId>junit</groupId>
55 <artifactId>junit</artifactId>
56 <version>4.12</version>
57 <scope>test</scope>
58 </dependency>
59
60 <!-- 支持AES/CBC/PKCS7Padding，用于微信小程序登录数据解密 -->
61 <dependency>
62 <groupId>org.bouncycastle</groupId>
63 <artifactId>bcprov-jdk16</artifactId>
64 <version>1.46</version>
65 </dependency>
66
67 <!--消息队列相关依赖-->
68 <dependency>
69 <groupId>org.springframework.boot</groupId>
70 <artifactId>spring-boot-starter-amqp</artifactId>
71 </dependency>
72
73 <!--重试-->
74 <dependency>
75 <groupId>org.springframework.retry</groupId>
76 <artifactId>spring-retry</artifactId>
77 </dependency>
78
79 <dependency>
80 <groupId>org.aspectj</groupId>
81 <artifactId>aspectjweaver</artifactId>
82 </dependency>
83
84 <dependency>
85 <groupId>commons-codec</groupId>
86 <artifactId>commons-codec</artifactId>
87 <version>1.9</version>
88 </dependency>
89
90 </dependencies>
91
92
93 <profiles>
94 <profile>
95 <!-- 本地开发环境 -->
96 <id>dev</id>
97 <properties>
98 <profiles.active>dev</profiles.active>
99 </properties>
100 <activation>
101 <!-- 默认的，不加参数时执行这个profile -->
102 <activeByDefault>true</activeByDefault>
103 </activation>
104 </profile>
105 <profile>
106 <!-- 生产环境 -->
107 <id>prod</id>
108 <properties>
109 <profiles.active>prod</profiles.active>
110 <modifier>-prod</modifier>
111 </properties>
112 </profile>
113 </profiles>
114
115 <build>
116 <finalName>member-engine</finalName>
117 <plugins>
118 <plugin>
119 <groupId>org.springframework.boot</groupId>
120 <artifactId>spring-boot-maven-plugin</artifactId>
121 <configuration>
122 <fork>true</fork>
123 </configuration>
124 </plugin>
125 <!-- 跳过单元测试 -->
126 <plugin>
127 <groupId>org.apache.maven.plugins</groupId>
128 <artifactId>maven-surefire-plugin</artifactId>
129 <configuration>
130 <skipTests>true</skipTests>
131 </configuration>
132 </plugin>
133 <!-- 复制指定配置文件到指定目录 -->
134 <plugin>
135 <artifactId>maven-resources-plugin</artifactId>
136 <executions>
137 <execution>
138 <id>copy-resources</id>
139 <phase>package</phase>
140 <goals>
141 <goal>copy-resources</goal>
142 </goals>
143 <configuration>
144 <resources>
145 <resource>
146 <directory>src/main/resources/config</directory>
147 <includes>
148 <include>application.yml</include>
149 <include>application-${profiles.active}.yml</include>
150 </includes>
151 </resource>
152 </resources>
153 <outputDirectory>${project.build.directory}/config</outputDirectory>
154 </configuration>
155 </execution>
156 </executions>
157 </plugin>
158 <!-- jar包内剔除所有配置文件 -->
159 <plugin>
160 <artifactId>maven-jar-plugin</artifactId>
161 <configuration>
162 <!--不打入jar包的文件类型或者路径-->
163 <excludes>
164 <exclude>config/**</exclude>
165 </excludes>
166 </configuration>
167 </plugin>
168 </plugins>
169 </build>
170
171 </project>
...\ No newline at end of file ...\ No newline at end of file
1 package com.topdraw;
2
3
4 import com.topdraw.utils.SpringContextHolder;
5 import org.springframework.boot.SpringApplication;
6 import org.springframework.boot.autoconfigure.SpringBootApplication;
7 import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration;
8 import org.springframework.boot.builder.SpringApplicationBuilder;
9 import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
10 import org.springframework.context.annotation.Bean;
11 import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
12 import org.springframework.retry.annotation.EnableRetry;
13 import org.springframework.scheduling.annotation.EnableAsync;
14 import org.springframework.transaction.annotation.EnableTransactionManagement;
15
16 @EnableJpaAuditing
17 @EnableAsync
18 @SpringBootApplication(exclude = {SecurityAutoConfiguration.class})
19 @EnableTransactionManagement
20 @EnableRetry
21 public class MemberEngineApplication extends SpringBootServletInitializer {
22
23 public static void main(String[] args) {
24 SpringApplication.run(MemberEngineApplication.class, args);
25 }
26
27 @Override
28 protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
29 return builder.sources(MemberEngineApplication.class);
30 }
31
32 @Bean
33 public SpringContextHolder springContextHolder() {
34 return new SpringContextHolder();
35 }
36
37 }
38
1 package com.topdraw.business.basicdata.coupon.domain;
2
3 import cn.hutool.core.bean.BeanUtil;
4 import cn.hutool.core.bean.copier.CopyOptions;
5 import lombok.Data;
6 import lombok.experimental.Accessors;
7 import org.springframework.data.annotation.CreatedDate;
8 import org.springframework.data.annotation.LastModifiedDate;
9 import org.springframework.data.jpa.domain.support.AuditingEntityListener;
10
11 import javax.persistence.*;
12 import java.io.Serializable;
13 import java.math.BigDecimal;
14 import java.sql.Timestamp;
15
16 /**
17 * @author XiangHan
18 * @date 2021-10-22
19 */
20 @Entity
21 @Data
22 @EntityListeners(AuditingEntityListener.class)
23 @Accessors(chain = true)
24 @Table(name="m_coupon")
25 public class Coupon implements Serializable {
26
27 // id
28 @Id
29 @GeneratedValue(strategy = GenerationType.IDENTITY)
30 @Column(name = "id")
31 private Long id;
32
33 // 标识
34 @Column(name = "code", nullable = false)
35 private String code;
36
37 // 名称
38 @Column(name = "title", nullable = false)
39 private String title;
40
41 // 图片
42 @Column(name = "images")
43 private String images;
44
45 // 发行量，-1代表不限量
46 @Column(name = "stock")
47 private Integer stock;
48
49 // 剩余量，-1代表不限量
50 @Column(name = "remain_stock")
51 private Integer remainStock;
52
53 // 优惠形式：1：现金；2：折扣
54 @Column(name = "use_type")
55 private Integer useType;
56
57 // 面额
58 @Column(name = "denomination")
59 private BigDecimal denomination;
60
61 // 折扣
62 @Column(name = "discount")
63 private BigDecimal discount;
64
65 // 适用用户范围：1：新用户；2：全体用户
66 @Column(name = "user_range")
67 private Integer userRange;
68
69 // 限领次数 -1：无限次； >0：具体次数
70 @Column(name = "collect_limit")
71 private Integer collectLimit;
72
73 // 适用门槛：1：无门槛；2：满减形式
74 @Column(name = "threshold_type")
75 private Integer thresholdType;
76
77 // 满减门槛
78 @Column(name = "amount_threshold")
79 private BigDecimal amountThreshold;
80
81 // 产品范围：1：全部商品；2：指定商品
82 @Column(name = "item_range")
83 private Integer itemRange;
84
85 // 生效形式：1：固定日期；2：相对日期
86 @Column(name = "effect_type")
87 private Integer effectType;
88
89 // 生效时间
90 @Column(name = "start_time")
91 private Timestamp startTime;
92
93 // 过期时间
94 @Column(name = "expire_time")
95 private Timestamp expireTime;
96
97 // 自领取当日，几天内有效
98 @Column(name = "valid_days")
99 private Integer validDays;
100
101 // 使用说明
102 @Column(name = "description")
103 private String description;
104
105 // 状态0：未开始，1:启用；2：停用
106 @Column(name = "status")
107 private Integer status;
108
109 // 创建时间
110 @CreatedDate
111 @Column(name = "create_time")
112 private Timestamp createTime;
113
114 // 更新时间
115 @LastModifiedDate
116 @Column(name = "update_time")
117 private Timestamp updateTime;
118
119 public void copy(Coupon source){
120 BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
121 }
122 }
1 package com.topdraw.business.basicdata.coupon.history.domain;
2
3 import cn.hutool.core.bean.BeanUtil;
4 import cn.hutool.core.bean.copier.CopyOptions;
5 import lombok.Data;
6 import lombok.experimental.Accessors;
7 import org.springframework.data.annotation.CreatedDate;
8 import org.springframework.data.annotation.LastModifiedDate;
9 import org.springframework.data.jpa.domain.support.AuditingEntityListener;
10
11 import javax.persistence.*;
12 import java.io.Serializable;
13 import java.sql.Timestamp;
14
15 /**
16 * @author XiangHan
17 * @date 2021-10-23
18 */
19 @Entity
20 @Data
21 @EntityListeners(AuditingEntityListener.class)
22 @Accessors(chain = true)
23 @Table(name="m_coupon_history")
24 public class CouponHistory implements Serializable {
25
26 // 主键
27 @Id
28 @GeneratedValue(strategy = GenerationType.IDENTITY)
29 @Column(name = "id")
30 private Long id;
31
32 // 优惠券id
33 @Column(name = "coupon_id")
34 private Long couponId;
35
36 // 领券用户id（对应账号）
37 @Column(name = "user_id")
38 private Long userId;
39
40 // 优惠券code
41 @Column(name = "coupon_code")
42 private String couponCode;
43
44 // 领取人昵称
45 @Column(name = "user_nickname")
46 private String userNickname;
47
48 // 领取时间
49 @Column(name = "receive_time")
50 private Timestamp receiveTime;
51
52 // 失效时间
53 @Column(name = "expire_time")
54 private Timestamp expireTime;
55
56 // 使用状态 0：未使用；1：已使用；-1：已过期
57 @Column(name = "use_status")
58 private Integer useStatus;
59
60 // 使用时间
61 @Column(name = "use_time")
62 private Timestamp useTime;
63
64 // 订单详情id
65 @Column(name = "order_detail_id")
66 private Long orderDetailId;
67
68 // 创建时间
69 @CreatedDate
70 @Column(name = "create_time")
71 private Timestamp createTime;
72
73 // 更新时间
74 @LastModifiedDate
75 @Column(name = "update_time")
76 private Timestamp updateTime;
77
78 public void copy(CouponHistory source){
79 BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
80 }
81 }
1 package com.topdraw.business.basicdata.coupon.history.repository;
2
3 import com.topdraw.business.basicdata.coupon.history.domain.CouponHistory;
4 import org.springframework.data.jpa.repository.JpaRepository;
5 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
6
7 import java.sql.Timestamp;
8
9 /**
10 * @author XiangHan
11 * @date 2021-10-23
12 */
13 public interface CouponHistoryRepository extends JpaRepository<CouponHistory, Long>, JpaSpecificationExecutor<CouponHistory> {
14
15 Long countByUserId(Long userId);
16
17 Long countByUserIdAndExpireTimeBefore(Long userId, Timestamp now);
18
19 Long countByUserIdAndExpireTimeBetween(Long userId, Timestamp now, Timestamp expireTime);
20 }
1 package com.topdraw.business.basicdata.coupon.history.rest;
2
3 import com.topdraw.annotation.Log;
4 import com.topdraw.business.basicdata.coupon.history.domain.CouponHistory;
5 import com.topdraw.business.basicdata.coupon.history.service.CouponHistoryService;
6 import com.topdraw.business.basicdata.coupon.history.service.dto.CouponHistoryQueryCriteria;
7 import com.topdraw.common.ResultInfo;
8 import io.swagger.annotations.Api;
9 import io.swagger.annotations.ApiOperation;
10 import org.springframework.beans.factory.annotation.Autowired;
11 import org.springframework.data.domain.Pageable;
12 import org.springframework.validation.annotation.Validated;
13 import org.springframework.web.bind.annotation.*;
14
15 /**
16 * @author XiangHan
17 * @date 2021-10-23
18 */
19 @Api(tags = "CouponHistory管理")
20 @RestController
21 @RequestMapping("/api/CouponHistory")
22 public class CouponHistoryController {
23
24 @Autowired
25 private CouponHistoryService CouponHistoryService;
26
27 @GetMapping
28 @ApiOperation("查询CouponHistory")
29 public ResultInfo getCouponHistorys(CouponHistoryQueryCriteria criteria, Pageable pageable) {
30 return ResultInfo.successPage(CouponHistoryService.queryAll(criteria,pageable));
31 }
32
33 @GetMapping(value = "/all")
34 @ApiOperation("查询所有CouponHistory")
35 public ResultInfo getCouponHistorys(CouponHistoryQueryCriteria criteria) {
36 return ResultInfo.success(CouponHistoryService.queryAll(criteria));
37 }
38
39 @Log
40 @PostMapping
41 @ApiOperation("新增CouponHistory")
42 public ResultInfo create(@Validated @RequestBody CouponHistory resources) {
43 CouponHistoryService.create(resources);
44 return ResultInfo.success();
45 }
46
47 @Log
48 @PutMapping
49 @ApiOperation("修改CouponHistory")
50 public ResultInfo update(@Validated @RequestBody CouponHistory resources) {
51 CouponHistoryService.update(resources);
52 return ResultInfo.success();
53 }
54
55
56 @Log
57 @DeleteMapping(value = "/{id}")
58 @ApiOperation("删除CouponHistory")
59 public ResultInfo delete(@PathVariable Long id) {
60 CouponHistoryService.delete(id);
61 return ResultInfo.success();
62 }
63
64 }
1 package com.topdraw.business.basicdata.coupon.history.service;
2
3 import com.topdraw.business.basicdata.coupon.history.domain.CouponHistory;
4 import com.topdraw.business.basicdata.coupon.history.service.dto.CouponHistoryDTO;
5 import com.topdraw.business.basicdata.coupon.history.service.dto.CouponHistoryQueryCriteria;
6 import org.springframework.data.domain.Pageable;
7
8 import java.sql.Timestamp;
9 import java.util.List;
10 import java.util.Map;
11
12 /**
13 * @author XiangHan
14 * @date 2021-10-23
15 */
16 public interface CouponHistoryService {
17
18 /**
19 * 查询数据分页
20 * @param criteria 条件参数
21 * @param pageable 分页参数
22 * @return Map<String,Object>
23 */
24 Map<String,Object> queryAll(CouponHistoryQueryCriteria criteria, Pageable pageable);
25
26 /**
27 * 查询所有数据不分页
28 * @param criteria 条件参数
29 * @return List<CouponHistoryDTO>
30 */
31 List<CouponHistoryDTO> queryAll(CouponHistoryQueryCriteria criteria);
32
33 /**
34 * 根据ID查询
35 * @param id ID
36 * @return CouponHistoryDTO
37 */
38 CouponHistoryDTO findById(Long id);
39
40 void create(CouponHistory resources);
41
42 void update(CouponHistory resources);
43
44 void delete(Long id);
45
46 Long countByUserId(Long userId);
47
48 Long countByUserIdAndExpireTimeBefore(Long userId, Timestamp now);
49
50 Long countByUserIdAndExpireTimeBetween(Long userId, Timestamp now, Timestamp expireTime);
51 }
1 package com.topdraw.business.basicdata.coupon.history.service.dto;
2
3 import lombok.Data;
4
5 import java.io.Serializable;
6 import java.sql.Timestamp;
7
8
9 /**
10 * @author XiangHan
11 * @date 2021-10-23
12 */
13 @Data
14 public class CouponHistoryDTO implements Serializable {
15
16 // 主键
17 private Long id;
18
19 // 优惠券id
20 private Long couponId;
21
22 // 领券用户id（对应账号）
23 private Long userId;
24
25 // 优惠券code
26 private String couponCode;
27
28 // 领取人昵称
29 private String userNickname;
30
31 // 领取时间
32 private Timestamp receiveTime;
33
34 // 失效时间
35 private Timestamp expireTime;
36
37 // 使用状态 0：未使用；1：已使用；-1：已过期
38 private Integer useStatus;
39
40 // 使用时间
41 private Timestamp useTime;
42
43 // 订单详情id
44 private Long orderDetailId;
45
46 // 创建时间
47 private Timestamp createTime;
48
49 // 更新时间
50 private Timestamp updateTime;
51 }
1 package com.topdraw.business.basicdata.coupon.history.service.dto;
2
3 import lombok.Data;
4
5 /**
6 * @author XiangHan
7 * @date 2021-10-23
8 */
9 @Data
10 public class CouponHistoryQueryCriteria{
11 }
1 package com.topdraw.business.basicdata.coupon.history.service.impl;
2
3 import com.topdraw.business.basicdata.coupon.history.domain.CouponHistory;
4 import com.topdraw.business.basicdata.coupon.history.repository.CouponHistoryRepository;
5 import com.topdraw.business.basicdata.coupon.history.service.CouponHistoryService;
6 import com.topdraw.business.basicdata.coupon.history.service.dto.CouponHistoryDTO;
7 import com.topdraw.business.basicdata.coupon.history.service.dto.CouponHistoryQueryCriteria;
8 import com.topdraw.business.basicdata.coupon.history.service.mapper.CouponHistoryMapper;
9 import com.topdraw.utils.PageUtil;
10 import com.topdraw.utils.QueryHelp;
11 import com.topdraw.utils.ValidationUtil;
12 import org.springframework.beans.factory.annotation.Autowired;
13 import org.springframework.dao.EmptyResultDataAccessException;
14 import org.springframework.data.domain.Page;
15 import org.springframework.data.domain.Pageable;
16 import org.springframework.stereotype.Service;
17 import org.springframework.transaction.annotation.Propagation;
18 import org.springframework.transaction.annotation.Transactional;
19 import org.springframework.util.Assert;
20
21 import java.sql.Timestamp;
22 import java.util.List;
23 import java.util.Map;
24
25 /**
26 * @author XiangHan
27 * @date 2021-10-23
28 */
29 @Service
30 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
31 public class CouponHistoryServiceImpl implements CouponHistoryService {
32
33 @Autowired
34 private CouponHistoryRepository CouponHistoryRepository;
35
36 @Autowired
37 private CouponHistoryMapper CouponHistoryMapper;
38
39 @Override
40 public Map<String, Object> queryAll(CouponHistoryQueryCriteria criteria, Pageable pageable) {
41 Page<CouponHistory> page = CouponHistoryRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
42 return PageUtil.toPage(page.map(CouponHistoryMapper::toDto));
43 }
44
45 @Override
46 public List<CouponHistoryDTO> queryAll(CouponHistoryQueryCriteria criteria) {
47 return CouponHistoryMapper.toDto(CouponHistoryRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
48 }
49
50 @Override
51 public CouponHistoryDTO findById(Long id) {
52 CouponHistory CouponHistory = CouponHistoryRepository.findById(id).orElseGet(CouponHistory::new);
53 ValidationUtil.isNull(CouponHistory.getId(),"CouponHistory","id",id);
54 return CouponHistoryMapper.toDto(CouponHistory);
55 }
56
57 @Override
58 @Transactional(rollbackFor = Exception.class)
59 public void create(CouponHistory resources) {
60 CouponHistoryRepository.save(resources);
61 }
62
63 @Override
64 @Transactional(rollbackFor = Exception.class)
65 public void update(CouponHistory resources) {
66 CouponHistory CouponHistory = CouponHistoryRepository.findById(resources.getId()).orElseGet(CouponHistory::new);
67 ValidationUtil.isNull( CouponHistory.getId(),"CouponHistory","id",resources.getId());
68 CouponHistory.copy(resources);
69 CouponHistoryRepository.save(CouponHistory);
70 }
71
72 @Override
73 @Transactional(rollbackFor = Exception.class)
74 public void delete(Long id) {
75 Assert.notNull(id, "The given id must not be null!");
76 CouponHistory CouponHistory = CouponHistoryRepository.findById(id).orElseThrow(
77 () -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", CouponHistory.class, id), 1));
78 CouponHistoryRepository.delete(CouponHistory);
79 }
80
81 @Override
82 public Long countByUserId(Long userId) {
83 return this.CouponHistoryRepository.countByUserId(userId);
84 }
85
86 @Override
87 public Long countByUserIdAndExpireTimeBefore(Long userId, Timestamp now) {
88 return this.CouponHistoryRepository.countByUserIdAndExpireTimeBefore(userId,now);
89 }
90
91 @Override
92 public Long countByUserIdAndExpireTimeBetween(Long userId, Timestamp now, Timestamp expireTime) {
93 return this.CouponHistoryRepository.countByUserIdAndExpireTimeBetween(userId,now,expireTime);
94 }
95
96
97 }
1 package com.topdraw.business.basicdata.coupon.history.service.mapper;
2
3 import com.topdraw.base.BaseMapper;
4 import com.topdraw.business.basicdata.coupon.history.domain.CouponHistory;
5 import com.topdraw.business.basicdata.coupon.history.service.dto.CouponHistoryDTO;
6 import org.mapstruct.Mapper;
7 import org.mapstruct.ReportingPolicy;
8
9 /**
10 * @author XiangHan
11 * @date 2021-10-23
12 */
13 @Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
14 public interface CouponHistoryMapper extends BaseMapper<CouponHistoryDTO, CouponHistory> {
15
16 }
1 package com.topdraw.business.basicdata.coupon.repository;
2
3 import com.topdraw.business.basicdata.coupon.domain.Coupon;
4 import org.springframework.data.jpa.repository.JpaRepository;
5 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
6
7 import java.util.Optional;
8
9 /**
10 * @author XiangHan
11 * @date 2021-10-22
12 */
13 public interface CouponRepository extends JpaRepository<Coupon, Long>, JpaSpecificationExecutor<Coupon> {
14
15 Optional<Coupon> findFirstByCode(String code);
16 }
1 package com.topdraw.business.basicdata.coupon.rest;
2
3 import com.topdraw.annotation.Log;
4 import com.topdraw.business.basicdata.coupon.domain.Coupon;
5 import com.topdraw.business.basicdata.coupon.service.CouponService;
6 import com.topdraw.business.basicdata.coupon.service.dto.CouponQueryCriteria;
7 import com.topdraw.common.ResultInfo;
8 import io.swagger.annotations.Api;
9 import io.swagger.annotations.ApiOperation;
10 import org.springframework.beans.factory.annotation.Autowired;
11 import org.springframework.data.domain.Pageable;
12 import org.springframework.validation.annotation.Validated;
13 import org.springframework.web.bind.annotation.*;
14
15 /**
16 * @author XiangHan
17 * @date 2021-10-22
18 */
19 @Api(tags = "Coupon管理")
20 @RestController
21 @RequestMapping("/api/Coupon")
22 public class CouponController {
23
24 @Autowired
25 private CouponService CouponService;
26
27 @GetMapping
28 @ApiOperation("查询Coupon")
29 public ResultInfo getCoupons(CouponQueryCriteria criteria, Pageable pageable) {
30 return ResultInfo.successPage(CouponService.queryAll(criteria,pageable));
31 }
32
33 @GetMapping(value = "/all")
34 @ApiOperation("查询所有Coupon")
35 public ResultInfo getCoupons(CouponQueryCriteria criteria) {
36 return ResultInfo.success(CouponService.queryAll(criteria));
37 }
38
39 @Log
40 @PostMapping
41 @ApiOperation("新增Coupon")
42 public ResultInfo create(@Validated @RequestBody Coupon resources) {
43 CouponService.create(resources);
44 return ResultInfo.success();
45 }
46
47 @Log
48 @PutMapping
49 @ApiOperation("修改Coupon")
50 public ResultInfo update(@Validated @RequestBody Coupon resources) {
51 CouponService.update(resources);
52 return ResultInfo.success();
53 }
54
55
56 @Log
57 @DeleteMapping(value = "/{id}")
58 @ApiOperation("删除Coupon")
59 public ResultInfo delete(@PathVariable Long id) {
60 CouponService.delete(id);
61 return ResultInfo.success();
62 }
63
64 @GetMapping(value = "/getByCode/{code}")
65 @ApiOperation(value = "根据标识查询")
66 public ResultInfo getByCode(@PathVariable String code) {
67 return ResultInfo.success(CouponService.getByCode(code));
68 }
69 }
1 package com.topdraw.business.basicdata.coupon.service;
2
3 import com.topdraw.business.basicdata.coupon.domain.Coupon;
4 import com.topdraw.business.basicdata.coupon.service.dto.CouponDTO;
5 import com.topdraw.business.basicdata.coupon.service.dto.CouponQueryCriteria;
6 import org.springframework.data.domain.Pageable;
7
8 import java.util.List;
9 import java.util.Map;
10
11 /**
12 * @author XiangHan
13 * @date 2021-10-22
14 */
15 public interface CouponService {
16
17 /**
18 * 查询数据分页
19 * @param criteria 条件参数
20 * @param pageable 分页参数
21 * @return Map<String,Object>
22 */
23 Map<String,Object> queryAll(CouponQueryCriteria criteria, Pageable pageable);
24
25 /**
26 * 查询所有数据不分页
27 * @param criteria 条件参数
28 * @return List<CouponDTO>
29 */
30 List<CouponDTO> queryAll(CouponQueryCriteria criteria);
31
32 /**
33 * 根据ID查询
34 * @param id ID
35 * @return CouponDTO
36 */
37 CouponDTO findById(Long id);
38
39 void create(Coupon resources);
40
41 void update(Coupon resources);
42
43 void delete(Long id);
44
45 /**
46 * Code校验
47 * @param code
48 * @return CouponDTO
49 */
50 CouponDTO getByCode(String code);
51 }
1 package com.topdraw.business.basicdata.coupon.service.dto;
2
3 import lombok.Data;
4
5 import java.io.Serializable;
6 import java.math.BigDecimal;
7 import java.sql.Timestamp;
8
9
10 /**
11 * @author XiangHan
12 * @date 2021-10-22
13 */
14 @Data
15 public class CouponDTO implements Serializable {
16
17 // id
18 private Long id;
19
20 // 标识
21 private String code;
22
23 // 名称
24 private String title;
25
26 // 图片
27 private String images;
28
29 // 发行量，-1代表不限量
30 private Integer stock;
31
32 // 剩余量，-1代表不限量
33 private Integer remainStock;
34
35 // 优惠形式：1：现金；2：折扣
36 private Integer useType;
37
38 // 面额
39 private BigDecimal denomination;
40
41 // 折扣
42 private BigDecimal discount;
43
44 // 适用用户范围：1：新用户；2：全体用户
45 private Integer userRange;
46
47 // 限领次数 -1：无限次； >0：具体次数
48 private Integer collectLimit;
49
50 // 适用门槛：1：无门槛；2：满减形式
51 private Integer thresholdType;
52
53 // 满减门槛
54 private BigDecimal amountThreshold;
55
56 // 产品范围：1：全部商品；2：指定商品
57 private Integer itemRange;
58
59 // 生效形式：1：固定日期；2：相对日期
60 private Integer effectType;
61
62 // 生效时间
63 private Timestamp startTime;
64
65 // 过期时间
66 private Timestamp expireTime;
67
68 // 自领取当日，几天内有效
69 private Integer validDays;
70
71 // 使用说明
72 private String description;
73
74 // 状态0：未开始，1:启用；2：停用
75 private Integer status;
76
77 // 创建时间
78 private Timestamp createTime;
79
80 // 更新时间
81 private Timestamp updateTime;
82 }
1 package com.topdraw.business.basicdata.coupon.service.dto;
2
3 import lombok.Data;
4
5 /**
6 * @author XiangHan
7 * @date 2021-10-22
8 */
9 @Data
10 public class CouponQueryCriteria{
11 }
1 package com.topdraw.business.basicdata.coupon.service.impl;
2
3 import com.topdraw.business.basicdata.coupon.domain.Coupon;
4 import com.topdraw.business.basicdata.coupon.repository.CouponRepository;
5 import com.topdraw.business.basicdata.coupon.service.CouponService;
6 import com.topdraw.business.basicdata.coupon.service.dto.CouponDTO;
7 import com.topdraw.business.basicdata.coupon.service.dto.CouponQueryCriteria;
8 import com.topdraw.business.basicdata.coupon.service.mapper.CouponMapper;
9 import com.topdraw.utils.PageUtil;
10 import com.topdraw.utils.QueryHelp;
11 import com.topdraw.utils.StringUtils;
12 import com.topdraw.utils.ValidationUtil;
13 import org.springframework.beans.factory.annotation.Autowired;
14 import org.springframework.dao.EmptyResultDataAccessException;
15 import org.springframework.data.domain.Page;
16 import org.springframework.data.domain.Pageable;
17 import org.springframework.stereotype.Service;
18 import org.springframework.transaction.annotation.Propagation;
19 import org.springframework.transaction.annotation.Transactional;
20 import org.springframework.util.Assert;
21
22 import java.util.List;
23 import java.util.Map;
24
25 /**
26 * @author XiangHan
27 * @date 2021-10-22
28 */
29 @Service
30 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
31 public class CouponServiceImpl implements CouponService {
32
33 @Autowired
34 private CouponRepository CouponRepository;
35
36 @Autowired
37 private CouponMapper CouponMapper;
38
39 @Override
40 public Map<String, Object> queryAll(CouponQueryCriteria criteria, Pageable pageable) {
41 Page<Coupon> page = CouponRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
42 return PageUtil.toPage(page.map(CouponMapper::toDto));
43 }
44
45 @Override
46 public List<CouponDTO> queryAll(CouponQueryCriteria criteria) {
47 return CouponMapper.toDto(CouponRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
48 }
49
50 @Override
51 public CouponDTO findById(Long id) {
52 Coupon Coupon = CouponRepository.findById(id).orElseGet(Coupon::new);
53 ValidationUtil.isNull(Coupon.getId(),"Coupon","id",id);
54 return CouponMapper.toDto(Coupon);
55 }
56
57 @Override
58 @Transactional(rollbackFor = Exception.class)
59 public void create(Coupon resources) {
60 CouponRepository.save(resources);
61 }
62
63 @Override
64 @Transactional(rollbackFor = Exception.class)
65 public void update(Coupon resources) {
66 Coupon Coupon = CouponRepository.findById(resources.getId()).orElseGet(Coupon::new);
67 ValidationUtil.isNull( Coupon.getId(),"Coupon","id",resources.getId());
68 Coupon.copy(resources);
69 CouponRepository.save(Coupon);
70 }
71
72 @Override
73 @Transactional(rollbackFor = Exception.class)
74 public void delete(Long id) {
75 Assert.notNull(id, "The given id must not be null!");
76 Coupon Coupon = CouponRepository.findById(id).orElseThrow(
77 () -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", Coupon.class, id), 1));
78 CouponRepository.delete(Coupon);
79 }
80
81
82 @Override
83 public CouponDTO getByCode(String code) {
84 return StringUtils.isNotEmpty(code) ? CouponMapper.toDto(CouponRepository.findFirstByCode(code).orElseGet(Coupon::new))
85 : new CouponDTO();
86 }
87 }
1 package com.topdraw.business.basicdata.coupon.service.mapper;
2
3 import com.topdraw.base.BaseMapper;
4 import com.topdraw.business.basicdata.coupon.domain.Coupon;
5 import com.topdraw.business.basicdata.coupon.service.dto.CouponDTO;
6 import org.mapstruct.Mapper;
7 import org.mapstruct.ReportingPolicy;
8
9 /**
10 * @author XiangHan
11 * @date 2021-10-22
12 */
13 @Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
14 public interface CouponMapper extends BaseMapper<CouponDTO, Coupon> {
15
16 }
1 package com.topdraw.business.basicdata.exp.detail.domain;
2
3 import cn.hutool.core.bean.BeanUtil;
4 import cn.hutool.core.bean.copier.CopyOptions;
5 import lombok.Data;
6 import lombok.experimental.Accessors;
7 import org.springframework.data.annotation.CreatedDate;
8 import org.springframework.data.annotation.LastModifiedDate;
9 import org.springframework.data.jpa.domain.support.AuditingEntityListener;
10
11 import javax.persistence.*;
12 import java.io.Serializable;
13 import java.sql.Timestamp;
14
15 /**
16 * @author XiangHan
17 * @date 2021-10-22
18 */
19 @Entity
20 @Data
21 @EntityListeners(AuditingEntityListener.class)
22 @Accessors(chain = true)
23 @Table(name="uc_exp_detail")
24 public class ExpDetail implements Serializable {
25
26 // 主键
27 @Id
28 @GeneratedValue(strategy = GenerationType.IDENTITY)
29 @Column(name = "id")
30 private Long id;
31
32 // 标识
33 @Column(name = "code", nullable = false)
34 private String code;
35
36 // 应用code
37 @Column(name = "app_code")
38 private String appCode;
39
40 // 会员id
41 @Column(name = "member_id", nullable = false)
42 private Long memberId;
43
44 // 账号id
45 @Column(name = "account_id")
46 private Long accountId;
47
48 // 原始成长值
49 @Column(name = "original_exp", nullable = false)
50 private Long originalExp;
51
52 // 结果成长值
53 @Column(name = "result_exp", nullable = false)
54 private Long resultExp;
55
56 // 成长值变化，一般为正数
57 @Column(name = "exp", nullable = false)
58 private Long exp;
59
60 // 设备类型 1：大屏；2：小屏（微信）3.小屏（xx）
61 @Column(name = "device_type", nullable = false)
62 private Integer deviceType;
63
64 // 行为事件类型 1：登录；2：观影；3：参与活动；4：订购；10：跨屏绑定；98：系统操作；99：其他
65 @Column(name = "evt_type", nullable = false)
66 private Integer evtType;
67
68 // 订单id（针对订购操作）
69 @Column(name = "order_id")
70 private Long orderId;
71
72 // 节目id（针对观影操作）
73 @Column(name = "media_id")
74 private Long mediaId;
75
76 // 活动id（针对参与活动）
77 @Column(name = "activity_id")
78 private Long activityId;
79
80 // 成长值变化描述，用于管理侧显示
81 @Column(name = "description", nullable = false)
82 private String description;
83
84 // 创建时间
85 @CreatedDate
86 @Column(name = "create_time")
87 private Timestamp createTime;
88
89 // 更新时间
90 @LastModifiedDate
91 @Column(name = "update_time")
92 private Timestamp updateTime;
93
94 public void copy(ExpDetail source){
95 BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
96 }
97 }
1 package com.topdraw.business.basicdata.exp.detail.repository;
2
3 import com.topdraw.business.basicdata.exp.detail.domain.ExpDetail;
4 import org.springframework.data.jpa.repository.JpaRepository;
5 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
6
7 import java.util.Optional;
8
9 /**
10 * @author XiangHan
11 * @date 2021-10-22
12 */
13 public interface ExpDetailRepository extends JpaRepository<ExpDetail, Long>, JpaSpecificationExecutor<ExpDetail> {
14
15 Optional<ExpDetail> findFirstByCode(String code);
16 }
1 package com.topdraw.business.basicdata.exp.detail.rest;
2
3 import com.topdraw.annotation.Log;
4 import com.topdraw.business.basicdata.exp.detail.domain.ExpDetail;
5 import com.topdraw.business.basicdata.exp.detail.service.ExpDetailService;
6 import com.topdraw.business.basicdata.exp.detail.service.dto.ExpDetailQueryCriteria;
7 import com.topdraw.common.ResultInfo;
8 import io.swagger.annotations.Api;
9 import io.swagger.annotations.ApiOperation;
10 import org.springframework.beans.factory.annotation.Autowired;
11 import org.springframework.data.domain.Pageable;
12 import org.springframework.validation.annotation.Validated;
13 import org.springframework.web.bind.annotation.*;
14
15 /**
16 * @author XiangHan
17 * @date 2021-10-22
18 */
19 @Api(tags = "ExpDetail管理")
20 @RestController
21 @RequestMapping("/api/ExpDetail")
22 public class ExpDetailController {
23
24 @Autowired
25 private ExpDetailService ExpDetailService;
26
27 @GetMapping
28 @ApiOperation("查询ExpDetail")
29 public ResultInfo getExpDetails(ExpDetailQueryCriteria criteria, Pageable pageable) {
30 return ResultInfo.successPage(ExpDetailService.queryAll(criteria,pageable));
31 }
32
33 @GetMapping(value = "/all")
34 @ApiOperation("查询所有ExpDetail")
35 public ResultInfo getExpDetails(ExpDetailQueryCriteria criteria) {
36 return ResultInfo.success(ExpDetailService.queryAll(criteria));
37 }
38
39 @Log
40 @PostMapping
41 @ApiOperation("新增ExpDetail")
42 public ResultInfo create(@Validated @RequestBody ExpDetail resources) {
43 ExpDetailService.create(resources);
44 return ResultInfo.success();
45 }
46
47 @Log
48 @PutMapping
49 @ApiOperation("修改ExpDetail")
50 public ResultInfo update(@Validated @RequestBody ExpDetail resources) {
51 ExpDetailService.update(resources);
52 return ResultInfo.success();
53 }
54
55
56 @Log
57 @DeleteMapping(value = "/{id}")
58 @ApiOperation("删除ExpDetail")
59 public ResultInfo delete(@PathVariable Long id) {
60 ExpDetailService.delete(id);
61 return ResultInfo.success();
62 }
63
64 @GetMapping(value = "/getByCode/{code}")
65 @ApiOperation(value = "根据标识查询")
66 public ResultInfo getByCode(@PathVariable String code) {
67 return ResultInfo.success(ExpDetailService.getByCode(code));
68 }
69 }
1 package com.topdraw.business.basicdata.exp.detail.service;
2
3 import com.topdraw.business.basicdata.exp.detail.domain.ExpDetail;
4 import com.topdraw.business.basicdata.exp.detail.service.dto.ExpDetailDTO;
5 import com.topdraw.business.basicdata.exp.detail.service.dto.ExpDetailQueryCriteria;
6 import org.springframework.data.domain.Pageable;
7
8 import java.util.List;
9 import java.util.Map;
10
11 /**
12 * @author XiangHan
13 * @date 2021-10-22
14 */
15 public interface ExpDetailService {
16
17 /**
18 * 查询数据分页
19 * @param criteria 条件参数
20 * @param pageable 分页参数
21 * @return Map<String,Object>
22 */
23 Map<String,Object> queryAll(ExpDetailQueryCriteria criteria, Pageable pageable);
24
25 /**
26 * 查询所有数据不分页
27 * @param criteria 条件参数
28 * @return List<ExpDetailDTO>
29 */
30 List<ExpDetailDTO> queryAll(ExpDetailQueryCriteria criteria);
31
32 /**
33 * 根据ID查询
34 * @param id ID
35 * @return ExpDetailDTO
36 */
37 ExpDetailDTO findById(Long id);
38
39 void create(ExpDetail resources);
40
41 void update(ExpDetail resources);
42
43 void delete(Long id);
44
45 /**
46 * Code校验
47 * @param code
48 * @return ExpDetailDTO
49 */
50 ExpDetailDTO getByCode(String code);
51 }
1 package com.topdraw.business.basicdata.exp.detail.service.dto;
2
3 import lombok.Data;
4
5 import java.io.Serializable;
6 import java.sql.Timestamp;
7
8
9 /**
10 * @author XiangHan
11 * @date 2021-10-22
12 */
13 @Data
14 public class ExpDetailDTO implements Serializable {
15
16 // 主键
17 private Long id;
18
19 // 标识
20 private String code;
21
22 // 应用code
23 private String appCode;
24
25 // 会员id
26 private Long memberId;
27
28 // 账号id
29 private Long accountId;
30
31 // 原始成长值
32 private Long originalExp;
33
34 // 结果成长值
35 private Long resultExp;
36
37 // 成长值变化，一般为正数
38 private Long exp;
39
40 // 设备类型 1：大屏；2：小屏（微信）3.小屏（xx）
41 private Integer deviceType;
42
43 // 行为事件类型 1：登录；2：观影；3：参与活动；4：订购；10：跨屏绑定；98：系统操作；99：其他
44 private Integer evtType;
45
46 // 订单id（针对订购操作）
47 private Long orderId;
48
49 // 节目id（针对观影操作）
50 private Long mediaId;
51
52 // 活动id（针对参与活动）
53 private Long activityId;
54
55 // 成长值变化描述，用于管理侧显示
56 private String description;
57
58 // 创建时间
59 private Timestamp createTime;
60
61 // 更新时间
62 private Timestamp updateTime;
63 }
1 package com.topdraw.business.basicdata.exp.detail.service.dto;
2
3 import lombok.Data;
4
5 /**
6 * @author XiangHan
7 * @date 2021-10-22
8 */
9 @Data
10 public class ExpDetailQueryCriteria{
11 }
1 package com.topdraw.business.basicdata.exp.detail.service.impl;
2
3 import com.topdraw.business.basicdata.exp.detail.domain.ExpDetail;
4 import com.topdraw.business.basicdata.exp.detail.repository.ExpDetailRepository;
5 import com.topdraw.business.basicdata.exp.detail.service.ExpDetailService;
6 import com.topdraw.business.basicdata.exp.detail.service.dto.ExpDetailDTO;
7 import com.topdraw.business.basicdata.exp.detail.service.dto.ExpDetailQueryCriteria;
8 import com.topdraw.business.basicdata.exp.detail.service.mapper.ExpDetailMapper;
9 import com.topdraw.utils.PageUtil;
10 import com.topdraw.utils.QueryHelp;
11 import com.topdraw.utils.StringUtils;
12 import com.topdraw.utils.ValidationUtil;
13 import org.springframework.beans.factory.annotation.Autowired;
14 import org.springframework.dao.EmptyResultDataAccessException;
15 import org.springframework.data.domain.Page;
16 import org.springframework.data.domain.Pageable;
17 import org.springframework.stereotype.Service;
18 import org.springframework.transaction.annotation.Propagation;
19 import org.springframework.transaction.annotation.Transactional;
20 import org.springframework.util.Assert;
21
22 import java.util.List;
23 import java.util.Map;
24
25 /**
26 * @author XiangHan
27 * @date 2021-10-22
28 */
29 @Service
30 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
31 public class ExpDetailServiceImpl implements ExpDetailService {
32
33 @Autowired
34 private ExpDetailRepository ExpDetailRepository;
35
36 @Autowired
37 private ExpDetailMapper ExpDetailMapper;
38
39 @Override
40 public Map<String, Object> queryAll(ExpDetailQueryCriteria criteria, Pageable pageable) {
41 Page<ExpDetail> page = ExpDetailRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
42 return PageUtil.toPage(page.map(ExpDetailMapper::toDto));
43 }
44
45 @Override
46 public List<ExpDetailDTO> queryAll(ExpDetailQueryCriteria criteria) {
47 return ExpDetailMapper.toDto(ExpDetailRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
48 }
49
50 @Override
51 public ExpDetailDTO findById(Long id) {
52 ExpDetail ExpDetail = ExpDetailRepository.findById(id).orElseGet(ExpDetail::new);
53 ValidationUtil.isNull(ExpDetail.getId(),"ExpDetail","id",id);
54 return ExpDetailMapper.toDto(ExpDetail);
55 }
56
57 @Override
58 @Transactional(rollbackFor = Exception.class)
59 public void create(ExpDetail resources) {
60 ExpDetailRepository.save(resources);
61 }
62
63 @Override
64 @Transactional(rollbackFor = Exception.class)
65 public void update(ExpDetail resources) {
66 ExpDetail ExpDetail = ExpDetailRepository.findById(resources.getId()).orElseGet(ExpDetail::new);
67 ValidationUtil.isNull( ExpDetail.getId(),"ExpDetail","id",resources.getId());
68 ExpDetail.copy(resources);
69 ExpDetailRepository.save(ExpDetail);
70 }
71
72 @Override
73 @Transactional(rollbackFor = Exception.class)
74 public void delete(Long id) {
75 Assert.notNull(id, "The given id must not be null!");
76 ExpDetail ExpDetail = ExpDetailRepository.findById(id).orElseThrow(
77 () -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", ExpDetail.class, id), 1));
78 ExpDetailRepository.delete(ExpDetail);
79 }
80
81
82 @Override
83 public ExpDetailDTO getByCode(String code) {
84 return StringUtils.isNotEmpty(code) ? ExpDetailMapper.toDto(ExpDetailRepository.findFirstByCode(code).orElseGet(ExpDetail::new))
85 : new ExpDetailDTO();
86 }
87 }
1 package com.topdraw.business.basicdata.exp.detail.service.mapper;
2
3 import com.topdraw.base.BaseMapper;
4 import com.topdraw.business.basicdata.exp.detail.domain.ExpDetail;
5 import com.topdraw.business.basicdata.exp.detail.service.dto.ExpDetailDTO;
6 import org.mapstruct.Mapper;
7 import org.mapstruct.ReportingPolicy;
8
9 /**
10 * @author XiangHan
11 * @date 2021-10-22
12 */
13 @Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
14 public interface ExpDetailMapper extends BaseMapper<ExpDetailDTO, ExpDetail> {
15
16 }
1 package com.topdraw.business.basicdata.exp.history.domain;
2
3 import cn.hutool.core.bean.BeanUtil;
4 import cn.hutool.core.bean.copier.CopyOptions;
5 import lombok.Data;
6 import lombok.experimental.Accessors;
7 import org.springframework.data.annotation.CreatedDate;
8 import org.springframework.data.annotation.LastModifiedDate;
9 import org.springframework.data.jpa.domain.support.AuditingEntityListener;
10
11 import javax.persistence.*;
12 import java.io.Serializable;
13 import java.sql.Timestamp;
14
15 /**
16 * @author XiangHan
17 * @date 2021-10-22
18 */
19 @Entity
20 @Data
21 @EntityListeners(AuditingEntityListener.class)
22 @Accessors(chain = true)
23 @Table(name="uc_exp_history")
24 public class ExpHistory implements Serializable {
25
26 // 主键
27 @Id
28 @GeneratedValue(strategy = GenerationType.IDENTITY)
29 @Column(name = "id")
30 private Long id;
31
32 // 标识
33 @Column(name = "code", nullable = false)
34 private String code;
35
36 // 会员id
37 @Column(name = "member_id", nullable = false)
38 private Long memberId;
39
40 // 账号id
41 @Column(name = "account_id")
42 private Long accountId;
43
44 // 原始成长值
45 @Column(name = "original_exp", nullable = false)
46 private Long originalExp;
47
48 // 结果成长值
49 @Column(name = "result_exp", nullable = false)
50 private Long resultExp;
51
52 // 成长值变化，一般为正数
53 @Column(name = "exp", nullable = false)
54 private Long exp;
55
56 // 设备类型 1：大屏；2：小屏（微信）3.小屏（xx）4.系统赠送
57 @Column(name = "device_type", nullable = false)
58 private Integer deviceType;
59
60 // 行为事件类型 1：登录；2：观影；3：参与活动；4：订购；10：跨屏绑定；98：系统操作；99：其他
61 @Column(name = "evt_type", nullable = false)
62 private Integer evtType;
63
64 // 订单id（针对订购操作）
65 @Column(name = "order_id")
66 private Long orderId;
67
68 // 节目id（针对观影操作）
69 @Column(name = "media_id")
70 private Long mediaId;
71
72 // 活动id（针对参与活动）
73 @Column(name = "activity_id")
74 private Long activityId;
75
76 // 成长值变化描述，用于管理侧显示
77 @Column(name = "description", nullable = false)
78 private String description;
79
80 // 创建时间
81 @CreatedDate
82 @Column(name = "create_time")
83 private Timestamp createTime;
84
85 // 更新时间
86 @LastModifiedDate
87 @Column(name = "update_time")
88 private Timestamp updateTime;
89
90 public void copy(ExpHistory source){
91 BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
92 }
93 }
1 package com.topdraw.business.basicdata.exp.history.repository;
2
3 import com.topdraw.business.basicdata.exp.history.domain.ExpHistory;
4 import org.springframework.data.jpa.repository.JpaRepository;
5 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
6
7 import java.util.Optional;
8
9 /**
10 * @author XiangHan
11 * @date 2021-10-22
12 */
13 public interface ExpHistoryRepository extends JpaRepository<ExpHistory, Long>, JpaSpecificationExecutor<ExpHistory> {
14
15 Optional<ExpHistory> findFirstByCode(String code);
16 }
1 package com.topdraw.business.basicdata.exp.history.rest;
2
3 import com.topdraw.annotation.Log;
4 import com.topdraw.business.basicdata.exp.history.domain.ExpHistory;
5 import com.topdraw.business.basicdata.exp.history.service.ExpHistoryService;
6 import com.topdraw.business.basicdata.exp.history.service.dto.ExpHistoryQueryCriteria;
7 import com.topdraw.common.ResultInfo;
8 import io.swagger.annotations.Api;
9 import io.swagger.annotations.ApiOperation;
10 import org.springframework.beans.factory.annotation.Autowired;
11 import org.springframework.data.domain.Pageable;
12 import org.springframework.validation.annotation.Validated;
13 import org.springframework.web.bind.annotation.*;
14
15 /**
16 * @author XiangHan
17 * @date 2021-10-22
18 */
19 @Api(tags = "ExpHistory管理")
20 @RestController
21 @RequestMapping("/api/ExpHistory")
22 public class ExpHistoryController {
23
24 @Autowired
25 private ExpHistoryService ExpHistoryService;
26
27 @GetMapping
28 @ApiOperation("查询ExpHistory")
29 public ResultInfo getExpHistorys(ExpHistoryQueryCriteria criteria, Pageable pageable) {
30 return ResultInfo.successPage(ExpHistoryService.queryAll(criteria,pageable));
31 }
32
33 @GetMapping(value = "/all")
34 @ApiOperation("查询所有ExpHistory")
35 public ResultInfo getExpHistorys(ExpHistoryQueryCriteria criteria) {
36 return ResultInfo.success(ExpHistoryService.queryAll(criteria));
37 }
38
39 @Log
40 @PostMapping
41 @ApiOperation("新增ExpHistory")
42 public ResultInfo create(@Validated @RequestBody ExpHistory resources) {
43 ExpHistoryService.create(resources);
44 return ResultInfo.success();
45 }
46
47 @Log
48 @PutMapping
49 @ApiOperation("修改ExpHistory")
50 public ResultInfo update(@Validated @RequestBody ExpHistory resources) {
51 ExpHistoryService.update(resources);
52 return ResultInfo.success();
53 }
54
55
56 @Log
57 @DeleteMapping(value = "/{id}")
58 @ApiOperation("删除ExpHistory")
59 public ResultInfo delete(@PathVariable Long id) {
60 ExpHistoryService.delete(id);
61 return ResultInfo.success();
62 }
63
64 @GetMapping(value = "/getByCode/{code}")
65 @ApiOperation(value = "根据标识查询")
66 public ResultInfo getByCode(@PathVariable String code) {
67 return ResultInfo.success(ExpHistoryService.getByCode(code));
68 }
69 }
1 package com.topdraw.business.basicdata.exp.history.service;
2
3 import com.topdraw.business.basicdata.exp.history.domain.ExpHistory;
4 import com.topdraw.business.basicdata.exp.history.service.dto.ExpHistoryDTO;
5 import com.topdraw.business.basicdata.exp.history.service.dto.ExpHistoryQueryCriteria;
6 import org.springframework.data.domain.Pageable;
7
8 import java.util.List;
9 import java.util.Map;
10
11 /**
12 * @author XiangHan
13 * @date 2021-10-22
14 */
15 public interface ExpHistoryService {
16
17 /**
18 * 查询数据分页
19 * @param criteria 条件参数
20 * @param pageable 分页参数
21 * @return Map<String,Object>
22 */
23 Map<String,Object> queryAll(ExpHistoryQueryCriteria criteria, Pageable pageable);
24
25 /**
26 * 查询所有数据不分页
27 * @param criteria 条件参数
28 * @return List<ExpHistoryDTO>
29 */
30 List<ExpHistoryDTO> queryAll(ExpHistoryQueryCriteria criteria);
31
32 /**
33 * 根据ID查询
34 * @param id ID
35 * @return ExpHistoryDTO
36 */
37 ExpHistoryDTO findById(Long id);
38
39 void create(ExpHistory resources);
40
41 void update(ExpHistory resources);
42
43 void delete(Long id);
44
45 /**
46 * Code校验
47 * @param code
48 * @return ExpHistoryDTO
49 */
50 ExpHistoryDTO getByCode(String code);
51 }
1 package com.topdraw.business.basicdata.exp.history.service.dto;
2
3 import lombok.Data;
4
5 import java.io.Serializable;
6 import java.sql.Timestamp;
7
8
9 /**
10 * @author XiangHan
11 * @date 2021-10-22
12 */
13 @Data
14 public class ExpHistoryDTO implements Serializable {
15
16 // 主键
17 private Long id;
18
19 // 标识
20 private String code;
21
22 // 会员id
23 private Long memberId;
24
25 // 账号id
26 private Long accountId;
27
28 // 原始成长值
29 private Long originalExp;
30
31 // 结果成长值
32 private Long resultExp;
33
34 // 成长值变化，一般为正数
35 private Long exp;
36
37 // 设备类型 1：大屏；2：小屏（微信）3.小屏（xx）4.系统赠送
38 private Integer deviceType;
39
40 // 行为事件类型 1：登录；2：观影；3：参与活动；4：订购；10：跨屏绑定；98：系统操作；99：其他
41 private Integer evtType;
42
43 // 订单id（针对订购操作）
44 private Long orderId;
45
46 // 节目id（针对观影操作）
47 private Long mediaId;
48
49 // 活动id（针对参与活动）
50 private Long activityId;
51
52 // 成长值变化描述，用于管理侧显示
53 private String description;
54
55 // 创建时间
56 private Timestamp createTime;
57
58 // 更新时间
59 private Timestamp updateTime;
60 }
1 package com.topdraw.business.basicdata.exp.history.service.dto;
2
3 import lombok.Data;
4
5 /**
6 * @author XiangHan
7 * @date 2021-10-22
8 */
9 @Data
10 public class ExpHistoryQueryCriteria{
11 }
1 package com.topdraw.business.basicdata.exp.history.service.impl;
2
3 import com.topdraw.business.basicdata.exp.history.domain.ExpHistory;
4 import com.topdraw.business.basicdata.exp.history.repository.ExpHistoryRepository;
5 import com.topdraw.business.basicdata.exp.history.service.ExpHistoryService;
6 import com.topdraw.business.basicdata.exp.history.service.dto.ExpHistoryDTO;
7 import com.topdraw.business.basicdata.exp.history.service.dto.ExpHistoryQueryCriteria;
8 import com.topdraw.business.basicdata.exp.history.service.mapper.ExpHistoryMapper;
9 import com.topdraw.utils.PageUtil;
10 import com.topdraw.utils.QueryHelp;
11 import com.topdraw.utils.StringUtils;
12 import com.topdraw.utils.ValidationUtil;
13 import org.springframework.beans.factory.annotation.Autowired;
14 import org.springframework.dao.EmptyResultDataAccessException;
15 import org.springframework.data.domain.Page;
16 import org.springframework.data.domain.Pageable;
17 import org.springframework.stereotype.Service;
18 import org.springframework.transaction.annotation.Propagation;
19 import org.springframework.transaction.annotation.Transactional;
20 import org.springframework.util.Assert;
21
22 import java.util.List;
23 import java.util.Map;
24
25 /**
26 * @author XiangHan
27 * @date 2021-10-22
28 */
29 @Service
30 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
31 public class ExpHistoryServiceImpl implements ExpHistoryService {
32
33 @Autowired
34 private ExpHistoryRepository ExpHistoryRepository;
35
36 @Autowired
37 private ExpHistoryMapper ExpHistoryMapper;
38
39 @Override
40 public Map<String, Object> queryAll(ExpHistoryQueryCriteria criteria, Pageable pageable) {
41 Page<ExpHistory> page = ExpHistoryRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
42 return PageUtil.toPage(page.map(ExpHistoryMapper::toDto));
43 }
44
45 @Override
46 public List<ExpHistoryDTO> queryAll(ExpHistoryQueryCriteria criteria) {
47 return ExpHistoryMapper.toDto(ExpHistoryRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
48 }
49
50 @Override
51 public ExpHistoryDTO findById(Long id) {
52 ExpHistory ExpHistory = ExpHistoryRepository.findById(id).orElseGet(ExpHistory::new);
53 ValidationUtil.isNull(ExpHistory.getId(),"ExpHistory","id",id);
54 return ExpHistoryMapper.toDto(ExpHistory);
55 }
56
57 @Override
58 @Transactional(rollbackFor = Exception.class)
59 public void create(ExpHistory resources) {
60 ExpHistoryRepository.save(resources);
61 }
62
63 @Override
64 @Transactional(rollbackFor = Exception.class)
65 public void update(ExpHistory resources) {
66 ExpHistory ExpHistory = ExpHistoryRepository.findById(resources.getId()).orElseGet(ExpHistory::new);
67 ValidationUtil.isNull( ExpHistory.getId(),"ExpHistory","id",resources.getId());
68 ExpHistory.copy(resources);
69 ExpHistoryRepository.save(ExpHistory);
70 }
71
72 @Override
73 @Transactional(rollbackFor = Exception.class)
74 public void delete(Long id) {
75 Assert.notNull(id, "The given id must not be null!");
76 ExpHistory ExpHistory = ExpHistoryRepository.findById(id).orElseThrow(
77 () -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", ExpHistory.class, id), 1));
78 ExpHistoryRepository.delete(ExpHistory);
79 }
80
81
82 @Override
83 public ExpHistoryDTO getByCode(String code) {
84 return StringUtils.isNotEmpty(code) ? ExpHistoryMapper.toDto(ExpHistoryRepository.findFirstByCode(code).orElseGet(ExpHistory::new))
85 : new ExpHistoryDTO();
86 }
87 }
1 package com.topdraw.business.basicdata.exp.history.service.mapper;
2
3 import com.topdraw.base.BaseMapper;
4 import com.topdraw.business.basicdata.exp.history.domain.ExpHistory;
5 import com.topdraw.business.basicdata.exp.history.service.dto.ExpHistoryDTO;
6 import org.mapstruct.Mapper;
7 import org.mapstruct.ReportingPolicy;
8
9 /**
10 * @author XiangHan
11 * @date 2021-10-22
12 */
13 @Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
14 public interface ExpHistoryMapper extends BaseMapper<ExpHistoryDTO, ExpHistory> {
15
16 }
1 package com.topdraw.business.basicdata.member.address.domain;
2
3 import cn.hutool.core.bean.BeanUtil;
4 import cn.hutool.core.bean.copier.CopyOptions;
5 import lombok.Data;
6 import lombok.experimental.Accessors;
7 import org.springframework.data.annotation.CreatedDate;
8 import org.springframework.data.annotation.LastModifiedDate;
9 import org.springframework.data.jpa.domain.support.AuditingEntityListener;
10
11 import javax.persistence.*;
12 import java.io.Serializable;
13 import java.sql.Timestamp;
14
15 /**
16 * @author XiangHan
17 * @date 2021-10-22
18 */
19 @Entity
20 @Data
21 @EntityListeners(AuditingEntityListener.class)
22 @Accessors(chain = true)
23 @Table(name="uc_member_address")
24 public class MemberAddress implements Serializable {
25
26 // 主键
27 @Id
28 @GeneratedValue(strategy = GenerationType.IDENTITY)
29 @Column(name = "id")
30 private Long id;
31
32 // 会员id
33 @Column(name = "member_id", nullable = false)
34 private Long memberId;
35
36 // 类型 1：家；2：公司；3：学校
37 @Column(name = "type", nullable = false)
38 private Integer type;
39
40 // 是否默认地址
41 @Column(name = "is_default", nullable = false)
42 private Integer isDefault;
43
44 // 显示顺序
45 @Column(name = "sequence")
46 private Integer sequence;
47
48 // 状态 0：不可用；1-可用
49 @Column(name = "status", nullable = false)
50 private Integer status;
51
52 // 联系人姓名
53 @Column(name = "contactor", nullable = false)
54 private String contactor;
55
56 // 联系人电话
57 @Column(name = "cellphone", nullable = false)
58 private String cellphone;
59
60 // 国家
61 @Column(name = "country", nullable = false)
62 private String country;
63
64 // 省份
65 @Column(name = "province", nullable = false)
66 private String province;
67
68 // 城市
69 @Column(name = "city", nullable = false)
70 private String city;
71
72 // 区县
73 @Column(name = "district", nullable = false)
74 private String district;
75
76 // 地址
77 @Column(name = "address", nullable = false)
78 private String address;
79
80 // 邮编
81 @Column(name = "zip_code")
82 private String zipCode;
83
84 // 创建时间
85 @CreatedDate
86 @Column(name = "create_time")
87 private Timestamp createTime;
88
89 // 更新时间
90 @LastModifiedDate
91 @Column(name = "update_time")
92 private Timestamp updateTime;
93
94 public void copy(MemberAddress source){
95 BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
96 }
97 }
1 package com.topdraw.business.basicdata.member.address.repository;
2
3 import com.topdraw.business.basicdata.member.address.domain.MemberAddress;
4 import org.springframework.data.jpa.repository.JpaRepository;
5 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
6
7 /**
8 * @author XiangHan
9 * @date 2021-10-22
10 */
11 public interface MemberAddressRepository extends JpaRepository<MemberAddress, Long>, JpaSpecificationExecutor<MemberAddress> {
12
13 }
1 package com.topdraw.business.basicdata.member.address.rest;
2
3 import com.topdraw.annotation.Log;
4 import com.topdraw.business.basicdata.member.address.domain.MemberAddress;
5 import com.topdraw.business.basicdata.member.address.service.MemberAddressService;
6 import com.topdraw.business.basicdata.member.address.service.dto.MemberAddressQueryCriteria;
7 import com.topdraw.common.ResultInfo;
8 import io.swagger.annotations.Api;
9 import io.swagger.annotations.ApiOperation;
10 import org.springframework.beans.factory.annotation.Autowired;
11 import org.springframework.data.domain.Pageable;
12 import org.springframework.validation.annotation.Validated;
13 import org.springframework.web.bind.annotation.*;
14
15 /**
16 * @author XiangHan
17 * @date 2021-10-22
18 */
19 @Api(tags = "MemberAddress管理")
20 @RestController
21 @RequestMapping("/api/MemberAddress")
22 public class MemberAddressController {
23
24 @Autowired
25 private MemberAddressService MemberAddressService;
26
27 @GetMapping(value = "/pageMemberAddress")
28 @ApiOperation("查询MemberAddress")
29 public ResultInfo pageMemberAddress(MemberAddressQueryCriteria criteria, Pageable pageable) {
30 return ResultInfo.successPage(MemberAddressService.queryAll(criteria,pageable));
31 }
32
33 @GetMapping(value = "/findById/{id}")
34 @ApiOperation("查询指定MemberAddress")
35 public ResultInfo findById(@PathVariable(value = "id") Long id) {
36 return ResultInfo.success(MemberAddressService.findById(id));
37 }
38
39 @Log
40 @PostMapping(value = "/create")
41 @ApiOperation("新增MemberAddress")
42 public ResultInfo create(@Validated @RequestBody MemberAddress resources) {
43 MemberAddressService.create(resources);
44 return ResultInfo.success();
45 }
46
47 @Log
48 @PutMapping(value = "/update")
49 @ApiOperation("修改MemberAddress")
50 public ResultInfo update(@Validated @RequestBody MemberAddress resources) {
51 MemberAddressService.update(resources);
52 return ResultInfo.success();
53 }
54
55 @Log
56 @DeleteMapping(value = "/delete/{id}")
57 @ApiOperation("删除MemberAddress")
58 public ResultInfo delete(@PathVariable Long id) {
59 MemberAddressService.delete(id);
60 return ResultInfo.success();
61 }
62
63 }
1 package com.topdraw.business.basicdata.member.address.service;
2
3 import com.topdraw.business.basicdata.member.address.domain.MemberAddress;
4 import com.topdraw.business.basicdata.member.address.service.dto.MemberAddressDTO;
5 import com.topdraw.business.basicdata.member.address.service.dto.MemberAddressQueryCriteria;
6 import org.springframework.data.domain.Pageable;
7
8 import java.util.List;
9 import java.util.Map;
10
11 /**
12 * @author XiangHan
13 * @date 2021-10-22
14 */
15 public interface MemberAddressService {
16
17 /**
18 * 查询数据分页
19 * @param criteria 条件参数
20 * @param pageable 分页参数
21 * @return Map<String,Object>
22 */
23 Map<String,Object> queryAll(MemberAddressQueryCriteria criteria, Pageable pageable);
24
25 /**
26 * 查询所有数据不分页
27 * @param criteria 条件参数
28 * @return List<MemberAddressDTO>
29 */
30 List<MemberAddressDTO> queryAll(MemberAddressQueryCriteria criteria);
31
32 /**
33 * 根据ID查询
34 * @param id ID
35 * @return MemberAddressDTO
36 */
37 MemberAddressDTO findById(Long id);
38
39 void create(MemberAddress resources);
40
41 void update(MemberAddress resources);
42
43 void delete(Long id);
44
45 }
1 package com.topdraw.business.basicdata.member.address.service.dto;
2
3 import lombok.Data;
4
5 import java.io.Serializable;
6 import java.sql.Timestamp;
7
8
9 /**
10 * @author XiangHan
11 * @date 2021-10-22
12 */
13 @Data
14 public class MemberAddressDTO implements Serializable {
15
16 // 主键
17 private Long id;
18
19 // 会员id
20 private Long memberId;
21
22 // 类型 1：家；2：公司；3：学校
23 private Integer type;
24
25 // 是否默认地址
26 private Integer isDefault;
27
28 // 显示顺序
29 private Integer sequence;
30
31 // 状态 0：不可用；1-可用
32 private Integer status;
33
34 // 联系人姓名
35 private String contactor;
36
37 // 联系人电话
38 private String cellphone;
39
40 // 国家
41 private String country;
42
43 // 省份
44 private String province;
45
46 // 城市
47 private String city;
48
49 // 区县
50 private String district;
51
52 // 地址
53 private String address;
54
55 // 邮编
56 private String zipCode;
57
58 // 创建时间
59 private Timestamp createTime;
60
61 // 更新时间
62 private Timestamp updateTime;
63 }
1 package com.topdraw.business.basicdata.member.address.service.dto;
2
3 import com.topdraw.annotation.Query;
4 import lombok.Data;
5
6 /**
7 * @author XiangHan
8 * @date 2021-10-22
9 */
10 @Data
11 public class MemberAddressQueryCriteria{
12
13 @Query
14 private Long memberId;
15
16 }
1 package com.topdraw.business.basicdata.member.address.service.impl;
2
3 import com.topdraw.business.basicdata.member.address.domain.MemberAddress;
4 import com.topdraw.business.basicdata.member.address.repository.MemberAddressRepository;
5 import com.topdraw.business.basicdata.member.address.service.MemberAddressService;
6 import com.topdraw.business.basicdata.member.address.service.dto.MemberAddressDTO;
7 import com.topdraw.business.basicdata.member.address.service.dto.MemberAddressQueryCriteria;
8 import com.topdraw.business.basicdata.member.address.service.mapper.MemberAddressMapper;
9 import com.topdraw.utils.PageUtil;
10 import com.topdraw.utils.QueryHelp;
11 import com.topdraw.utils.ValidationUtil;
12 import org.springframework.beans.factory.annotation.Autowired;
13 import org.springframework.dao.EmptyResultDataAccessException;
14 import org.springframework.data.domain.Page;
15 import org.springframework.data.domain.Pageable;
16 import org.springframework.stereotype.Service;
17 import org.springframework.transaction.annotation.Propagation;
18 import org.springframework.transaction.annotation.Transactional;
19 import org.springframework.util.Assert;
20
21 import java.util.List;
22 import java.util.Map;
23
24 /**
25 * @author XiangHan
26 * @date 2021-10-22
27 */
28 @Service
29 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
30 public class MemberAddressServiceImpl implements MemberAddressService {
31
32 @Autowired
33 private MemberAddressRepository MemberAddressRepository;
34
35 @Autowired
36 private MemberAddressMapper MemberAddressMapper;
37
38 @Override
39 public Map<String, Object> queryAll(MemberAddressQueryCriteria criteria, Pageable pageable) {
40 Page<MemberAddress> page = MemberAddressRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
41 return PageUtil.toPage(page.map(MemberAddressMapper::toDto));
42 }
43
44 @Override
45 public List<MemberAddressDTO> queryAll(MemberAddressQueryCriteria criteria) {
46 return MemberAddressMapper.toDto(MemberAddressRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
47 }
48
49 @Override
50 public MemberAddressDTO findById(Long id) {
51 MemberAddress MemberAddress = MemberAddressRepository.findById(id).orElseGet(MemberAddress::new);
52 ValidationUtil.isNull(MemberAddress.getId(),"MemberAddress","id",id);
53 return MemberAddressMapper.toDto(MemberAddress);
54 }
55
56 @Override
57 @Transactional(rollbackFor = Exception.class)
58 public void create(MemberAddress resources) {
59 MemberAddressRepository.save(resources);
60 }
61
62 @Override
63 @Transactional(rollbackFor = Exception.class)
64 public void update(MemberAddress resources) {
65 MemberAddress MemberAddress = MemberAddressRepository.findById(resources.getId()).orElseGet(MemberAddress::new);
66 ValidationUtil.isNull( MemberAddress.getId(),"MemberAddress","id",resources.getId());
67 MemberAddress.copy(resources);
68 MemberAddressRepository.save(MemberAddress);
69 }
70
71 @Override
72 @Transactional(rollbackFor = Exception.class)
73 public void delete(Long id) {
74 Assert.notNull(id, "The given id must not be null!");
75 MemberAddress MemberAddress = MemberAddressRepository.findById(id).orElseThrow(
76 () -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", MemberAddress.class, id), 1));
77 MemberAddressRepository.delete(MemberAddress);
78 }
79
80
81 }
1 package com.topdraw.business.basicdata.member.address.service.mapper;
2
3 import com.topdraw.base.BaseMapper;
4 import com.topdraw.business.basicdata.member.address.domain.MemberAddress;
5 import com.topdraw.business.basicdata.member.address.service.dto.MemberAddressDTO;
6 import org.mapstruct.Mapper;
7 import org.mapstruct.ReportingPolicy;
8
9 /**
10 * @author XiangHan
11 * @date 2021-10-22
12 */
13 @Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
14 public interface MemberAddressMapper extends BaseMapper<MemberAddressDTO, MemberAddress> {
15
16 }
1 package com.topdraw.business.basicdata.member.domain;
2
3 import cn.hutool.core.bean.BeanUtil;
4 import cn.hutool.core.bean.copier.CopyOptions;
5 import lombok.Data;
6 import lombok.experimental.Accessors;
7 import org.springframework.data.annotation.CreatedDate;
8 import org.springframework.data.annotation.LastModifiedDate;
9 import org.springframework.data.jpa.domain.support.AuditingEntityListener;
10
11 import javax.persistence.*;
12 import java.io.Serializable;
13 import java.sql.Timestamp;
14
15 /**
16 * @author XiangHan
17 * @date 2021-10-22
18 */
19 @Entity
20 @Data
21 @EntityListeners(AuditingEntityListener.class)
22 @Accessors(chain = true)
23 @Table(name="uc_member")
24 public class Member implements Serializable {
25
26 // 主键
27 @Id
28 @GeneratedValue(strategy = GenerationType.IDENTITY)
29 @Column(name = "id")
30 private Long id;
31
32 // 标识
33 @Column(name = "code", nullable = false)
34 private String code;
35
36 // 类型 1：大屏；2：小屏
37 @Column(name = "`type`", nullable = false)
38 private Integer type;
39
40 // 状态 0：不可用；1：可用
41 @Column(name = "`status`", nullable = false)
42 private Integer status;
43
44 // 昵称 base64
45 @Column(name = "nickname")
46 private String nickname;
47
48 // 描述
49 @Column(name = "description")
50 private String description;
51
52 // 性别 0：女；1：男；-1：未知
53 @Column(name = "gender", nullable = false)
54 private Integer gender;
55
56 // 生日
57 @Column(name = "birthday")
58 private String birthday;
59
60 // 头像
61 @Column(name = "avatar_url")
62 private String avatarUrl;
63
64 // 分组信息
65 @Column(name = "`groups`")
66 private String groups;
67
68 // 标签
69 @Column(name = "tags")
70 private String tags;
71
72 // 是否会员 0：非会员；1：会员
73 @Column(name = "vip", nullable = false)
74 private Integer vip;
75
76 // 会员等级（对应level表的level字段，非id）
77 @Column(name = "`level`", nullable = false)
78 private Integer level;
79
80 // 成长值
81 @Column(name = "`exp`")
82 private Long exp;
83
84 // 当前积分
85 @Column(name = "`points`")
86 private Integer points;
87
88 // 即将到期积分（一个月内）
89 @Column(name = "due_points")
90 private Long duePoints;
91
92 // 优惠券数量
93 @Column(name = "coupon_amount")
94 private Integer couponAmount;
95
96 // 即将过期优惠券数量
97 @Column(name = "due_coupon_amount")
98 private Integer dueCouponAmount;
99
100 // iptv账号id
101 @Column(name = "user_iptv_id")
102 private Long userIptvId;
103
104 // 绑定IPTV平台 0：未知；1：电信；2：移动；3：联通
105 @Column(name = "bind_iptv_platform_type")
106 private Integer bindIptvPlatformType;
107
108 // iptv账号绑定时间
109 @Column(name = "bind_iptv_time")
110 private Timestamp bindIptvTime;
111
112 // 创建时间
113 @CreatedDate
114 @Column(name = "create_time")
115 private Timestamp createTime;
116
117 // 更新时间
118 @LastModifiedDate
119 @Column(name = "update_time")
120 private Timestamp updateTime;
121
122 // 是否在黑名单 1：是；0否
123 // @Column(name = "black_status")
124 // private Integer blackStatus;
125
126 public void copy(Member source){
127 BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
128 }
129 }
1 package com.topdraw.business.basicdata.member.level.domain;
2
3 import cn.hutool.core.bean.BeanUtil;
4 import cn.hutool.core.bean.copier.CopyOptions;
5 import lombok.Data;
6 import lombok.experimental.Accessors;
7 import org.springframework.data.annotation.CreatedDate;
8 import org.springframework.data.annotation.LastModifiedDate;
9 import org.springframework.data.jpa.domain.support.AuditingEntityListener;
10
11 import javax.persistence.*;
12 import java.io.Serializable;
13 import java.sql.Timestamp;
14
15 /**
16 * @author XiangHan
17 * @date 2021-10-22
18 */
19 @Entity
20 @Data
21 @EntityListeners(AuditingEntityListener.class)
22 @Accessors(chain = true)
23 @Table(name="uc_member_level")
24 public class MemberLevel implements Serializable {
25
26 // 主键
27 @Id
28 @GeneratedValue(strategy = GenerationType.IDENTITY)
29 @Column(name = "id")
30 private Long id;
31
32 // 标识
33 @Column(name = "code", nullable = false)
34 private String code;
35
36 // 名称
37 @Column(name = "name", nullable = false)
38 private String name;
39
40 // 状态 0：未启用；1：启用
41 @Column(name = "status", nullable = false)
42 private Integer status;
43
44 // 对应成长值
45 @Column(name = "exp_value", nullable = false)
46 private Long expValue;
47
48 // 等级（不可重复，数字越大等级越高）
49 @Column(name = "level", nullable = false)
50 private Integer level;
51
52 // 会员徽标
53 @Column(name = "icon_url")
54 private String iconUrl;
55
56 // 描述
57 @Column(name = "description")
58 private String description;
59
60 // 对应任务id，通过此字段可获得该等级所对应的权益
61 @Column(name = "task_id")
62 private Long taskId;
63
64 // 创建时间
65 @CreatedDate
66 @Column(name = "create_time")
67 private Timestamp createTime;
68
69 // 更新时间
70 @LastModifiedDate
71 @Column(name = "update_time")
72 private Timestamp updateTime;
73
74 public void copy(MemberLevel source){
75 BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
76 }
77 }
1 package com.topdraw.business.basicdata.member.level.repository;
2
3 import com.topdraw.business.basicdata.member.level.domain.MemberLevel;
4 import org.springframework.data.jpa.repository.JpaRepository;
5 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
6
7 import java.util.List;
8 import java.util.Optional;
9
10 /**
11 * @author XiangHan
12 * @date 2021-10-22
13 */
14 public interface MemberLevelRepository extends JpaRepository<MemberLevel, Long>, JpaSpecificationExecutor<MemberLevel> {
15
16 Optional<MemberLevel> findFirstByCode(String code);
17
18 List<MemberLevel> findByLevelAndStatus(Integer level, Integer status);
19 }
1 package com.topdraw.business.basicdata.member.level.rest;
2
3 import com.topdraw.annotation.Log;
4 import com.topdraw.business.basicdata.member.level.domain.MemberLevel;
5 import com.topdraw.business.basicdata.member.level.service.MemberLevelService;
6 import com.topdraw.business.basicdata.member.level.service.dto.MemberLevelQueryCriteria;
7 import com.topdraw.common.ResultInfo;
8 import io.swagger.annotations.Api;
9 import io.swagger.annotations.ApiOperation;
10 import org.springframework.beans.factory.annotation.Autowired;
11 import org.springframework.data.domain.Pageable;
12 import org.springframework.validation.annotation.Validated;
13 import org.springframework.web.bind.annotation.*;
14
15 /**
16 * @author XiangHan
17 * @date 2021-10-22
18 */
19 @Api(tags = "MemberLevel管理")
20 @RestController
21 @RequestMapping("/api/MemberLevel")
22 public class MemberLevelController {
23
24 @Autowired
25 private MemberLevelService MemberLevelService;
26
27 @GetMapping
28 @ApiOperation("查询MemberLevel")
29 public ResultInfo getMemberLevels(MemberLevelQueryCriteria criteria, Pageable pageable) {
30 return ResultInfo.successPage(MemberLevelService.queryAll(criteria,pageable));
31 }
32
33 @GetMapping(value = "/all")
34 @ApiOperation("查询所有MemberLevel")
35 public ResultInfo getMemberLevels(MemberLevelQueryCriteria criteria) {
36 return ResultInfo.success(MemberLevelService.queryAll(criteria));
37 }
38
39 @Log
40 @PostMapping
41 @ApiOperation("新增MemberLevel")
42 public ResultInfo create(@Validated @RequestBody MemberLevel resources) {
43 MemberLevelService.create(resources);
44 return ResultInfo.success();
45 }
46
47 @Log
48 @PutMapping
49 @ApiOperation("修改MemberLevel")
50 public ResultInfo update(@Validated @RequestBody MemberLevel resources) {
51 MemberLevelService.update(resources);
52 return ResultInfo.success();
53 }
54
55
56 @Log
57 @DeleteMapping(value = "/{id}")
58 @ApiOperation("删除MemberLevel")
59 public ResultInfo delete(@PathVariable Long id) {
60 MemberLevelService.delete(id);
61 return ResultInfo.success();
62 }
63
64 @GetMapping(value = "/getByCode/{code}")
65 @ApiOperation(value = "根据标识查询")
66 public ResultInfo getByCode(@PathVariable String code) {
67 return ResultInfo.success(MemberLevelService.getByCode(code));
68 }
69 }
1 package com.topdraw.business.basicdata.member.level.service;
2
3 import com.topdraw.business.basicdata.member.level.domain.MemberLevel;
4 import com.topdraw.business.basicdata.member.level.service.dto.MemberLevelDTO;
5 import com.topdraw.business.basicdata.member.level.service.dto.MemberLevelQueryCriteria;
6 import org.springframework.data.domain.Pageable;
7
8 import java.util.List;
9 import java.util.Map;
10
11 /**
12 * @author XiangHan
13 * @date 2021-10-22
14 */
15 public interface MemberLevelService {
16
17 /**
18 * 查询数据分页
19 * @param criteria 条件参数
20 * @param pageable 分页参数
21 * @return Map<String,Object>
22 */
23 Map<String,Object> queryAll(MemberLevelQueryCriteria criteria, Pageable pageable);
24
25 /**
26 * 查询所有数据不分页
27 * @param criteria 条件参数
28 * @return List<MemberLevelDTO>
29 */
30 List<MemberLevelDTO> queryAll(MemberLevelQueryCriteria criteria);
31
32 /**
33 * 根据ID查询
34 * @param id ID
35 * @return MemberLevelDTO
36 */
37 MemberLevelDTO findById(Long id);
38
39 void create(MemberLevel resources);
40
41 void update(MemberLevel resources);
42
43 void delete(Long id);
44
45 /**
46 * Code校验
47 * @param code
48 * @return MemberLevelDTO
49 */
50 MemberLevelDTO getByCode(String code);
51
52 List<MemberLevelDTO> findLevelAndStatus(Integer i, Integer status);
53 }
1 package com.topdraw.business.basicdata.member.level.service.dto;
2
3 import lombok.Data;
4
5 import java.io.Serializable;
6 import java.sql.Timestamp;
7
8
9 /**
10 * @author XiangHan
11 * @date 2021-10-22
12 */
13 @Data
14 public class MemberLevelDTO implements Serializable {
15
16 // 主键
17 private Long id;
18
19 // 标识
20 private String code;
21
22 // 名称
23 private String name;
24
25 // 状态 0：未启用；1：启用
26 private Integer status;
27
28 // 对应成长值
29 private Long expValue;
30
31 // 等级（不可重复，数字越大等级越高）
32 private Integer level;
33
34 // 会员徽标
35 private String iconUrl;
36
37 // 描述
38 private String description;
39
40 // 对应任务id，通过此字段可获得该等级所对应的权益
41 private Long taskId;
42
43 // 创建时间
44 private Timestamp createTime;
45
46 // 更新时间
47 private Timestamp updateTime;
48 }
1 package com.topdraw.business.basicdata.member.level.service.dto;
2
3 import lombok.Data;
4
5 /**
6 * @author XiangHan
7 * @date 2021-10-22
8 */
9 @Data
10 public class MemberLevelQueryCriteria{
11 }
1 package com.topdraw.business.basicdata.member.level.service.impl;
2
3 import com.topdraw.business.basicdata.member.level.domain.MemberLevel;
4 import com.topdraw.business.basicdata.member.level.repository.MemberLevelRepository;
5 import com.topdraw.business.basicdata.member.level.service.MemberLevelService;
6 import com.topdraw.business.basicdata.member.level.service.dto.MemberLevelDTO;
7 import com.topdraw.business.basicdata.member.level.service.dto.MemberLevelQueryCriteria;
8 import com.topdraw.business.basicdata.member.level.service.mapper.MemberLevelMapper;
9 import com.topdraw.utils.PageUtil;
10 import com.topdraw.utils.QueryHelp;
11 import com.topdraw.utils.StringUtils;
12 import com.topdraw.utils.ValidationUtil;
13 import org.springframework.beans.factory.annotation.Autowired;
14 import org.springframework.dao.EmptyResultDataAccessException;
15 import org.springframework.data.domain.Page;
16 import org.springframework.data.domain.Pageable;
17 import org.springframework.stereotype.Service;
18 import org.springframework.transaction.annotation.Propagation;
19 import org.springframework.transaction.annotation.Transactional;
20 import org.springframework.util.Assert;
21
22 import java.util.List;
23 import java.util.Map;
24
25 /**
26 * @author XiangHan
27 * @date 2021-10-22
28 */
29 @Service
30 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
31 public class MemberLevelServiceImpl implements MemberLevelService {
32
33 @Autowired
34 private MemberLevelRepository MemberLevelRepository;
35
36 @Autowired
37 private MemberLevelMapper MemberLevelMapper;
38
39 @Override
40 public Map<String, Object> queryAll(MemberLevelQueryCriteria criteria, Pageable pageable) {
41 Page<MemberLevel> page = MemberLevelRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
42 return PageUtil.toPage(page.map(MemberLevelMapper::toDto));
43 }
44
45 @Override
46 public List<MemberLevelDTO> queryAll(MemberLevelQueryCriteria criteria) {
47 return MemberLevelMapper.toDto(MemberLevelRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
48 }
49
50 @Override
51 public MemberLevelDTO findById(Long id) {
52 MemberLevel MemberLevel = MemberLevelRepository.findById(id).orElseGet(MemberLevel::new);
53 ValidationUtil.isNull(MemberLevel.getId(),"MemberLevel","id",id);
54 return MemberLevelMapper.toDto(MemberLevel);
55 }
56
57 @Override
58 @Transactional(rollbackFor = Exception.class)
59 public void create(MemberLevel resources) {
60 MemberLevelRepository.save(resources);
61 }
62
63 @Override
64 @Transactional(rollbackFor = Exception.class)
65 public void update(MemberLevel resources) {
66 MemberLevel MemberLevel = MemberLevelRepository.findById(resources.getId()).orElseGet(MemberLevel::new);
67 ValidationUtil.isNull( MemberLevel.getId(),"MemberLevel","id",resources.getId());
68 MemberLevel.copy(resources);
69 MemberLevelRepository.save(MemberLevel);
70 }
71
72 @Override
73 @Transactional(rollbackFor = Exception.class)
74 public void delete(Long id) {
75 Assert.notNull(id, "The given id must not be null!");
76 MemberLevel MemberLevel = MemberLevelRepository.findById(id).orElseThrow(
77 () -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", MemberLevel.class, id), 1));
78 MemberLevelRepository.delete(MemberLevel);
79 }
80
81
82 @Override
83 public MemberLevelDTO getByCode(String code) {
84 return StringUtils.isNotEmpty(code) ? MemberLevelMapper.toDto(MemberLevelRepository.findFirstByCode(code).orElseGet(MemberLevel::new))
85 : new MemberLevelDTO();
86 }
87
88 @Override
89 public List<MemberLevelDTO> findLevelAndStatus(Integer level, Integer status) {
90 return MemberLevelMapper.toDto(MemberLevelRepository.findByLevelAndStatus(level,status));
91 }
92 }
1 package com.topdraw.business.basicdata.member.level.service.mapper;
2
3 import com.topdraw.base.BaseMapper;
4 import com.topdraw.business.basicdata.member.level.domain.MemberLevel;
5 import com.topdraw.business.basicdata.member.level.service.dto.MemberLevelDTO;
6 import org.mapstruct.Mapper;
7 import org.mapstruct.ReportingPolicy;
8
9 /**
10 * @author XiangHan
11 * @date 2021-10-22
12 */
13 @Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
14 public interface MemberLevelMapper extends BaseMapper<MemberLevelDTO, MemberLevel> {
15
16 }
1 package com.topdraw.business.basicdata.member.profile.domain;
2
3 import cn.hutool.core.bean.BeanUtil;
4 import cn.hutool.core.bean.copier.CopyOptions;
5 import lombok.Data;
6 import lombok.experimental.Accessors;
7 import org.springframework.data.annotation.CreatedDate;
8 import org.springframework.data.annotation.LastModifiedDate;
9 import org.springframework.data.jpa.domain.support.AuditingEntityListener;
10
11 import javax.persistence.*;
12 import java.io.Serializable;
13 import java.sql.Timestamp;
14
15 /**
16 * @author XiangHan
17 * @date 2021-10-22
18 */
19 @Entity
20 @Data
21 @EntityListeners(AuditingEntityListener.class)
22 @Accessors(chain = true)
23 @Table(name="uc_member_profile")
24 public class MemberProfile implements Serializable {
25
26 // 主键
27 @Id
28 @GeneratedValue(strategy = GenerationType.IDENTITY)
29 @Column(name = "id")
30 private Long id;
31
32 // 会员id
33 @Column(name = "member_id", nullable = false)
34 private Long memberId;
35
36 // 姓名
37 @Column(name = "realname")
38 private String realname;
39
40 // 性别 0：女； 1：男 -1：未知
41 @Column(name = "gender", nullable = false)
42 private Integer gender;
43
44 // 生日
45 @Column(name = "birthday", nullable = false)
46 private Timestamp birthday;
47
48 // 星座
49 @Column(name = "constellation")
50 private String constellation;
51
52 // 身份证
53 @Column(name = "id_card", nullable = false)
54 private String idCard;
55
56 // 电子邮件
57 @Column(name = "email")
58 private String email;
59
60 // 国家
61 @Column(name = "country")
62 private String country;
63
64 // 省份
65 @Column(name = "province")
66 private String province;
67
68 // 城市
69 @Column(name = "city")
70 private String city;
71
72 // 区县
73 @Column(name = "district")
74 private String district;
75
76 // 描述
77 @Column(name = "description")
78 private String description;
79
80 // 创建时间
81 @CreatedDate
82 @Column(name = "create_time")
83 private Timestamp createTime;
84
85 // 更新时间
86 @LastModifiedDate
87 @Column(name = "update_time")
88 private Timestamp updateTime;
89
90 public void copy(MemberProfile source){
91 BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
92 }
93 }
1 package com.topdraw.business.basicdata.member.profile.repository;
2
3 import com.topdraw.business.basicdata.member.profile.domain.MemberProfile;
4 import org.springframework.data.jpa.repository.JpaRepository;
5 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
6
7 /**
8 * @author XiangHan
9 * @date 2021-10-22
10 */
11 public interface MemberProfileRepository extends JpaRepository<MemberProfile, Long>, JpaSpecificationExecutor<MemberProfile> {
12
13 }
1 package com.topdraw.business.basicdata.member.profile.rest;
2
3 import com.topdraw.annotation.Log;
4 import com.topdraw.business.basicdata.member.profile.domain.MemberProfile;
5 import com.topdraw.business.basicdata.member.profile.service.MemberProfileService;
6 import com.topdraw.business.basicdata.member.profile.service.dto.MemberProfileQueryCriteria;
7 import com.topdraw.common.ResultInfo;
8 import io.swagger.annotations.Api;
9 import io.swagger.annotations.ApiOperation;
10 import org.springframework.beans.factory.annotation.Autowired;
11 import org.springframework.data.domain.Pageable;
12 import org.springframework.validation.annotation.Validated;
13 import org.springframework.web.bind.annotation.*;
14
15 /**
16 * @author XiangHan
17 * @date 2021-10-22
18 */
19 @Api(tags = "MemberProfile管理")
20 @RestController
21 @RequestMapping("/api/MemberProfile")
22 public class MemberProfileController {
23
24 @Autowired
25 private MemberProfileService MemberProfileService;
26
27 @GetMapping
28 @ApiOperation("查询MemberProfile")
29 public ResultInfo getMemberProfiles(MemberProfileQueryCriteria criteria, Pageable pageable) {
30 return ResultInfo.successPage(MemberProfileService.queryAll(criteria,pageable));
31 }
32
33 @GetMapping(value = "/all")
34 @ApiOperation("查询所有MemberProfile")
35 public ResultInfo getMemberProfiles(MemberProfileQueryCriteria criteria) {
36 return ResultInfo.success(MemberProfileService.queryAll(criteria));
37 }
38
39 @Log
40 @PostMapping
41 @ApiOperation("新增MemberProfile")
42 public ResultInfo create(@Validated @RequestBody MemberProfile resources) {
43 MemberProfileService.create(resources);
44 return ResultInfo.success();
45 }
46
47 @Log
48 @PutMapping
49 @ApiOperation("修改MemberProfile")
50 public ResultInfo update(@Validated @RequestBody MemberProfile resources) {
51 MemberProfileService.update(resources);
52 return ResultInfo.success();
53 }
54
55
56 @Log
57 @DeleteMapping(value = "/{id}")
58 @ApiOperation("删除MemberProfile")
59 public ResultInfo delete(@PathVariable Long id) {
60 MemberProfileService.delete(id);
61 return ResultInfo.success();
62 }
63
64 }
1 package com.topdraw.business.basicdata.member.profile.service;
2
3 import com.topdraw.business.basicdata.member.profile.domain.MemberProfile;
4 import com.topdraw.business.basicdata.member.profile.service.dto.MemberProfileDTO;
5 import com.topdraw.business.basicdata.member.profile.service.dto.MemberProfileQueryCriteria;
6 import org.springframework.data.domain.Pageable;
7
8 import java.util.List;
9 import java.util.Map;
10
11 /**
12 * @author XiangHan
13 * @date 2021-10-22
14 */
15 public interface MemberProfileService {
16
17 /**
18 * 查询数据分页
19 * @param criteria 条件参数
20 * @param pageable 分页参数
21 * @return Map<String,Object>
22 */
23 Map<String,Object> queryAll(MemberProfileQueryCriteria criteria, Pageable pageable);
24
25 /**
26 * 查询所有数据不分页
27 * @param criteria 条件参数
28 * @return List<MemberProfileDTO>
29 */
30 List<MemberProfileDTO> queryAll(MemberProfileQueryCriteria criteria);
31
32 /**
33 * 根据ID查询
34 * @param id ID
35 * @return MemberProfileDTO
36 */
37 MemberProfileDTO findById(Long id);
38
39 void create(MemberProfile resources);
40
41 void update(MemberProfile resources);
42
43 void delete(Long id);
44
45 }
1 package com.topdraw.business.basicdata.member.profile.service.dto;
2
3 import lombok.Data;
4
5 import java.io.Serializable;
6 import java.sql.Timestamp;
7
8
9 /**
10 * @author XiangHan
11 * @date 2021-10-22
12 */
13 @Data
14 public class MemberProfileDTO implements Serializable {
15
16 // 主键
17 private Long id;
18
19 // 会员id
20 private Long memberId;
21
22 // 姓名
23 private String realname;
24
25 // 性别 0：女； 1：男 -1：未知
26 private Integer gender;
27
28 // 生日
29 private Timestamp birthday;
30
31 // 星座
32 private String constellation;
33
34 // 身份证
35 private String idCard;
36
37 // 电子邮件
38 private String email;
39
40 // 国家
41 private String country;
42
43 // 省份
44 private String province;
45
46 // 城市
47 private String city;
48
49 // 区县
50 private String district;
51
52 // 描述
53 private String description;
54
55 // 创建时间
56 private Timestamp createTime;
57
58 // 更新时间
59 private Timestamp updateTime;
60 }
1 package com.topdraw.business.basicdata.member.profile.service.dto;
2
3 import lombok.Data;
4
5 /**
6 * @author XiangHan
7 * @date 2021-10-22
8 */
9 @Data
10 public class MemberProfileQueryCriteria{
11 }
1 package com.topdraw.business.basicdata.member.profile.service.impl;
2
3 import com.topdraw.business.basicdata.member.profile.domain.MemberProfile;
4 import com.topdraw.business.basicdata.member.profile.repository.MemberProfileRepository;
5 import com.topdraw.business.basicdata.member.profile.service.MemberProfileService;
6 import com.topdraw.business.basicdata.member.profile.service.dto.MemberProfileDTO;
7 import com.topdraw.business.basicdata.member.profile.service.dto.MemberProfileQueryCriteria;
8 import com.topdraw.business.basicdata.member.profile.service.mapper.MemberProfileMapper;
9 import com.topdraw.utils.PageUtil;
10 import com.topdraw.utils.QueryHelp;
11 import com.topdraw.utils.ValidationUtil;
12 import org.springframework.beans.factory.annotation.Autowired;
13 import org.springframework.dao.EmptyResultDataAccessException;
14 import org.springframework.data.domain.Page;
15 import org.springframework.data.domain.Pageable;
16 import org.springframework.stereotype.Service;
17 import org.springframework.transaction.annotation.Propagation;
18 import org.springframework.transaction.annotation.Transactional;
19 import org.springframework.util.Assert;
20
21 import java.util.List;
22 import java.util.Map;
23
24 /**
25 * @author XiangHan
26 * @date 2021-10-22
27 */
28 @Service
29 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
30 public class MemberProfileServiceImpl implements MemberProfileService {
31
32 @Autowired
33 private MemberProfileRepository MemberProfileRepository;
34
35 @Autowired
36 private MemberProfileMapper MemberProfileMapper;
37
38 @Override
39 public Map<String, Object> queryAll(MemberProfileQueryCriteria criteria, Pageable pageable) {
40 Page<MemberProfile> page = MemberProfileRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
41 return PageUtil.toPage(page.map(MemberProfileMapper::toDto));
42 }
43
44 @Override
45 public List<MemberProfileDTO> queryAll(MemberProfileQueryCriteria criteria) {
46 return MemberProfileMapper.toDto(MemberProfileRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
47 }
48
49 @Override
50 public MemberProfileDTO findById(Long id) {
51 MemberProfile MemberProfile = MemberProfileRepository.findById(id).orElseGet(MemberProfile::new);
52 ValidationUtil.isNull(MemberProfile.getId(),"MemberProfile","id",id);
53 return MemberProfileMapper.toDto(MemberProfile);
54 }
55
56 @Override
57 @Transactional(rollbackFor = Exception.class)
58 public void create(MemberProfile resources) {
59 MemberProfileRepository.save(resources);
60 }
61
62 @Override
63 @Transactional(rollbackFor = Exception.class)
64 public void update(MemberProfile resources) {
65 MemberProfile MemberProfile = MemberProfileRepository.findById(resources.getId()).orElseGet(MemberProfile::new);
66 ValidationUtil.isNull( MemberProfile.getId(),"MemberProfile","id",resources.getId());
67 MemberProfile.copy(resources);
68 MemberProfileRepository.save(MemberProfile);
69 }
70
71 @Override
72 @Transactional(rollbackFor = Exception.class)
73 public void delete(Long id) {
74 Assert.notNull(id, "The given id must not be null!");
75 MemberProfile MemberProfile = MemberProfileRepository.findById(id).orElseThrow(
76 () -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", MemberProfile.class, id), 1));
77 MemberProfileRepository.delete(MemberProfile);
78 }
79
80
81 }
1 package com.topdraw.business.basicdata.member.profile.service.mapper;
2
3 import com.topdraw.base.BaseMapper;
4 import com.topdraw.business.basicdata.member.profile.domain.MemberProfile;
5 import com.topdraw.business.basicdata.member.profile.service.dto.MemberProfileDTO;
6 import org.mapstruct.Mapper;
7 import org.mapstruct.ReportingPolicy;
8
9 /**
10 * @author XiangHan
11 * @date 2021-10-22
12 */
13 @Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
14 public interface MemberProfileMapper extends BaseMapper<MemberProfileDTO, MemberProfile> {
15
16 }
1 package com.topdraw.business.basicdata.member.relatedinfo.domain;
2
3 import cn.hutool.core.bean.BeanUtil;
4 import cn.hutool.core.bean.copier.CopyOptions;
5 import lombok.Data;
6 import lombok.experimental.Accessors;
7 import org.springframework.data.annotation.CreatedDate;
8 import org.springframework.data.annotation.LastModifiedDate;
9 import org.springframework.data.jpa.domain.support.AuditingEntityListener;
10
11 import javax.persistence.*;
12 import java.io.Serializable;
13 import java.sql.Timestamp;
14
15 /**
16 * @author XiangHan
17 * @date 2021-10-22
18 */
19 @Entity
20 @Data
21 @EntityListeners(AuditingEntityListener.class)
22 @Accessors(chain = true)
23 @Table(name="uc_member_related_info")
24 public class MemberRelatedInfo implements Serializable {
25
26 // ID
27 @Id
28 @GeneratedValue(strategy = GenerationType.IDENTITY)
29 @Column(name = "id")
30 private Long id;
31
32 // 会员id
33 @Column(name = "member_id", nullable = false)
34 private Long memberId;
35
36 // 人物关系 0：子女；1：父母
37 @Column(name = "type")
38 private Integer type;
39
40 // 手机号
41 @Column(name = "cellphone")
42 private String cellphone;
43
44 // 身份证号
45 @Column(name = "id_card")
46 private String idCard;
47
48 // 姓名
49 @Column(name = "name")
50 private String name;
51
52 // 性别 0：女；1：男；-1：未知
53 @Column(name = "sex")
54 private Integer sex;
55
56 // 创建时间
57 @CreatedDate
58 @Column(name = "create_time")
59 private Timestamp createTime;
60
61 // 更新时间
62 @LastModifiedDate
63 @Column(name = "update_time")
64 private Timestamp updateTime;
65
66 public void copy(MemberRelatedInfo source){
67 BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
68 }
69 }
1 package com.topdraw.business.basicdata.member.relatedinfo.repository;
2
3 import com.topdraw.business.basicdata.member.relatedinfo.domain.MemberRelatedInfo;
4 import org.springframework.data.jpa.repository.JpaRepository;
5 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
6
7 /**
8 * @author XiangHan
9 * @date 2021-10-22
10 */
11 public interface MemberRelatedInfoRepository extends JpaRepository<MemberRelatedInfo, Long>, JpaSpecificationExecutor<MemberRelatedInfo> {
12
13 }
1 package com.topdraw.business.basicdata.member.relatedinfo.rest;
2
3 import com.topdraw.annotation.Log;
4 import com.topdraw.business.basicdata.member.relatedinfo.domain.MemberRelatedInfo;
5 import com.topdraw.business.basicdata.member.relatedinfo.service.MemberRelatedInfoService;
6 import com.topdraw.business.basicdata.member.relatedinfo.service.dto.MemberRelatedInfoQueryCriteria;
7 import com.topdraw.common.ResultInfo;
8 import io.swagger.annotations.Api;
9 import io.swagger.annotations.ApiOperation;
10 import org.springframework.beans.factory.annotation.Autowired;
11 import org.springframework.data.domain.Pageable;
12 import org.springframework.validation.annotation.Validated;
13 import org.springframework.web.bind.annotation.*;
14
15 /**
16 * @author XiangHan /api/MemberRelatedInfo
17 * @date 2021-10-22
18 */
19 @Api(tags = "MemberRelatedInfo管理")
20 @RestController
21 @RequestMapping("/api/MemberRelatedInfo")
22 public class MemberRelatedInfoController {
23
24 @Autowired
25 private MemberRelatedInfoService MemberRelatedInfoService;
26
27 @GetMapping(value = "/pageMemberRelatedInfos")
28 @ApiOperation("查询MemberRelatedInfo")
29 public ResultInfo pageMemberRelatedInfos(@Validated MemberRelatedInfoQueryCriteria criteria, Pageable pageable) {
30 return ResultInfo.successPage(MemberRelatedInfoService.queryAll(criteria,pageable));
31 }
32
33 @Log
34 @PostMapping(value = "/create")
35 @ApiOperation("新增MemberRelatedInfo")
36 public ResultInfo create(@Validated @RequestBody MemberRelatedInfo resources) {
37 MemberRelatedInfoService.create(resources);
38 return ResultInfo.success();
39 }
40
41 @Log
42 @PutMapping(value = "/update")
43 @ApiOperation("修改MemberRelatedInfo")
44 public ResultInfo update(@Validated @RequestBody MemberRelatedInfo resources) {
45 MemberRelatedInfoService.update(resources);
46 return ResultInfo.success();
47 }
48
49 @GetMapping(value = "/findById/{id}")
50 @ApiOperation("查询指定MemberRelatedInfo")
51 public ResultInfo findById(@PathVariable("id") Long id) {
52 return ResultInfo.success(MemberRelatedInfoService.findById(id));
53 }
54
55 @Log
56 @DeleteMapping(value = "/delete//{id}")
57 @ApiOperation("删除MemberRelatedInfo")
58 public ResultInfo delete(@PathVariable Long id) {
59 MemberRelatedInfoService.delete(id);
60 return ResultInfo.success();
61 }
62
63 }
1 package com.topdraw.business.basicdata.member.relatedinfo.service;
2
3 import com.topdraw.business.basicdata.member.relatedinfo.domain.MemberRelatedInfo;
4 import com.topdraw.business.basicdata.member.relatedinfo.service.dto.MemberRelatedInfoDTO;
5 import com.topdraw.business.basicdata.member.relatedinfo.service.dto.MemberRelatedInfoQueryCriteria;
6 import org.springframework.data.domain.Pageable;
7
8 import java.util.List;
9 import java.util.Map;
10
11 /**
12 * @author XiangHan
13 * @date 2021-10-22
14 */
15 public interface MemberRelatedInfoService {
16
17 /**
18 * 查询数据分页
19 * @param criteria 条件参数
20 * @param pageable 分页参数
21 * @return Map<String,Object>
22 */
23 Map<String,Object> queryAll(MemberRelatedInfoQueryCriteria criteria, Pageable pageable);
24
25 /**
26 * 查询所有数据不分页
27 * @param criteria 条件参数
28 * @return List<MemberRelatedInfoDTO>
29 */
30 List<MemberRelatedInfoDTO> queryAll(MemberRelatedInfoQueryCriteria criteria);
31
32 /**
33 * 根据ID查询
34 * @param id ID
35 * @return MemberRelatedInfoDTO
36 */
37 MemberRelatedInfoDTO findById(Long id);
38
39 void create(MemberRelatedInfo resources);
40
41 void update(MemberRelatedInfo resources);
42
43 void delete(Long id);
44
45 }
1 package com.topdraw.business.basicdata.member.relatedinfo.service.dto;
2
3 import lombok.Data;
4
5 import java.io.Serializable;
6 import java.sql.Timestamp;
7
8
9 /**
10 * @author XiangHan
11 * @date 2021-10-22
12 */
13 @Data
14 public class MemberRelatedInfoDTO implements Serializable {
15
16 // ID
17 private Long id;
18
19 // 会员id
20 private Long memberId;
21
22 // 人物关系 0：子女；1：父母
23 private Integer type;
24
25 // 手机号
26 private String cellphone;
27
28 // 身份证号
29 private String idCard;
30
31 // 姓名
32 private String name;
33
34 // 性别 0：女；1：男；-1：未知
35 private Integer sex;
36
37 // 创建时间
38 private Timestamp createTime;
39
40 // 更新时间
41 private Timestamp updateTime;
42 }
1 package com.topdraw.business.basicdata.member.relatedinfo.service.dto;
2
3 import com.topdraw.annotation.Query;
4 import lombok.Data;
5
6 /**
7 * @author XiangHan
8 * @date 2021-10-22
9 */
10 @Data
11 public class MemberRelatedInfoQueryCriteria{
12
13 @Query
14 private Long memberId;
15
16
17
18 }
1 package com.topdraw.business.basicdata.member.relatedinfo.service.impl;
2
3 import com.topdraw.business.basicdata.member.relatedinfo.domain.MemberRelatedInfo;
4 import com.topdraw.business.basicdata.member.relatedinfo.repository.MemberRelatedInfoRepository;
5 import com.topdraw.business.basicdata.member.relatedinfo.service.MemberRelatedInfoService;
6 import com.topdraw.business.basicdata.member.relatedinfo.service.dto.MemberRelatedInfoDTO;
7 import com.topdraw.business.basicdata.member.relatedinfo.service.dto.MemberRelatedInfoQueryCriteria;
8 import com.topdraw.business.basicdata.member.relatedinfo.service.mapper.MemberRelatedInfoMapper;
9 import com.topdraw.utils.PageUtil;
10 import com.topdraw.utils.QueryHelp;
11 import com.topdraw.utils.ValidationUtil;
12 import org.springframework.beans.factory.annotation.Autowired;
13 import org.springframework.dao.EmptyResultDataAccessException;
14 import org.springframework.data.domain.Page;
15 import org.springframework.data.domain.Pageable;
16 import org.springframework.stereotype.Service;
17 import org.springframework.transaction.annotation.Propagation;
18 import org.springframework.transaction.annotation.Transactional;
19 import org.springframework.util.Assert;
20
21 import java.util.List;
22 import java.util.Map;
23
24 /**
25 * @author XiangHan
26 * @date 2021-10-22
27 */
28 @Service
29 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
30 public class MemberRelatedInfoServiceImpl implements MemberRelatedInfoService {
31
32 @Autowired
33 private MemberRelatedInfoRepository MemberRelatedInfoRepository;
34
35 @Autowired
36 private MemberRelatedInfoMapper MemberRelatedInfoMapper;
37
38 @Override
39 public Map<String, Object> queryAll(MemberRelatedInfoQueryCriteria criteria, Pageable pageable) {
40 Page<MemberRelatedInfo> page = MemberRelatedInfoRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
41 return PageUtil.toPage(page.map(MemberRelatedInfoMapper::toDto));
42 }
43
44 @Override
45 public List<MemberRelatedInfoDTO> queryAll(MemberRelatedInfoQueryCriteria criteria) {
46 return MemberRelatedInfoMapper.toDto(MemberRelatedInfoRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
47 }
48
49 @Override
50 public MemberRelatedInfoDTO findById(Long id) {
51 MemberRelatedInfo MemberRelatedInfo = MemberRelatedInfoRepository.findById(id).orElseGet(MemberRelatedInfo::new);
52 ValidationUtil.isNull(MemberRelatedInfo.getId(),"MemberRelatedInfo","id",id);
53 return MemberRelatedInfoMapper.toDto(MemberRelatedInfo);
54 }
55
56 @Override
57 @Transactional(rollbackFor = Exception.class)
58 public void create(MemberRelatedInfo resources) {
59 MemberRelatedInfoRepository.save(resources);
60 }
61
62 @Override
63 @Transactional(rollbackFor = Exception.class)
64 public void update(MemberRelatedInfo resources) {
65 MemberRelatedInfo MemberRelatedInfo = MemberRelatedInfoRepository.findById(resources.getId()).orElseGet(MemberRelatedInfo::new);
66 ValidationUtil.isNull( MemberRelatedInfo.getId(),"MemberRelatedInfo","id",resources.getId());
67 MemberRelatedInfo.copy(resources);
68 MemberRelatedInfoRepository.save(MemberRelatedInfo);
69 }
70
71 @Override
72 @Transactional(rollbackFor = Exception.class)
73 public void delete(Long id) {
74 Assert.notNull(id, "The given id must not be null!");
75 MemberRelatedInfo MemberRelatedInfo = MemberRelatedInfoRepository.findById(id).orElseThrow(
76 () -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", MemberRelatedInfo.class, id), 1));
77 MemberRelatedInfoRepository.delete(MemberRelatedInfo);
78 }
79
80
81 }
1 package com.topdraw.business.basicdata.member.relatedinfo.service.mapper;
2
3 import com.topdraw.base.BaseMapper;
4 import com.topdraw.business.basicdata.member.relatedinfo.domain.MemberRelatedInfo;
5 import com.topdraw.business.basicdata.member.relatedinfo.service.dto.MemberRelatedInfoDTO;
6 import org.mapstruct.Mapper;
7 import org.mapstruct.ReportingPolicy;
8
9 /**
10 * @author XiangHan
11 * @date 2021-10-22
12 */
13 @Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
14 public interface MemberRelatedInfoMapper extends BaseMapper<MemberRelatedInfoDTO, MemberRelatedInfo> {
15
16 }
1 package com.topdraw.business.basicdata.member.repository;
2
3 import com.topdraw.business.basicdata.member.domain.Member;
4 import org.springframework.data.jpa.repository.JpaRepository;
5 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
6
7 import java.util.Optional;
8
9 /**
10 * @author XiangHan
11 * @date 2021-10-22
12 */
13 public interface MemberRepository extends JpaRepository<Member, Long>, JpaSpecificationExecutor<Member> {
14
15 Optional<Member> findFirstByCode(String code);
16 }
1 package com.topdraw.business.basicdata.member.rest;
2
3 import com.topdraw.annotation.Log;
4 import com.topdraw.business.basicdata.member.domain.Member;
5 import com.topdraw.business.basicdata.member.service.MemberService;
6 import com.topdraw.business.basicdata.member.service.dto.MemberQueryCriteria;
7 import com.topdraw.common.ResultInfo;
8 import io.swagger.annotations.Api;
9 import io.swagger.annotations.ApiOperation;
10 import org.springframework.beans.factory.annotation.Autowired;
11 import org.springframework.data.domain.Pageable;
12 import org.springframework.validation.annotation.Validated;
13 import org.springframework.web.bind.annotation.*;
14
15 /**
16 * @author XiangHan
17 * @date 2021-10-22
18 */
19 @Api(tags = "Member管理")
20 @RestController
21 @RequestMapping("/api/member")
22 public class MemberController {
23
24 @Autowired
25 private MemberService memberService;
26
27 @GetMapping(value = "/pageMembers")
28 @ApiOperation("查询Member")
29 public ResultInfo pageMembers(MemberQueryCriteria criteria, Pageable pageable) {
30 return ResultInfo.successPage(memberService.queryAll(criteria,pageable));
31 }
32
33 @GetMapping(value = "/findById/{id}")
34 @ApiOperation("查询指定Member")
35 public ResultInfo findById(@PathVariable("id") Long id) {
36 return ResultInfo.success(memberService.findById(id));
37 }
38
39 @Log
40 @PostMapping(value = "/create")
41 @ApiOperation("新增Member")
42 public ResultInfo create(@Validated @RequestBody Member resources) {
43 memberService.create(resources);
44 return ResultInfo.success();
45 }
46
47 @Log
48 @PutMapping(value = "/update")
49 @ApiOperation("修改Member")
50 public ResultInfo update(@Validated @RequestBody Member resources) {
51 memberService.update(resources);
52 return ResultInfo.success();
53 }
54
55 @GetMapping(value = "/getByCode/{code}")
56 @ApiOperation(value = "根据标识查询")
57 public ResultInfo getByCode(@PathVariable String code) {
58 return ResultInfo.success(memberService.getByCode(code));
59 }
60 }
1 package com.topdraw.business.basicdata.member.service;
2
3 import com.topdraw.business.basicdata.member.domain.Member;
4 import com.topdraw.business.basicdata.member.service.dto.MemberDTO;
5 import com.topdraw.business.basicdata.member.service.dto.MemberQueryCriteria;
6 import org.springframework.data.domain.Pageable;
7
8 import java.util.List;
9 import java.util.Map;
10
11 /**
12 * @author XiangHan
13 * @date 2021-10-22
14 */
15 public interface MemberService {
16
17 /**
18 * 查询数据分页
19 * @param criteria 条件参数
20 * @param pageable 分页参数
21 * @return Map<String,Object>
22 */
23 Map<String,Object> queryAll(MemberQueryCriteria criteria, Pageable pageable);
24
25 /**
26 * 查询所有数据不分页
27 * @param criteria 条件参数
28 * @return List<MemberDTO>
29 */
30 List<MemberDTO> queryAll(MemberQueryCriteria criteria);
31
32 /**
33 * 根据ID查询
34 * @param id ID
35 * @return MemberDTO
36 */
37 MemberDTO findById(Long id);
38
39 void create(Member resources);
40
41 void update(Member resources);
42
43 void delete(Long id);
44
45 /**
46 * Code校验
47 * @param code
48 * @return MemberDTO
49 */
50 MemberDTO getByCode(String code);
51 }
1 package com.topdraw.business.basicdata.member.service.dto;
2
3 import lombok.Data;
4
5 import java.io.Serializable;
6 import java.sql.Timestamp;
7
8
9 /**
10 * @author XiangHan
11 * @date 2021-10-22
12 */
13 @Data
14 public class MemberDTO implements Serializable {
15
16 // 主键
17 private Long id;
18
19 // 标识
20 private String code;
21
22 // 类型 1：大屏；2：小屏
23 private Integer type;
24
25 // 状态 0：不可用；1：可用
26 private Integer status;
27
28 // 昵称 base64
29 private String nickname;
30
31 // 描述
32 private String description;
33
34 // 性别 0：女；1：男；-1：未知
35 private Integer gender;
36
37 // 生日
38 private String birthday;
39
40 // 头像
41 private String avatarUrl;
42
43 // 分组信息
44 private String groups;
45
46 // 标签
47 private String tags;
48
49 // 是否会员 0：非会员；1：会员
50 private Integer vip;
51
52 // 会员等级（对应level表的level字段，非id）
53 private Integer level;
54
55 // 成长值
56 private Long exp;
57
58 // 当前积分
59 private Long points;
60
61 // 即将到期积分（一个月内）
62 private Long duePoints;
63
64 // 优惠券数量
65 private Integer couponAmount;
66
67 // 即将过期优惠券数量
68 private Integer dueCouponAmount;
69
70 // iptv账号id
71 private Long userIptvId;
72
73 // 绑定IPTV平台 0：未知；1：电信；2：移动；3：联通
74 private Integer bindIptvPlatformType;
75
76 // iptv账号绑定时间
77 private Timestamp bindIptvTime;
78
79 // 创建时间
80 private Timestamp createTime;
81
82 // 更新时间
83 private Timestamp updateTime;
84
85 // 是否在黑名单 1：是；0否
86 // private Integer blackStatus;
87 }
1 package com.topdraw.business.basicdata.member.service.dto;
2
3 import com.topdraw.annotation.Query;
4 import lombok.Data;
5
6 /**
7 * @author XiangHan
8 * @date 2021-10-22
9 */
10 @Data
11 public class MemberQueryCriteria{
12
13 @Query(type = Query.Type.LEFT_LIKE)
14 private String code;
15
16 // 类型 1：大屏；2：小屏
17 @Query(type = Query.Type.EQUAL)
18 private Integer type;
19
20 // 状态 0：不可用；1：可用
21 @Query(type = Query.Type.EQUAL)
22 private Integer status;
23
24 // 昵称 base64
25 @Query(type = Query.Type.LEFT_LIKE)
26 private String nickname;
27
28 // 性别 0：女；1：男；-1：未知
29 @Query(type = Query.Type.EQUAL)
30 private Integer gender;
31
32 // 分组信息
33 @Query(type = Query.Type.EQUAL)
34 private String groups;
35
36 // 标签
37 @Query(type = Query.Type.IN)
38 private String tags;
39
40 // 是否会员 0：非会员；1：会员
41 @Query(type = Query.Type.EQUAL)
42 private Integer vip;
43
44 // 会员等级（对应level表的level字段，非id）
45 @Query(type = Query.Type.EQUAL)
46 private Integer level;
47
48 // iptv账号id
49 @Query(type = Query.Type.EQUAL)
50 private Long userIptvId;
51
52 // 绑定IPTV平台 0：未知；1：电信；2：移动；3：联通
53 @Query(type = Query.Type.IN)
54 private Integer bindIptvPlatformType;
55
56 }
1 package com.topdraw.business.basicdata.member.service.impl;
2
3 import com.topdraw.business.basicdata.member.domain.Member;
4 import com.topdraw.business.basicdata.member.repository.MemberRepository;
5 import com.topdraw.business.basicdata.member.service.MemberService;
6 import com.topdraw.business.basicdata.member.service.dto.MemberDTO;
7 import com.topdraw.business.basicdata.member.service.dto.MemberQueryCriteria;
8 import com.topdraw.business.basicdata.member.service.mapper.MemberMapper;
9 import com.topdraw.util.IdWorker;
10 import com.topdraw.utils.PageUtil;
11 import com.topdraw.utils.QueryHelp;
12 import com.topdraw.utils.StringUtils;
13 import com.topdraw.utils.ValidationUtil;
14 import org.springframework.beans.factory.annotation.Autowired;
15 import org.springframework.dao.EmptyResultDataAccessException;
16 import org.springframework.data.domain.Page;
17 import org.springframework.data.domain.Pageable;
18 import org.springframework.stereotype.Service;
19 import org.springframework.transaction.annotation.Propagation;
20 import org.springframework.transaction.annotation.Transactional;
21 import org.springframework.util.Assert;
22
23 import java.util.List;
24 import java.util.Map;
25
26 /**
27 * @author XiangHan
28 * @date 2021-10-22
29 */
30 @Service
31 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
32 public class MemberServiceImpl implements MemberService {
33
34 @Autowired
35 private MemberRepository memberRepository;
36
37 @Autowired
38 private MemberMapper memberMapper;
39
40 @Override
41 public Map<String, Object> queryAll(MemberQueryCriteria criteria, Pageable pageable) {
42 Page<Member> page = memberRepository.findAll((root, criteriaQuery, criteriaBuilder)
43 -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
44 return PageUtil.toPage(page.map(memberMapper::toDto));
45 }
46
47 @Override
48 public List<MemberDTO> queryAll(MemberQueryCriteria criteria) {
49 return memberMapper.toDto(memberRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
50 }
51
52 @Override
53 public MemberDTO findById(Long id) {
54 Member member = memberRepository.findById(id).orElseGet(Member::new);
55 ValidationUtil.isNull(member.getId(),"Member","id",id);
56 return memberMapper.toDto(member);
57 }
58
59 @Override
60 @Transactional(rollbackFor = Exception.class)
61 public void create(Member resources) {
62 Member member = this.checkMemberData(resources);
63 memberRepository.save(member);
64 }
65
66 private Member checkMemberData(Member member) {
67 member.setCode(String.valueOf(IdWorker.generator()));
68 member.setGender(0);
69 member.setType(-1);
70 member.setStatus(1);
71 member.setVip(0);
72 member.setLevel(0);
73 member.setExp(0L);
74 member.setPoints(0);
75 member.setDuePoints(0L);
76 member.setCouponAmount(0);
77 member.setDueCouponAmount(0);
78 return member;
79 }
80
81 @Override
82 @Transactional(rollbackFor = Exception.class)
83 public void update(Member resources) {
84 Member member = memberRepository.findById(resources.getId()).orElseGet(Member::new);
85 ValidationUtil.isNull( member.getId(),"Member","id",resources.getId());
86 member.copy(resources);
87 memberRepository.save(member);
88 }
89
90 @Override
91 @Transactional(rollbackFor = Exception.class)
92 public void delete(Long id) {
93 Assert.notNull(id, "The given id must not be null!");
94 Member member = memberRepository.findById(id).orElseThrow(
95 () -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", Member.class, id), 1));
96 memberRepository.delete(member);
97 }
98
99
100 @Override
101 public MemberDTO getByCode(String code) {
102 return StringUtils.isNotEmpty(code) ? memberMapper.toDto(memberRepository.findFirstByCode(code).orElseGet(Member::new))
103 : new MemberDTO();
104 }
105 }
1 package com.topdraw.business.basicdata.member.service.mapper;
2
3 import com.topdraw.base.BaseMapper;
4 import com.topdraw.business.basicdata.member.domain.Member;
5 import com.topdraw.business.basicdata.member.service.dto.MemberDTO;
6 import org.mapstruct.Mapper;
7 import org.mapstruct.ReportingPolicy;
8
9 /**
10 * @author XiangHan
11 * @date 2021-10-22
12 */
13 @Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
14 public interface MemberMapper extends BaseMapper<MemberDTO, Member> {
15
16 }
1 package com.topdraw.business.basicdata.points.available.domain;
2
3 import cn.hutool.core.bean.BeanUtil;
4 import cn.hutool.core.bean.copier.CopyOptions;
5 import com.fasterxml.jackson.annotation.JsonFormat;
6 import lombok.Data;
7 import lombok.experimental.Accessors;
8 import org.springframework.data.annotation.CreatedDate;
9 import org.springframework.data.annotation.LastModifiedDate;
10 import org.springframework.data.jpa.domain.support.AuditingEntityListener;
11
12 import javax.persistence.*;
13 import java.io.Serializable;
14 import java.sql.Timestamp;
15
16 /**
17 * @author XiangHan
18 * @date 2021-10-23
19 */
20 @Entity
21 @Data
22 @EntityListeners(AuditingEntityListener.class)
23 @Accessors(chain = true)
24 @Table(name="uc_points_available")
25 public class PointsAvailable implements Serializable {
26
27 // 主键
28 @Id
29 @GeneratedValue(strategy = GenerationType.IDENTITY)
30 @Column(name = "id")
31 private Long id;
32
33 // 标识
34 @Column(name = "code")
35 private String code;
36
37 // 积分类型 0：通用型
38 @Column(name = "points_type")
39 private Integer pointsType;
40
41 // 设备类型 1：大屏；2：小屏（微信）3.小屏（xx）
42 @Column(name = "device_type")
43 private Integer deviceType;
44
45 // 会员id
46 @Column(name = "member_id", nullable = false)
47 private Long memberId;
48
49 // 积分值
50 @Column(name = "points")
51 private Long points;
52
53 // 过期时间
54 @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
55 @Column(name = "expire_time")
56 private Timestamp expireTime;
57
58 // 描述
59 @Column(name = "description")
60 private String description;
61
62 // 创建时间
63 @CreatedDate
64 @Column(name = "create_time")
65 private Timestamp createTime;
66
67 // 更新时间
68 @LastModifiedDate
69 @Column(name = "update_time")
70 private Timestamp updateTime;
71
72 public void copy(PointsAvailable source){
73 BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
74 }
75 }
1 package com.topdraw.business.basicdata.points.available.repository;
2
3 import com.topdraw.business.basicdata.points.available.domain.PointsAvailable;
4 import com.topdraw.business.basicdata.points.available.service.dto.PointsAvailableDTO;
5 import org.springframework.data.jpa.repository.JpaRepository;
6 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
7
8 import java.util.Date;
9 import java.util.List;
10 import java.util.Optional;
11
12 /**
13 * @author XiangHan
14 * @date 2021-10-23
15 */
16 public interface PointsAvailableRepository extends JpaRepository<PointsAvailable, Long>, JpaSpecificationExecutor<PointsAvailable> {
17
18 Optional<PointsAvailable> findFirstByCode(String code);
19
20 List<PointsAvailableDTO> findByMemberId(Long memberId);
21
22 List<PointsAvailable> findByMemberIdAndExpireTimeBefore(Long memberId , Date now);
23 }
1 package com.topdraw.business.basicdata.points.available.rest;
2
3 /**
4 * @author XiangHan
5 * @date 2021-10-23
6 */
7 //@Api(tags = "PointsAvailable管理")
8 //@RestController
9 //@RequestMapping("/api/PointsAvailable")
10 public class PointsAvailableController {
11
12 /*@Autowired
13 private PointsAvailableService PointsAvailableService;
14
15 @GetMapping
16 @ApiOperation("查询PointsAvailable")
17 public ResultInfo getPointsAvailables(PointsAvailableQueryCriteria criteria, Pageable pageable) {
18 return ResultInfo.successPage(PointsAvailableService.queryAll(criteria,pageable));
19 }
20
21 @GetMapping(value = "/all")
22 @ApiOperation("查询所有PointsAvailable")
23 public ResultInfo getPointsAvailables(PointsAvailableQueryCriteria criteria) {
24 return ResultInfo.success(PointsAvailableService.queryAll(criteria));
25 }
26
27 @Log
28 @PostMapping
29 @ApiOperation("新增PointsAvailable")
30 public ResultInfo create(@Validated @RequestBody PointsAvailable resources) {
31 PointsAvailableService.create(resources);
32 return ResultInfo.success();
33 }
34
35 @Log
36 @PutMapping
37 @ApiOperation("修改PointsAvailable")
38 public ResultInfo update(@Validated @RequestBody PointsAvailable resources) {
39 PointsAvailableService.update(resources);
40 return ResultInfo.success();
41 }
42
43
44 @Log
45 @DeleteMapping(value = "/{id}")
46 @ApiOperation("删除PointsAvailable")
47 public ResultInfo delete(@PathVariable Long id) {
48 PointsAvailableService.delete(id);
49 return ResultInfo.success();
50 }
51
52 @GetMapping(value = "/getByCode/{code}")
53 @ApiOperation(value = "根据标识查询")
54 public ResultInfo getByCode(@PathVariable String code) {
55 return ResultInfo.success(PointsAvailableService.getByCode(code));
56 }*/
57 }
1 package com.topdraw.business.basicdata.points.available.service;
2
3 import com.topdraw.business.basicdata.points.available.domain.PointsAvailable;
4 import com.topdraw.business.basicdata.points.available.service.dto.PointsAvailableDTO;
5 import com.topdraw.business.basicdata.points.available.service.dto.PointsAvailableQueryCriteria;
6 import org.springframework.data.domain.Pageable;
7
8 import java.util.Date;
9 import java.util.List;
10 import java.util.Map;
11
12 /**
13 * @author XiangHan
14 * @date 2021-10-23
15 */
16 public interface PointsAvailableService {
17
18 /**
19 * 查询数据分页
20 * @param criteria 条件参数
21 * @param pageable 分页参数
22 * @return Map<String,Object>
23 */
24 Map<String,Object> queryAll(PointsAvailableQueryCriteria criteria, Pageable pageable);
25
26 /**
27 * 查询所有数据不分页
28 * @param criteria 条件参数
29 * @return List<PointsAvailableDTO>
30 */
31 List<PointsAvailableDTO> queryAll(PointsAvailableQueryCriteria criteria);
32
33 /**
34 * 根据ID查询
35 * @param id ID
36 * @return PointsAvailableDTO
37 */
38 PointsAvailableDTO findById(Long id);
39
40 /**
41 *
42 * @param resources
43 */
44 void create(PointsAvailable resources);
45
46 /**
47 *
48 * @param resources
49 */
50 void update(PointsAvailable resources);
51
52 /**
53 *
54 * @param id
55 */
56 void delete(Long id);
57
58 /**
59 * Code校验
60 * @param code
61 * @return PointsAvailableDTO
62 */
63 PointsAvailableDTO getByCode(String code);
64
65 /**
66 *
67 * @param memberId
68 * @param timestamp
69 * @return
70 */
71 List<PointsAvailableDTO> findByMemberIdAndExpireTimeBefore(Long memberId, Date timestamp);
72
73 /**
74 * 查询数据分页
75 * @param criteria 条件参数
76 * @param pageable 分页参数
77 * @return Map<String,Object>
78 */
79 Map<String,Object> findByMemberIdAndExpireTimeBefore(PointsAvailableQueryCriteria criteria, Pageable pageable);
80 }
1 package com.topdraw.business.basicdata.points.available.service.dto;
2
3 import lombok.Data;
4
5 import java.io.Serializable;
6 import java.sql.Timestamp;
7
8
9 /**
10 * @author XiangHan
11 * @date 2021-10-23
12 */
13 @Data
14 public class PointsAvailableDTO implements Serializable {
15
16 // 主键
17 private Long id;
18
19 // 标识
20 private String code;
21
22 // 积分类型 0：通用型
23 private Integer pointsType;
24
25 // 设备类型 1：大屏；2：小屏（微信）3.小屏（xx）
26 private Integer deviceType;
27
28 // 会员id
29 private Long memberId;
30
31 // 积分值
32 private Long points;
33
34 // 过期时间
35 private Timestamp expireTime;
36
37 // 描述
38 private String description;
39
40 // 创建时间
41 private Timestamp createTime;
42
43 // 更新时间
44 private Timestamp updateTime;
45 }
1 package com.topdraw.business.basicdata.points.available.service.dto;
2
3 import com.topdraw.annotation.Query;
4 import lombok.Data;
5
6 import java.sql.Timestamp;
7
8 /**
9 * @author XiangHan
10 * @date 2021-10-23
11 */
12 @Data
13 public class PointsAvailableQueryCriteria{
14
15 @Query
16 private Long memberId;
17
18 @Query
19 private Long accountId;
20
21 @Query(type = Query.Type.GREATER_THAN)
22 private Timestamp expireTime;
23
24 private PointsAvailableQueryType queryType;
25
26 }
1 package com.topdraw.business.basicdata.points.available.service.dto;
2
3 public enum PointsAvailableQueryType {
4
5 // 全部
6 ALL,
7 // 可用
8 AVAILABLE_ONLY
9
10 }
1 package com.topdraw.business.basicdata.points.available.service.impl;
2
3 import com.topdraw.business.basicdata.points.available.domain.PointsAvailable;
4 import com.topdraw.business.basicdata.points.available.repository.PointsAvailableRepository;
5 import com.topdraw.business.basicdata.points.available.service.PointsAvailableService;
6 import com.topdraw.business.basicdata.points.available.service.dto.PointsAvailableDTO;
7 import com.topdraw.business.basicdata.points.available.service.dto.PointsAvailableQueryCriteria;
8 import com.topdraw.business.basicdata.points.available.service.mapper.PointsAvailableMapper;
9 import com.topdraw.utils.PageUtil;
10 import com.topdraw.utils.QueryHelp;
11 import com.topdraw.utils.StringUtils;
12 import com.topdraw.utils.ValidationUtil;
13 import org.springframework.beans.factory.annotation.Autowired;
14 import org.springframework.dao.EmptyResultDataAccessException;
15 import org.springframework.data.domain.Page;
16 import org.springframework.data.domain.Pageable;
17 import org.springframework.stereotype.Service;
18 import org.springframework.transaction.annotation.Propagation;
19 import org.springframework.transaction.annotation.Transactional;
20 import org.springframework.util.Assert;
21
22 import java.util.Date;
23 import java.util.List;
24 import java.util.Map;
25 import java.util.Objects;
26
27 /**
28 * @author XiangHan
29 * @date 2021-10-23
30 */
31 @Service
32 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
33 public class PointsAvailableServiceImpl implements PointsAvailableService {
34
35 @Autowired
36 private PointsAvailableRepository PointsAvailableRepository;
37
38 @Autowired
39 private PointsAvailableMapper PointsAvailableMapper;
40
41 @Override
42 public Map<String, Object> queryAll(PointsAvailableQueryCriteria criteria, Pageable pageable) {
43 Page<PointsAvailable> page = PointsAvailableRepository.findAll((root, criteriaQuery, criteriaBuilder) ->
44 QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
45 return PageUtil.toPage(page.map(PointsAvailableMapper::toDto));
46 }
47
48 @Override
49 public Map<String, Object> findByMemberIdAndExpireTimeBefore(PointsAvailableQueryCriteria criteria, Pageable pageable) {
50 return this.queryAll(criteria,pageable);
51 }
52
53 @Override
54 public List<PointsAvailableDTO> queryAll(PointsAvailableQueryCriteria criteria) {
55 return PointsAvailableMapper.toDto(PointsAvailableRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
56 }
57
58 @Override
59 public PointsAvailableDTO findById(Long id) {
60 PointsAvailable PointsAvailable = PointsAvailableRepository.findById(id).orElseGet(PointsAvailable::new);
61 ValidationUtil.isNull(PointsAvailable.getId(),"PointsAvailable","id",id);
62 return PointsAvailableMapper.toDto(PointsAvailable);
63 }
64
65 @Override
66 @Transactional(rollbackFor = Exception.class)
67 public void create(PointsAvailable resources) {
68 PointsAvailableRepository.save(resources);
69 }
70
71 @Override
72 @Transactional(rollbackFor = Exception.class)
73 public void update(PointsAvailable resources) {
74 PointsAvailable PointsAvailable = PointsAvailableRepository.findById(resources.getId()).orElseGet(PointsAvailable::new);
75 ValidationUtil.isNull( PointsAvailable.getId(),"PointsAvailable","id",resources.getId());
76 PointsAvailable.copy(resources);
77 PointsAvailableRepository.save(PointsAvailable);
78 }
79
80 @Override
81 @Transactional(rollbackFor = Exception.class)
82 public void delete(Long id) {
83 Assert.notNull(id, "The given id must not be null!");
84 PointsAvailable PointsAvailable = PointsAvailableRepository.findById(id).orElseThrow(
85 () -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", PointsAvailable.class, id), 1));
86 PointsAvailableRepository.delete(PointsAvailable);
87 }
88
89
90 @Override
91 public PointsAvailableDTO getByCode(String code) {
92 return StringUtils.isNotEmpty(code) ? PointsAvailableMapper.toDto(PointsAvailableRepository.findFirstByCode(code).orElseGet(PointsAvailable::new))
93 : new PointsAvailableDTO();
94 }
95
96 @Override
97 public List<PointsAvailableDTO> findByMemberIdAndExpireTimeBefore(Long memberId, Date timestamp) {
98 return Objects.nonNull(memberId)?
99 PointsAvailableMapper.toDto(PointsAvailableRepository.findByMemberIdAndExpireTimeBefore(memberId, timestamp))
100 :null;
101 }
102
103
104 }
1 package com.topdraw.business.basicdata.points.available.service.mapper;
2
3 import com.topdraw.base.BaseMapper;
4 import com.topdraw.business.basicdata.points.available.domain.PointsAvailable;
5 import com.topdraw.business.basicdata.points.available.service.dto.PointsAvailableDTO;
6 import org.mapstruct.Mapper;
7 import org.mapstruct.ReportingPolicy;
8
9 /**
10 * @author XiangHan
11 * @date 2021-10-23
12 */
13 @Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
14 public interface PointsAvailableMapper extends BaseMapper<PointsAvailableDTO, PointsAvailable> {
15
16 }
1 package com.topdraw.business.basicdata.points.detail.detailhistory.domain;
2
3 import cn.hutool.core.bean.BeanUtil;
4 import cn.hutool.core.bean.copier.CopyOptions;
5 import lombok.Data;
6 import lombok.experimental.Accessors;
7 import org.springframework.data.annotation.CreatedDate;
8 import org.springframework.data.annotation.LastModifiedDate;
9 import org.springframework.data.jpa.domain.support.AuditingEntityListener;
10
11 import javax.persistence.*;
12 import java.io.Serializable;
13 import java.sql.Timestamp;
14
15 /**
16 * @author XiangHan
17 * @date 2021-10-22
18 */
19 @Entity
20 @Data
21 @EntityListeners(AuditingEntityListener.class)
22 @Accessors(chain = true)
23 @Table(name="uc_points_detail_history")
24 public class PointsDetailHistory implements Serializable {
25
26 // 主键
27 @Id
28 @GeneratedValue(strategy = GenerationType.IDENTITY)
29 @Column(name = "id")
30 private Long id;
31
32 // 标识
33 @Column(name = "code", nullable = false)
34 private String code;
35
36 // 应用code
37 @Column(name = "app_code")
38 private String appCode;
39
40 // 会员id
41 @Column(name = "member_id", nullable = false)
42 private Long memberId;
43
44 // 账号id
45 @Column(name = "account_id")
46 private Long accountId;
47
48 // 原始积分
49 @Column(name = "original_points", nullable = false)
50 private Long originalPoints;
51
52 // 结果积分
53 @Column(name = "result_points", nullable = false)
54 private Long resultPoints;
55
56 // 积分变化，积分获得为正，积分消耗为负
57 @Column(name = "points", nullable = false)
58 private Long points;
59
60 // 设备类型 1：大屏；2：小屏（微信）3.小屏（xx）
61 @Column(name = "device_type", nullable = false)
62 private Integer deviceType;
63
64 // 行为事件类型 1：登录；2：观影；3：参与活动；4：订购；10：跨屏绑定；11：积分转移；98：系统操作；99：其他
65 @Column(name = "evt_type", nullable = false)
66 private Integer evtType;
67
68 // 订单id（针对订购操作）
69 @Column(name = "order_id")
70 private Long orderId;
71
72 // 节目id（针对观影操作）
73 @Column(name = "media_id")
74 private Long mediaId;
75
76 // 活动id（针对参与活动）
77 @Column(name = "activity_id")
78 private Long activityId;
79
80 // 积分变化描述，用于管理侧显示
81 @Column(name = "description", nullable = false)
82 private String description;
83
84 // 创建时间
85 @CreatedDate
86 @Column(name = "create_time")
87 private Timestamp createTime;
88
89 // 更新时间
90 @LastModifiedDate
91 @Column(name = "update_time")
92 private Timestamp updateTime;
93
94 public void copy(PointsDetailHistory source){
95 BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
96 }
97 }
1 package com.topdraw.business.basicdata.points.detail.detailhistory.repository;
2
3 import com.topdraw.business.basicdata.points.detail.detailhistory.domain.PointsDetailHistory;
4 import org.springframework.data.jpa.repository.JpaRepository;
5 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
6
7 import java.util.Optional;
8
9 /**
10 * @author XiangHan
11 * @date 2021-10-22
12 */
13 public interface PointsDetailHistoryRepository extends JpaRepository<PointsDetailHistory, Long>, JpaSpecificationExecutor<PointsDetailHistory> {
14
15 Optional<PointsDetailHistory> findFirstByCode(String code);
16 }
1 package com.topdraw.business.basicdata.points.detail.detailhistory.rest;
2
3 import io.swagger.annotations.Api;
4
5 /**
6 * @author XiangHan
7 * @date 2021-10-22
8 */
9 @Api(tags = "PointsDetailHistory管理")
10 //@RestController
11 //@RequestMapping("/api/PointsDetailHistory")
12 public class PointsDetailHistoryController {
13
14 /*@Autowired
15 private PointsDetailHistoryService PointsDetailHistoryService;
16
17 @GetMapping
18 @ApiOperation("查询PointsDetailHistory")
19 public ResultInfo getPointsDetailHistorys(PointsDetailHistoryQueryCriteria criteria, Pageable pageable) {
20 return ResultInfo.successPage(PointsDetailHistoryService.queryAll(criteria,pageable));
21 }
22
23 @GetMapping(value = "/all")
24 @ApiOperation("查询所有PointsDetailHistory")
25 public ResultInfo getPointsDetailHistorys(PointsDetailHistoryQueryCriteria criteria) {
26 return ResultInfo.success(PointsDetailHistoryService.queryAll(criteria));
27 }
28
29 @Log
30 @PostMapping
31 @ApiOperation("新增PointsDetailHistory")
32 public ResultInfo create(@Validated @RequestBody PointsDetailHistory resources) {
33 PointsDetailHistoryService.create(resources);
34 return ResultInfo.success();
35 }
36
37 @Log
38 @PutMapping
39 @ApiOperation("修改PointsDetailHistory")
40 public ResultInfo update(@Validated @RequestBody PointsDetailHistory resources) {
41 PointsDetailHistoryService.update(resources);
42 return ResultInfo.success();
43 }
44
45
46 @Log
47 @DeleteMapping(value = "/{id}")
48 @ApiOperation("删除PointsDetailHistory")
49 public ResultInfo delete(@PathVariable Long id) {
50 PointsDetailHistoryService.delete(id);
51 return ResultInfo.success();
52 }
53
54 @GetMapping(value = "/getByCode/{code}")
55 @ApiOperation(value = "根据标识查询")
56 public ResultInfo getByCode(@PathVariable String code) {
57 return ResultInfo.success(PointsDetailHistoryService.getByCode(code));
58 }*/
59 }
1 package com.topdraw.business.basicdata.points.detail.detailhistory.service;
2
3 import com.topdraw.business.basicdata.points.detail.detailhistory.domain.PointsDetailHistory;
4 import com.topdraw.business.basicdata.points.detail.detailhistory.service.dto.PointsDetailHistoryDTO;
5 import com.topdraw.business.basicdata.points.detail.detailhistory.service.dto.PointsDetailHistoryQueryCriteria;
6 import org.springframework.data.domain.Pageable;
7
8 import java.util.List;
9 import java.util.Map;
10
11 /**
12 * @author XiangHan
13 * @date 2021-10-22
14 */
15 public interface PointsDetailHistoryService {
16
17 /**
18 * 查询数据分页
19 * @param criteria 条件参数
20 * @param pageable 分页参数
21 * @return Map<String,Object>
22 */
23 Map<String,Object> queryAll(PointsDetailHistoryQueryCriteria criteria, Pageable pageable);
24
25 /**
26 * 查询所有数据不分页
27 * @param criteria 条件参数
28 * @return List<PointsDetailHistoryDTO>
29 */
30 List<PointsDetailHistoryDTO> queryAll(PointsDetailHistoryQueryCriteria criteria);
31
32 /**
33 * 根据ID查询
34 * @param id ID
35 * @return PointsDetailHistoryDTO
36 */
37 PointsDetailHistoryDTO findById(Long id);
38
39 void create(PointsDetailHistory resources);
40
41 void update(PointsDetailHistory resources);
42
43 void delete(Long id);
44
45 /**
46 * Code校验
47 * @param code
48 * @return PointsDetailHistoryDTO
49 */
50 PointsDetailHistoryDTO getByCode(String code);
51 }
1 package com.topdraw.business.basicdata.points.detail.detailhistory.service.dto;
2
3 import lombok.Data;
4
5 import java.io.Serializable;
6 import java.sql.Timestamp;
7
8
9 /**
10 * @author XiangHan
11 * @date 2021-10-22
12 */
13 @Data
14 public class PointsDetailHistoryDTO implements Serializable {
15
16 // 主键
17 private Long id;
18
19 // 标识
20 private String code;
21
22 // 应用code
23 private String appCode;
24
25 // 会员id
26 private Long memberId;
27
28 // 账号id
29 private Long accountId;
30
31 // 原始积分
32 private Long originalPoints;
33
34 // 结果积分
35 private Long resultPoints;
36
37 // 积分变化，积分获得为正，积分消耗为负
38 private Long points;
39
40 // 设备类型 1：大屏；2：小屏（微信）3.小屏（xx）
41 private Integer deviceType;
42
43 // 行为事件类型 1：登录；2：观影；3：参与活动；4：订购；10：跨屏绑定；11：积分转移；98：系统操作；99：其他
44 private Integer evtType;
45
46 // 订单id（针对订购操作）
47 private Long orderId;
48
49 // 节目id（针对观影操作）
50 private Long mediaId;
51
52 // 活动id（针对参与活动）
53 private Long activityId;
54
55 // 积分变化描述，用于管理侧显示
56 private String description;
57
58 // 创建时间
59 private Timestamp createTime;
60
61 // 更新时间
62 private Timestamp updateTime;
63 }
1 package com.topdraw.business.basicdata.points.detail.detailhistory.service.dto;
2
3 import lombok.Data;
4
5 /**
6 * @author XiangHan
7 * @date 2021-10-22
8 */
9 @Data
10 public class PointsDetailHistoryQueryCriteria{
11 }
1 package com.topdraw.business.basicdata.points.detail.detailhistory.service.impl;
2
3 import com.topdraw.business.basicdata.points.detail.detailhistory.domain.PointsDetailHistory;
4 import com.topdraw.business.basicdata.points.detail.detailhistory.repository.PointsDetailHistoryRepository;
5 import com.topdraw.business.basicdata.points.detail.detailhistory.service.PointsDetailHistoryService;
6 import com.topdraw.business.basicdata.points.detail.detailhistory.service.dto.PointsDetailHistoryDTO;
7 import com.topdraw.business.basicdata.points.detail.detailhistory.service.dto.PointsDetailHistoryQueryCriteria;
8 import com.topdraw.business.basicdata.points.detail.detailhistory.service.mapper.PointsDetailHistoryMapper;
9 import com.topdraw.utils.PageUtil;
10 import com.topdraw.utils.QueryHelp;
11 import com.topdraw.utils.StringUtils;
12 import com.topdraw.utils.ValidationUtil;
13 import org.springframework.beans.factory.annotation.Autowired;
14 import org.springframework.dao.EmptyResultDataAccessException;
15 import org.springframework.data.domain.Page;
16 import org.springframework.data.domain.Pageable;
17 import org.springframework.stereotype.Service;
18 import org.springframework.transaction.annotation.Propagation;
19 import org.springframework.transaction.annotation.Transactional;
20 import org.springframework.util.Assert;
21
22 import java.util.List;
23 import java.util.Map;
24
25 /**
26 * @author XiangHan
27 * @date 2021-10-22
28 */
29 @Service
30 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
31 public class PointsDetailHistoryServiceImpl implements PointsDetailHistoryService {
32
33 @Autowired
34 private PointsDetailHistoryRepository PointsDetailHistoryRepository;
35
36 @Autowired
37 private PointsDetailHistoryMapper PointsDetailHistoryMapper;
38
39 @Override
40 public Map<String, Object> queryAll(PointsDetailHistoryQueryCriteria criteria, Pageable pageable) {
41 Page<PointsDetailHistory> page = PointsDetailHistoryRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
42 return PageUtil.toPage(page.map(PointsDetailHistoryMapper::toDto));
43 }
44
45 @Override
46 public List<PointsDetailHistoryDTO> queryAll(PointsDetailHistoryQueryCriteria criteria) {
47 return PointsDetailHistoryMapper.toDto(PointsDetailHistoryRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
48 }
49
50 @Override
51 public PointsDetailHistoryDTO findById(Long id) {
52 PointsDetailHistory PointsDetailHistory = PointsDetailHistoryRepository.findById(id).orElseGet(PointsDetailHistory::new);
53 ValidationUtil.isNull(PointsDetailHistory.getId(),"PointsDetailHistory","id",id);
54 return PointsDetailHistoryMapper.toDto(PointsDetailHistory);
55 }
56
57 @Override
58 @Transactional(rollbackFor = Exception.class)
59 public void create(PointsDetailHistory resources) {
60 PointsDetailHistoryRepository.save(resources);
61 }
62
63 @Override
64 @Transactional(rollbackFor = Exception.class)
65 public void update(PointsDetailHistory resources) {
66 PointsDetailHistory PointsDetailHistory = PointsDetailHistoryRepository.findById(resources.getId()).orElseGet(PointsDetailHistory::new);
67 ValidationUtil.isNull( PointsDetailHistory.getId(),"PointsDetailHistory","id",resources.getId());
68 PointsDetailHistory.copy(resources);
69 PointsDetailHistoryRepository.save(PointsDetailHistory);
70 }
71
72 @Override
73 @Transactional(rollbackFor = Exception.class)
74 public void delete(Long id) {
75 Assert.notNull(id, "The given id must not be null!");
76 PointsDetailHistory PointsDetailHistory = PointsDetailHistoryRepository.findById(id).orElseThrow(
77 () -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", PointsDetailHistory.class, id), 1));
78 PointsDetailHistoryRepository.delete(PointsDetailHistory);
79 }
80
81
82 @Override
83 public PointsDetailHistoryDTO getByCode(String code) {
84 return StringUtils.isNotEmpty(code) ? PointsDetailHistoryMapper.toDto(PointsDetailHistoryRepository.findFirstByCode(code).orElseGet(PointsDetailHistory::new))
85 : new PointsDetailHistoryDTO();
86 }
87 }
1 package com.topdraw.business.basicdata.points.detail.detailhistory.service.mapper;
2
3 import com.topdraw.base.BaseMapper;
4 import com.topdraw.business.basicdata.points.detail.detailhistory.domain.PointsDetailHistory;
5 import com.topdraw.business.basicdata.points.detail.detailhistory.service.dto.PointsDetailHistoryDTO;
6 import org.mapstruct.Mapper;
7 import org.mapstruct.ReportingPolicy;
8
9 /**
10 * @author XiangHan
11 * @date 2021-10-22
12 */
13 @Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
14 public interface PointsDetailHistoryMapper extends BaseMapper<PointsDetailHistoryDTO, PointsDetailHistory> {
15
16 }