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