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
Inline Side-by-side
Showing 188 changed files with 9764 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> {
}
package com.topdraw.business.basicdata.points.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_points_detail")
public class PointsDetail 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(PointsDetail source){
BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
}
}
package com.topdraw.business.basicdata.points.detail.repository;
import com.topdraw.business.basicdata.points.detail.domain.PointsDetail;
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 PointsDetailRepository extends JpaRepository<PointsDetail, Long>, JpaSpecificationExecutor<PointsDetail> {
Optional<PointsDetail> findFirstByCode(String code);
}
package com.topdraw.business.basicdata.points.detail.rest;
import io.swagger.annotations.Api;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Api(tags = "PointsDetail管理")
//@RestController
//@RequestMapping("/api/PointsDetail")
public class PointsDetailController {
/*@Autowired
private PointsDetailService PointsDetailService;
@GetMapping
@ApiOperation("查询PointsDetail")
public ResultInfo getPointsDetails(PointsDetailQueryCriteria criteria, Pageable pageable) {
return ResultInfo.successPage(PointsDetailService.queryAll(criteria,pageable));
}
@GetMapping(value = "/all")
@ApiOperation("查询所有PointsDetail")
public ResultInfo getPointsDetails(PointsDetailQueryCriteria criteria) {
return ResultInfo.success(PointsDetailService.queryAll(criteria));
}
@Log
@PostMapping
@ApiOperation("新增PointsDetail")
public ResultInfo create(@Validated @RequestBody PointsDetail resources) {
PointsDetailService.create(resources);
return ResultInfo.success();
}
@Log
@PutMapping
@ApiOperation("修改PointsDetail")
public ResultInfo update(@Validated @RequestBody PointsDetail resources) {
PointsDetailService.update(resources);
return ResultInfo.success();
}
@Log
@DeleteMapping(value = "/{id}")
@ApiOperation("删除PointsDetail")
public ResultInfo delete(@PathVariable Long id) {
PointsDetailService.delete(id);
return ResultInfo.success();
}
@GetMapping(value = "/getByCode/{code}")
@ApiOperation(value = "根据标识查询")
public ResultInfo getByCode(@PathVariable String code) {
return ResultInfo.success(PointsDetailService.getByCode(code));
}*/
}
package com.topdraw.business.basicdata.points.detail.service;
import com.topdraw.business.basicdata.points.detail.domain.PointsDetail;
import com.topdraw.business.basicdata.points.detail.service.dto.PointsDetailDTO;
import com.topdraw.business.basicdata.points.detail.service.dto.PointsDetailQueryCriteria;
import org.springframework.data.domain.Pageable;
import java.util.List;
import java.util.Map;
/**
* @author XiangHan
* @date 2021-10-22
*/
public interface PointsDetailService {
/**
* 查询数据分页
* @param criteria 条件参数
* @param pageable 分页参数
* @return Map<String,Object>
*/
Map<String,Object> queryAll(PointsDetailQueryCriteria criteria, Pageable pageable);
/**
* 查询所有数据不分页
* @param criteria 条件参数
* @return List<PointsDetailDTO>
*/
List<PointsDetailDTO> queryAll(PointsDetailQueryCriteria criteria);
/**
* 根据ID查询
* @param id ID
* @return PointsDetailDTO
*/
PointsDetailDTO findById(Long id);
void create(PointsDetail resources);
void update(PointsDetail resources);
void delete(Long id);
/**
* Code校验
* @param code
* @return PointsDetailDTO
*/
PointsDetailDTO getByCode(String code);
List<PointsDetailDTO> loadListExpirePointsByMemberId(Long memberId);
}
package com.topdraw.business.basicdata.points.detail.service.dto;
import lombok.Data;
import java.io.Serializable;
import java.sql.Timestamp;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class PointsDetailDTO 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.service.dto;
import com.topdraw.annotation.Query;
import lombok.Data;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class PointsDetailQueryCriteria{
@Query(type = Query.Type.EQUAL)
private Long memberId;
@Query(type = Query.Type.EQUAL)
private Long accountId;
}
package com.topdraw.business.basicdata.points.detail.service.impl;
import com.topdraw.business.basicdata.points.detail.domain.PointsDetail;
import com.topdraw.business.basicdata.points.detail.repository.PointsDetailRepository;
import com.topdraw.business.basicdata.points.detail.service.PointsDetailService;
import com.topdraw.business.basicdata.points.detail.service.dto.PointsDetailDTO;
import com.topdraw.business.basicdata.points.detail.service.dto.PointsDetailQueryCriteria;
import com.topdraw.business.basicdata.points.detail.service.mapper.PointsDetailMapper;
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 PointsDetailServiceImpl implements PointsDetailService {
@Autowired
private PointsDetailRepository PointsDetailRepository;
@Autowired
private PointsDetailMapper PointsDetailMapper;
@Override
public Map<String, Object> queryAll(PointsDetailQueryCriteria criteria, Pageable pageable) {
Page<PointsDetail> page = PointsDetailRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
return PageUtil.toPage(page.map(PointsDetailMapper::toDto));
}
@Override
public List<PointsDetailDTO> queryAll(PointsDetailQueryCriteria criteria) {
return PointsDetailMapper.toDto(PointsDetailRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
}
@Override
public PointsDetailDTO findById(Long id) {
PointsDetail PointsDetail = PointsDetailRepository.findById(id).orElseGet(PointsDetail::new);
ValidationUtil.isNull(PointsDetail.getId(),"PointsDetail","id",id);
return PointsDetailMapper.toDto(PointsDetail);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void create(PointsDetail resources) {
PointsDetailRepository.save(resources);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void update(PointsDetail resources) {
PointsDetail PointsDetail = PointsDetailRepository.findById(resources.getId()).orElseGet(PointsDetail::new);
ValidationUtil.isNull( PointsDetail.getId(),"PointsDetail","id",resources.getId());
PointsDetail.copy(resources);
PointsDetailRepository.save(PointsDetail);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void delete(Long id) {
Assert.notNull(id, "The given id must not be null!");
PointsDetail PointsDetail = PointsDetailRepository.findById(id).orElseThrow(
() -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", PointsDetail.class, id), 1));
PointsDetailRepository.delete(PointsDetail);
}
@Override
public PointsDetailDTO getByCode(String code) {
return StringUtils.isNotEmpty(code) ? PointsDetailMapper.toDto(PointsDetailRepository.findFirstByCode(code).orElseGet(PointsDetail::new))
: new PointsDetailDTO();
}
@Override
public List<PointsDetailDTO> loadListExpirePointsByMemberId(Long memberId) {
return null;
}
}
package com.topdraw.business.basicdata.points.detail.service.mapper;
import com.topdraw.base.BaseMapper;
import com.topdraw.business.basicdata.points.detail.domain.PointsDetail;
import com.topdraw.business.basicdata.points.detail.service.dto.PointsDetailDTO;
import org.mapstruct.Mapper;
import org.mapstruct.ReportingPolicy;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface PointsDetailMapper extends BaseMapper<PointsDetailDTO, PointsDetail> {
}
package com.topdraw.business.basicdata.points.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")
public class Points implements Serializable {
@Id
@Column(name = "id")
private Long id;
@Column(name = "user_id")
private Long userId;
// 积分类型，通用，绑定， 区分大小屏 todo
@Column(name = "point_type")
private Integer pointType;
// 绑定对应的实体， 如何描述？
@Column(name = "target_no")
private String targetNo;
// 本月期初积分值
@Column(name = "begin_points")
private Integer beginPoints;
// 当前积分余额
@Column(name = "current_points")
private Integer currentPoints;
// 本月到期积分
@Column(name = "expire_points")
private Integer expirePoints;
// 积分类型：10：通用积分（跨屏） 11：定向积分（跨屏，绑定用途）20：通用积分（大屏） 21：定向积分（大屏，绑定用途）30：通用积分（小屏） 31：定向积分（小屏，绑定用途）
@CreatedDate
@Column(name = "create_time")
private Timestamp createTime;
// 最后修改时间
@LastModifiedDate
@Column(name = "update_time")
private Timestamp updateTime;
public void copy(Points source){
BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
}
}
package com.topdraw.business.basicdata.points.repository;
import com.topdraw.business.basicdata.points.domain.Points;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
/**
* @author XiangHan
* @date 2021-10-22
*/
public interface PointsRepository extends JpaRepository<Points, Long>, JpaSpecificationExecutor<Points> {
}
package com.topdraw.business.basicdata.points.rest;
import io.swagger.annotations.Api;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Api(tags = "Points管理")
//@RestController
//@RequestMapping("/api/Points")
public class PointsController {
/* @Autowired
private PointsService PointsService;
@GetMapping
@ApiOperation("查询Points")
public ResultInfo getPointss(PointsQueryCriteria criteria, Pageable pageable) {
return ResultInfo.successPage(PointsService.queryAll(criteria,pageable));
}
@GetMapping(value = "/all")
@ApiOperation("查询所有Points")
public ResultInfo getPointss(PointsQueryCriteria criteria) {
return ResultInfo.success(PointsService.queryAll(criteria));
}
@Log
@PostMapping
@ApiOperation("新增Points")
public ResultInfo create(@Validated @RequestBody Points resources) {
PointsService.create(resources);
return ResultInfo.success();
}
@Log
@PutMapping
@ApiOperation("修改Points")
public ResultInfo update(@Validated @RequestBody Points resources) {
PointsService.update(resources);
return ResultInfo.success();
}
@Log
@DeleteMapping(value = "/{id}")
@ApiOperation("删除Points")
public ResultInfo delete(@PathVariable Long id) {
PointsService.delete(id);
return ResultInfo.success();
}*/
}
package com.topdraw.business.basicdata.points.service;
import com.topdraw.business.basicdata.points.domain.Points;
import com.topdraw.business.basicdata.points.service.dto.PointsDTO;
import com.topdraw.business.basicdata.points.service.dto.PointsQueryCriteria;
import org.springframework.data.domain.Pageable;
import java.util.List;
import java.util.Map;
/**
* @author XiangHan
* @date 2021-10-22
*/
public interface PointsService {
/**
* 查询数据分页
* @param criteria 条件参数
* @param pageable 分页参数
* @return Map<String,Object>
*/
Map<String,Object> queryAll(PointsQueryCriteria criteria, Pageable pageable);
/**
* 查询所有数据不分页
* @param criteria 条件参数
* @return List<PointsDTO>
*/
List<PointsDTO> queryAll(PointsQueryCriteria criteria);
/**
* 根据ID查询
* @param id ID
* @return PointsDTO
*/
PointsDTO findById(Long id);
void create(Points resources);
void update(Points resources);
void delete(Long id);
}
package com.topdraw.business.basicdata.points.service.dto;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import lombok.Data;
import java.io.Serializable;
import java.sql.Timestamp;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class PointsDTO implements Serializable {
// 处理精度丢失问题
@JsonSerialize(using= ToStringSerializer.class)
private Long id;
private Long userId;
// 积分类型，通用，绑定， 区分大小屏 todo
private Integer pointType;
// 绑定对应的实体， 如何描述？
private String targetNo;
// 本月期初积分值
private Integer beginPoints;
// 当前积分余额
private Integer currentPoints;
// 本月到期积分
private Integer expirePoints;
// 积分类型：10：通用积分（跨屏） 11：定向积分（跨屏，绑定用途）20：通用积分（大屏） 21：定向积分（大屏，绑定用途）30：通用积分（小屏） 31：定向积分（小屏，绑定用途）
private Timestamp createTime;
// 最后修改时间
private Timestamp updateTime;
}
package com.topdraw.business.basicdata.points.service.dto;
import lombok.Data;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class PointsQueryCriteria{
}
package com.topdraw.business.basicdata.points.service.impl;
import cn.hutool.core.lang.Snowflake;
import cn.hutool.core.util.IdUtil;
import com.topdraw.business.basicdata.points.domain.Points;
import com.topdraw.business.basicdata.points.repository.PointsRepository;
import com.topdraw.business.basicdata.points.service.PointsService;
import com.topdraw.business.basicdata.points.service.dto.PointsDTO;
import com.topdraw.business.basicdata.points.service.dto.PointsQueryCriteria;
import com.topdraw.business.basicdata.points.service.mapper.PointsMapper;
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 PointsServiceImpl implements PointsService {
@Autowired
private PointsRepository PointsRepository;
@Autowired
private PointsMapper PointsMapper;
@Override
public Map<String, Object> queryAll(PointsQueryCriteria criteria, Pageable pageable) {
Page<Points> page = PointsRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
return PageUtil.toPage(page.map(PointsMapper::toDto));
}
@Override
public List<PointsDTO> queryAll(PointsQueryCriteria criteria) {
return PointsMapper.toDto(PointsRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
}
@Override
public PointsDTO findById(Long id) {
Points Points = PointsRepository.findById(id).orElseGet(Points::new);
ValidationUtil.isNull(Points.getId(),"Points","id",id);
return PointsMapper.toDto(Points);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void create(Points resources) {
Snowflake snowflake = IdUtil.createSnowflake(1, 1);
resources.setId(snowflake.nextId());
PointsRepository.save(resources);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void update(Points resources) {
Points Points = PointsRepository.findById(resources.getId()).orElseGet(Points::new);
ValidationUtil.isNull( Points.getId(),"Points","id",resources.getId());
Points.copy(resources);
PointsRepository.save(Points);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void delete(Long id) {
Assert.notNull(id, "The given id must not be null!");
Points Points = PointsRepository.findById(id).orElseThrow(
() -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", Points.class, id), 1));
PointsRepository.delete(Points);
}
}
package com.topdraw.business.basicdata.points.service.mapper;
import com.topdraw.base.BaseMapper;
import com.topdraw.business.basicdata.points.domain.Points;
import com.topdraw.business.basicdata.points.service.dto.PointsDTO;
import org.mapstruct.Mapper;
import org.mapstruct.ReportingPolicy;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface PointsMapper extends BaseMapper<PointsDTO, Points> {
}
package com.topdraw.business.basicdata.rights.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="tr_rights")
public class Rights implements Serializable {
// 主键
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
// 标识
@Column(name = "code", nullable = false)
private String code;
// 权益名称
// @Column(name = "name")
// private String name;
// 类型 1：实体类 （预留字段）
@Column(name = "type", nullable = false)
private Integer type;
// 终端类型 0：大屏；1：微信小程序/公众号；2：App
@Column(name = "device_type", nullable = false)
private Integer deviceType;
// 权益的实体类型 1：积分；2成长值；3优惠券
@Column(name = "entity_type", nullable = false)
private String entityType;
// 实体id
@Column(name = "entity_id", nullable = false)
private Long entityId;
// 生效时间，为null表示获取后立即生效，不为空时，表示特定的生效时间
@Column(name = "valid_time")
private Timestamp validTime;
// 失效时间，空为不失效，否则为获得权益后直到失效的毫秒数
@Column(name = "expire_time")
private Long expireTime;
// 创建时间
@CreatedDate
@Column(name = "create_time")
private Timestamp createTime;
// 更新时间
@LastModifiedDate
@Column(name = "update_time")
private Timestamp updateTime;
// 图片
@Column(name = "image")
private String image;
// 图片
@Column(name = "images")
private String images;
// 描述
@Column(name = "description")
private String description;
public void copy(Rights source){
BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
}
}
package com.topdraw.business.basicdata.rights.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="tr_rights_histroy")
public class RightsHistory implements Serializable {
// 主键id
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
// 权益id
@Column(name = "rights_id",nullable = false)
private Long rightsId;
// 会员id
@Column(name = "member_id",nullable = false)
private Long memberId;
@Transient
private Long userId;
// 操作者id（手动发放时保存）
@Column(name = "operator_id",nullable = false)
private Long operatorId;
// 操作者名称（手动发放时保存）
@Column(name = "operator_name",nullable = false)
private String operatorName;
// 发放时间
@Column(name = "send_time")
private Timestamp sendTime;
// 失效时间
@Column(name = "expire_time")
private Timestamp expireTime;
@CreatedDate
@Column(name = "create_time")
private Timestamp createTime;
@LastModifiedDate
@Column(name = "update_time")
private Timestamp updateTime;
public void copy(RightsHistory source){
BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
}
}
package com.topdraw.business.basicdata.rights.history.repository;
import com.topdraw.business.basicdata.rights.history.domain.RightsHistory;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
/**
* @author XiangHan
* @date 2021-10-22
*/
public interface RightsHistoryRepository extends JpaRepository<RightsHistory, Long>, JpaSpecificationExecutor<RightsHistory> {
}
package com.topdraw.business.basicdata.rights.history.rest;
import com.topdraw.business.basicdata.rights.history.service.RightsHistoryService;
import com.topdraw.business.basicdata.rights.history.service.dto.RightsHistoryQueryCriteria;
import com.topdraw.common.ResultInfo;
import com.topdraw.util.TimestampUtil;
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.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Api(tags = "RightsHistory管理")
@RestController
@RequestMapping("/api/RightsHistory")
public class RightsHistoryController {
@Autowired
private RightsHistoryService RightsHistoryService;
@GetMapping(value = "/pageRightsHistory")
@ApiOperation("查询RightsHistory")
public ResultInfo pageRightsHistory(RightsHistoryQueryCriteria criteria, Pageable pageable) {
return ResultInfo.successPage(RightsHistoryService.queryAll(criteria,pageable));
}
@GetMapping(value = "/pageAvailableRights")
@ApiOperation("查询用户可用权益列表")
public ResultInfo pageAvailableRights(RightsHistoryQueryCriteria criteria, Pageable pageable) {
criteria.setExpireTime(TimestampUtil.now());
return ResultInfo.successPage(RightsHistoryService.queryAll(criteria,pageable));
}
}
package com.topdraw.business.basicdata.rights.history.service;
import com.topdraw.business.basicdata.rights.history.domain.RightsHistory;
import com.topdraw.business.basicdata.rights.history.service.dto.RightsHistoryDTO;
import com.topdraw.business.basicdata.rights.history.service.dto.RightsHistoryQueryCriteria;
import org.springframework.data.domain.Pageable;
import java.util.List;
import java.util.Map;
/**
* @author XiangHan
* @date 2021-10-22
*/
public interface RightsHistoryService {
/**
* 查询数据分页
* @param criteria 条件参数
* @param pageable 分页参数
* @return Map<String,Object>
*/
Map<String,Object> queryAll(RightsHistoryQueryCriteria criteria, Pageable pageable);
/**
* 查询所有数据不分页
* @param criteria 条件参数
* @return List<RightsHistoryDTO>
*/
List<RightsHistoryDTO> queryAll(RightsHistoryQueryCriteria criteria);
/**
* 根据ID查询
* @param id ID
* @return RightsHistoryDTO
*/
RightsHistoryDTO findById(Long id);
/**
*
* @param resources
*/
void create(RightsHistory resources);
/**
*
* @param resources
*/
void update(RightsHistory resources);
/**
*
* @param id
*/
void delete(Long id);
}
package com.topdraw.business.basicdata.rights.history.service.dto;
import lombok.Data;
import java.io.Serializable;
import java.sql.Timestamp;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class RightsHistoryDTO implements Serializable {
// 主键id
private Long id;
// 权益id
private Long rightsId;
// 会员id
private Long memberId;
// 操作者id（手动发放时保存）
private Long operatorId;
// 操作者名称（手动发放时保存）
private String operatorName;
// 发放时间
private Timestamp sendTime;
// 失效时间
private Timestamp expireTime;
private Timestamp createTime;
private Timestamp updateTime;
}
package com.topdraw.business.basicdata.rights.history.service.dto;
import com.topdraw.annotation.Query;
import lombok.Data;
import java.sql.Timestamp;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class RightsHistoryQueryCriteria{
@Query
private Long memberId;
@Query(type = Query.Type.GREATER_THAN)
private Timestamp expireTime;
private RightsHistoryQueryType queryType;
}
package com.topdraw.business.basicdata.rights.history.service.dto;
public enum RightsHistoryQueryType {
// 全部
ALL,
// 可用
AVAILABLE_ONLY
}
package com.topdraw.business.basicdata.rights.history.service.impl;
import com.topdraw.business.basicdata.rights.history.domain.RightsHistory;
import com.topdraw.business.basicdata.rights.history.repository.RightsHistoryRepository;
import com.topdraw.business.basicdata.rights.history.service.RightsHistoryService;
import com.topdraw.business.basicdata.rights.history.service.dto.RightsHistoryDTO;
import com.topdraw.business.basicdata.rights.history.service.dto.RightsHistoryQueryCriteria;
import com.topdraw.business.basicdata.rights.history.service.mapper.RightsHistoryMapper;
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 RightsHistoryServiceImpl implements RightsHistoryService {
@Autowired
private RightsHistoryRepository RightsHistoryRepository;
@Autowired
private RightsHistoryMapper RightsHistoryMapper;
@Override
public Map<String, Object> queryAll(RightsHistoryQueryCriteria criteria, Pageable pageable) {
Page<RightsHistory> page = RightsHistoryRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
return PageUtil.toPage(page.map(RightsHistoryMapper::toDto));
}
@Override
public List<RightsHistoryDTO> queryAll(RightsHistoryQueryCriteria criteria) {
return RightsHistoryMapper.toDto(RightsHistoryRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
}
@Override
public RightsHistoryDTO findById(Long id) {
RightsHistory RightsHistory = RightsHistoryRepository.findById(id).orElseGet(RightsHistory::new);
ValidationUtil.isNull(RightsHistory.getId(),"RightsHistory","id",id);
return RightsHistoryMapper.toDto(RightsHistory);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void create(RightsHistory resources) {
RightsHistoryRepository.save(resources);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void update(RightsHistory resources) {
RightsHistory RightsHistory = RightsHistoryRepository.findById(resources.getId()).orElseGet(RightsHistory::new);
ValidationUtil.isNull( RightsHistory.getId(),"RightsHistory","id",resources.getId());
RightsHistory.copy(resources);
RightsHistoryRepository.save(RightsHistory);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void delete(Long id) {
Assert.notNull(id, "The given id must not be null!");
RightsHistory RightsHistory = RightsHistoryRepository.findById(id).orElseThrow(
() -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", RightsHistory.class, id), 1));
RightsHistoryRepository.delete(RightsHistory);
}
}
package com.topdraw.business.basicdata.rights.history.service.mapper;
import com.topdraw.base.BaseMapper;
import com.topdraw.business.basicdata.rights.history.domain.RightsHistory;
import com.topdraw.business.basicdata.rights.history.service.dto.RightsHistoryDTO;
import org.mapstruct.Mapper;
import org.mapstruct.ReportingPolicy;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface RightsHistoryMapper extends BaseMapper<RightsHistoryDTO, RightsHistory> {
}
package com.topdraw.business.basicdata.rights.permanentrights.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="uc_permanent_rights")
public class PermanentRights implements Serializable {
// ID
@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：vip；1：会员等级
@Column(name = "type")
private Integer type;
// 等级（当权益类型为vip时，对应vip值，当权益类型为会员等级时，对应等级index）
@Column(name = "level")
private Integer level;
// 商品折扣，10代表10% off，范围为0-100
@Column(name = "item_discount", nullable = false)
private BigDecimal itemDiscount;
// 额外积分比率，范围为0-1000
@Column(name = "extra_points", nullable = false)
private BigDecimal extraPoints;
// 免广告
@Column(name = "ad_disabled", nullable = false)
private Integer adDisabled;
// 额外活动参与机会
@Column(name = "extra_activity_ticket", nullable = false)
private Integer extraActivityTicket;
// 免费试看
@Column(name = "free_trial", nullable = false)
private Integer freeTrial;
// 上电视专区权益
@Column(name = "zone_sds", nullable = false)
private Integer zoneSds;
// 创建时间
@CreatedDate
@Column(name = "create_time")
private Timestamp createTime;
// 更新时间
@LastModifiedDate
@Column(name = "update_time")
private Timestamp updateTime;
public void copy(PermanentRights source){
BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
}
}
package com.topdraw.business.basicdata.rights.permanentrights.repository;
import com.topdraw.business.basicdata.rights.permanentrights.domain.PermanentRights;
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 PermanentRightsRepository extends JpaRepository<PermanentRights, Long>, JpaSpecificationExecutor<PermanentRights> {
Optional<PermanentRights> findFirstByCode(String code);
}
package com.topdraw.business.basicdata.rights.permanentrights.rest;
import com.topdraw.annotation.Log;
import com.topdraw.business.basicdata.rights.permanentrights.domain.PermanentRights;
import com.topdraw.business.basicdata.rights.permanentrights.service.PermanentRightsService;
import com.topdraw.business.basicdata.rights.permanentrights.service.dto.PermanentRightsQueryCriteria;
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 = "PermanentRights管理")
@RestController
@RequestMapping("/api/PermanentRights")
public class PermanentRightsController {
@Autowired
private PermanentRightsService PermanentRightsService;
@GetMapping
@ApiOperation("查询PermanentRights")
public ResultInfo pagePermanentRights(PermanentRightsQueryCriteria criteria, Pageable pageable) {
return ResultInfo.successPage(PermanentRightsService.queryAll(criteria,pageable));
}
@GetMapping(value = "/findById/{id}")
@ApiOperation("查询PermanentRights")
public ResultInfo findById(@PathVariable("id") Long id) {
return ResultInfo.success(PermanentRightsService.findById(id));
}
@Log
@PostMapping(value = "/create")
@ApiOperation("新增PermanentRights")
public ResultInfo create(@Validated @RequestBody PermanentRights resources) {
PermanentRightsService.create(resources);
return ResultInfo.success();
}
@Log
@PutMapping(value = "/update")
@ApiOperation("修改PermanentRights")
public ResultInfo update(@Validated @RequestBody PermanentRights resources) {
PermanentRightsService.update(resources);
return ResultInfo.success();
}
@Log
@DeleteMapping(value = "/delete/{id}")
@ApiOperation("删除PermanentRights")
public ResultInfo delete(@PathVariable Long id) {
PermanentRightsService.delete(id);
return ResultInfo.success();
}
@GetMapping(value = "/getByCode/{code}")
@ApiOperation(value = "根据标识查询")
public ResultInfo getByCode(@PathVariable String code) {
return ResultInfo.success(PermanentRightsService.getByCode(code));
}
}
package com.topdraw.business.basicdata.rights.permanentrights.service;
import com.topdraw.business.basicdata.rights.permanentrights.domain.PermanentRights;
import com.topdraw.business.basicdata.rights.permanentrights.service.dto.PermanentRightsDTO;
import com.topdraw.business.basicdata.rights.permanentrights.service.dto.PermanentRightsQueryCriteria;
import org.springframework.data.domain.Pageable;
import java.util.List;
import java.util.Map;
/**
* @author XiangHan
* @date 2021-10-22
*/
public interface PermanentRightsService {
/**
* 查询数据分页
* @param criteria 条件参数
* @param pageable 分页参数
* @return Map<String,Object>
*/
Map<String,Object> queryAll(PermanentRightsQueryCriteria criteria, Pageable pageable);
/**
* 查询所有数据不分页
* @param criteria 条件参数
* @return List<PermanentRightsDTO>
*/
List<PermanentRightsDTO> queryAll(PermanentRightsQueryCriteria criteria);
/**
* 根据ID查询
* @param id ID
* @return PermanentRightsDTO
*/
PermanentRightsDTO findById(Long id);
void create(PermanentRights resources);
void update(PermanentRights resources);
void delete(Long id);
/**
* Code校验
* @param code
* @return PermanentRightsDTO
*/
PermanentRightsDTO getByCode(String code);
}
package com.topdraw.business.basicdata.rights.permanentrights.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 PermanentRightsDTO implements Serializable {
// ID
private Long id;
// 标识
private String code;
// 名称
private String name;
// 永久权益类型 0：vip；1：会员等级
private Integer type;
// 等级（当权益类型为vip时，对应vip值，当权益类型为会员等级时，对应等级index）
private Integer level;
// 商品折扣，10代表10% off，范围为0-100
private BigDecimal itemDiscount;
// 额外积分比率，范围为0-1000
private BigDecimal extraPoints;
// 免广告
private Integer adDisabled;
// 额外活动参与机会
private Integer extraActivityTicket;
// 免费试看
private Integer freeTrial;
// 上电视专区权益
private Integer zoneSds;
// 创建时间
private Timestamp createTime;
// 更新时间
private Timestamp updateTime;
}
package com.topdraw.business.basicdata.rights.permanentrights.service.dto;
import com.topdraw.annotation.Query;
import lombok.Data;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class PermanentRightsQueryCriteria{
@Query(type = Query.Type.EQUAL)
private Integer level;
}
package com.topdraw.business.basicdata.rights.permanentrights.service.impl;
import com.topdraw.business.basicdata.rights.permanentrights.domain.PermanentRights;
import com.topdraw.business.basicdata.rights.permanentrights.repository.PermanentRightsRepository;
import com.topdraw.business.basicdata.rights.permanentrights.service.PermanentRightsService;
import com.topdraw.business.basicdata.rights.permanentrights.service.dto.PermanentRightsDTO;
import com.topdraw.business.basicdata.rights.permanentrights.service.dto.PermanentRightsQueryCriteria;
import com.topdraw.business.basicdata.rights.permanentrights.service.mapper.PermanentRightsMapper;
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 PermanentRightsServiceImpl implements PermanentRightsService {
@Autowired
private PermanentRightsRepository PermanentRightsRepository;
@Autowired
private PermanentRightsMapper PermanentRightsMapper;
@Override
public Map<String, Object> queryAll(PermanentRightsQueryCriteria criteria, Pageable pageable) {
Page<PermanentRights> page = PermanentRightsRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
return PageUtil.toPage(page.map(PermanentRightsMapper::toDto));
}
@Override
public List<PermanentRightsDTO> queryAll(PermanentRightsQueryCriteria criteria) {
return PermanentRightsMapper.toDto(PermanentRightsRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
}
@Override
public PermanentRightsDTO findById(Long id) {
PermanentRights PermanentRights = PermanentRightsRepository.findById(id).orElseGet(PermanentRights::new);
ValidationUtil.isNull(PermanentRights.getId(),"PermanentRights","id",id);
return PermanentRightsMapper.toDto(PermanentRights);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void create(PermanentRights resources) {
PermanentRightsRepository.save(resources);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void update(PermanentRights resources) {
PermanentRights PermanentRights = PermanentRightsRepository.findById(resources.getId()).orElseGet(PermanentRights::new);
ValidationUtil.isNull( PermanentRights.getId(),"PermanentRights","id",resources.getId());
PermanentRights.copy(resources);
PermanentRightsRepository.save(PermanentRights);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void delete(Long id) {
Assert.notNull(id, "The given id must not be null!");
PermanentRights PermanentRights = PermanentRightsRepository.findById(id).orElseThrow(
() -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", PermanentRights.class, id), 1));
PermanentRightsRepository.delete(PermanentRights);
}
@Override
public PermanentRightsDTO getByCode(String code) {
return StringUtils.isNotEmpty(code) ? PermanentRightsMapper.toDto(PermanentRightsRepository.findFirstByCode(code).orElseGet(PermanentRights::new))
: new PermanentRightsDTO();
}
}
package com.topdraw.business.basicdata.rights.permanentrights.service.mapper;
import com.topdraw.base.BaseMapper;
import com.topdraw.business.basicdata.rights.permanentrights.domain.PermanentRights;
import com.topdraw.business.basicdata.rights.permanentrights.service.dto.PermanentRightsDTO;
import org.mapstruct.Mapper;
import org.mapstruct.ReportingPolicy;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface PermanentRightsMapper extends BaseMapper<PermanentRightsDTO, PermanentRights> {
}
package com.topdraw.business.basicdata.rights.repository;
import com.topdraw.business.basicdata.rights.domain.Rights;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Query;
import java.util.List;
import java.util.Optional;
/**
* @author XiangHan
* @date 2021-10-22
*/
public interface RightsRepository extends JpaRepository<Rights, Long>, JpaSpecificationExecutor<Rights> {
Optional<Rights> findFirstByCode(String code);
@Query(value = "FROM Rights r WHERE r.id IN (?2)",nativeQuery = false)
List<Rights> findBatchByIds(Long[] ids);
}
package com.topdraw.business.basicdata.rights.rest;
import com.topdraw.business.basicdata.rights.service.RightsService;
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.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Api(tags = "Rights管理")
@RestController
@RequestMapping("/api/Rights")
public class RightsController {
@Autowired
private RightsService rightsService;
@GetMapping(value = "/findById/{id}")
@ApiOperation("查询Rights")
public ResultInfo findById(@PathVariable("id") Long id) {
return ResultInfo.success(rightsService.findById(id));
}
}
package com.topdraw.business.basicdata.rights.service;
import com.topdraw.business.basicdata.rights.domain.Rights;
import com.topdraw.business.basicdata.rights.service.dto.RightsDTO;
import com.topdraw.business.basicdata.rights.service.dto.RightsQueryCriteria;
import org.springframework.data.domain.Pageable;
import java.util.List;
import java.util.Map;
/**
* @author XiangHan
* @date 2021-10-22
*/
public interface RightsService {
/**
* 查询数据分页
* @param criteria 条件参数
* @param pageable 分页参数
* @return Map<String,Object>
*/
Map<String,Object> queryAll(RightsQueryCriteria criteria, Pageable pageable);
/**
* 查询所有数据不分页
* @param criteria 条件参数
* @return List<RightsDTO>
*/
List<RightsDTO> queryAll(RightsQueryCriteria criteria);
/**
* 根据ID查询
* @param id ID
* @return RightsDTO
*/
RightsDTO findById(Long id);
/**
* 批量查询
* @param ids
* @return
*/
List<RightsDTO> findBatchByIds(Long... ids);
void create(Rights resources);
void update(Rights resources);
void delete(Long id);
/**
* Code校验
* @param code
* @return RightsDTO
*/
RightsDTO getByCode(String code);
}
package com.topdraw.business.basicdata.rights.service.dto;
import lombok.Data;
import java.io.Serializable;
import java.sql.Timestamp;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class RightsDTO implements Serializable {
// 主键
private Long id;
// 标识
private String code;
// 权益名称
// private String name;
// 终端类型 0：大屏；1：微信小程序/公众号；2：App
private Integer deviceType;
// 类型 1：实体类 （预留字段）
private Integer type;
// 权益的实体类型 1：积分；2成长值；3优惠券
private String entityType;
// 实体id
private Long entityId;
// 生效时间，为null表示获取后立即生效，不为空时，表示特定的生效时间
private Timestamp validTime;
// 失效时间，空为不失效，否则为获得权益后直到失效的毫秒数
private Long expireTime;
// 创建时间
private Timestamp createTime;
// 更新时间
private Timestamp updateTime;
// 图片
private String image;
// 图片
private String images;
// 描述
private String description;
}
package com.topdraw.business.basicdata.rights.service.dto;
import com.topdraw.annotation.Query;
import lombok.Data;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class RightsQueryCriteria{
@Query
private Long memberId;
private RightsQueryType queryType;
}
package com.topdraw.business.basicdata.rights.service.dto;
public enum RightsQueryType {
// 全部
ALL,
// 可用
AVAILABLE_ONLY
}
package com.topdraw.business.basicdata.rights.service.impl;
import com.topdraw.business.basicdata.rights.domain.Rights;
import com.topdraw.business.basicdata.rights.repository.RightsRepository;
import com.topdraw.business.basicdata.rights.service.RightsService;
import com.topdraw.business.basicdata.rights.service.dto.RightsDTO;
import com.topdraw.business.basicdata.rights.service.dto.RightsQueryCriteria;
import com.topdraw.business.basicdata.rights.service.mapper.RightsMapper;
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 org.springframework.util.CollectionUtils;
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 RightsServiceImpl implements RightsService {
@Autowired
private RightsRepository RightsRepository;
@Autowired
private RightsMapper RightsMapper;
@Override
public Map<String, Object> queryAll(RightsQueryCriteria criteria, Pageable pageable) {
Page<Rights> page = RightsRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
return PageUtil.toPage(page.map(RightsMapper::toDto));
}
@Override
public List<RightsDTO> queryAll(RightsQueryCriteria criteria) {
return RightsMapper.toDto(RightsRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
}
@Override
public RightsDTO findById(Long id) {
Rights Rights = RightsRepository.findById(id).orElseGet(Rights::new);
ValidationUtil.isNull(Rights.getId(),"Rights","id",id);
return RightsMapper.toDto(Rights);
}
@Override
public List<RightsDTO> findBatchByIds(Long... ids) {
List<Rights> rightsList = this.RightsRepository.findBatchByIds(ids);
return !CollectionUtils.isEmpty(rightsList) ? RightsMapper.toDto(rightsList) : null;
}
@Override
@Transactional(rollbackFor = Exception.class)
public void create(Rights resources) {
RightsRepository.save(resources);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void update(Rights resources) {
Rights Rights = RightsRepository.findById(resources.getId()).orElseGet(Rights::new);
ValidationUtil.isNull( Rights.getId(),"Rights","id",resources.getId());
Rights.copy(resources);
RightsRepository.save(Rights);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void delete(Long id) {
Assert.notNull(id, "The given id must not be null!");
Rights Rights = RightsRepository.findById(id).orElseThrow(
() -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", Rights.class, id), 1));
RightsRepository.delete(Rights);
}
@Override
public RightsDTO getByCode(String code) {
return StringUtils.isNotEmpty(code) ? RightsMapper.toDto(RightsRepository.findFirstByCode(code).orElseGet(Rights::new))
: new RightsDTO();
}
}
package com.topdraw.business.basicdata.rights.service.mapper;
import com.topdraw.base.BaseMapper;
import com.topdraw.business.basicdata.rights.domain.Rights;
import com.topdraw.business.basicdata.rights.service.dto.RightsDTO;
import org.mapstruct.Mapper;
import org.mapstruct.ReportingPolicy;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface RightsMapper extends BaseMapper<RightsDTO, Rights> {
}
package com.topdraw.business.basicdata.task.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="tr_task")
public class Task implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
// 任务模板id
@Column(name = "task_template_id", nullable = false)
private Long taskTemplateId;
// 任务重复类型，-1：不限次；1：单次；>1：多次
@Column(name = "task_repeat_type", nullable = false)
private Integer taskRepeatType;
// 任务每日重置 0：不重置；1：重置
@Column(name = "task_daily_reset", nullable = false)
private Integer taskDailyReset;
// 行为量（完成此任务需要多少次相同行为的触发）
@Column(name = "action_amount", nullable = false)
private Integer actionAmount;
// 任务生效时间
@Column(name = "valid_time")
private Timestamp validTime;
// 任务失效时间
@Column(name = "expire_time")
private Timestamp expireTime;
// 显示顺序
@Column(name = "sequence")
private Integer sequence;
// 获得成长值
@Column(name = "reward_exp", nullable = false)
private Long rewardExp;
// 获得积分
@Column(name = "reward_points", nullable = false)
private Long rewardPoints;
// 积分过期时间（空为不过期）
@Column(name = "reward_points_expire_time")
private Long rewardPointsExpireTime;
// 积分获取类型 0：定值；1：随机
@Column(name = "points_type")
private Integer pointsType;
// 随机积分最大值
@Column(name = "reward_max_points")
private Integer rewardMaxPoints;
// 能够获取该任务的用户分组，为空则都能获取
@Column(name = "groups")
private String groups;
// 权益发放策略 0：立即发放；1：次日发放；2：次月发放
@Column(name = "rights_send_strategy", nullable = false)
private Integer rightsSendStrategy;
// 会员等级门槛（0表示无门槛）
@Column(name = "member_level", nullable = false)
private Integer memberLevel;
// 会员vip门槛（0表示没有门槛）
@Column(name = "member_vip")
private Integer memberVip;
// 权益id
@Column(name = "rights_id")
private Long rightsId;
// 权益数量（活动机会次数、优惠券数量、奖品数量）
@Column(name = "rights_amount")
private Integer rightsAmount;
// 权益2id
@Column(name = "rights2_id")
private Long rights2Id;
// 权益2数量
@Column(name = "rights2_amount")
private Integer rights2Amount;
// 权益3id
@Column(name = "rights3_id")
private Long rights3Id;
// 权益3数量
@Column(name = "rights3_amount")
private Integer rights3Amount;
// 状态 0：失效；1：生效
@Column(name = "status", nullable = false)
private Integer status;
// 创建时间
@CreatedDate
@Column(name = "create_time")
private Timestamp createTime;
// 更新时间
@LastModifiedDate
@Column(name = "update_time")
private Timestamp updateTime;
public void copy(Task source){
BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
}
}
package com.topdraw.business.basicdata.task.repository;
import com.topdraw.business.basicdata.task.domain.Task;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import java.util.List;
/**
* @author XiangHan
* @date 2021-10-22
*/
public interface TaskRepository extends JpaRepository<Task, Long>, JpaSpecificationExecutor<Task> {
List<Task> findByTaskTemplateId(Long taskTemplateId);
// List<Task> findByTemplateId(Long taskTemplateId);
}
package com.topdraw.business.basicdata.task.rest;
import com.topdraw.annotation.Log;
import com.topdraw.business.basicdata.task.domain.Task;
import com.topdraw.business.basicdata.task.service.TaskService;
import com.topdraw.business.basicdata.task.service.dto.TaskQueryCriteria;
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 = "Task管理")
@RestController
@RequestMapping("/api/Task")
public class TaskController {
@Autowired
private TaskService TaskService;
@GetMapping
@ApiOperation("查询Task")
public ResultInfo getTasks(TaskQueryCriteria criteria, Pageable pageable) {
return ResultInfo.successPage(TaskService.queryAll(criteria,pageable));
}
@GetMapping(value = "/all")
@ApiOperation("查询所有Task")
public ResultInfo getTasks(TaskQueryCriteria criteria) {
return ResultInfo.success(TaskService.queryAll(criteria));
}
@Log
@PostMapping
@ApiOperation("新增Task")
public ResultInfo create(@Validated @RequestBody Task resources) {
TaskService.create(resources);
return ResultInfo.success();
}
@Log
@PutMapping
@ApiOperation("修改Task")
public ResultInfo update(@Validated @RequestBody Task resources) {
TaskService.update(resources);
return ResultInfo.success();
}
@Log
@DeleteMapping(value = "/{id}")
@ApiOperation("删除Task")
public ResultInfo delete(@PathVariable Long id) {
TaskService.delete(id);
return ResultInfo.success();
}
}
package com.topdraw.business.basicdata.task.service;
import com.topdraw.business.basicdata.task.domain.Task;
import com.topdraw.business.basicdata.task.service.dto.TaskDTO;
import com.topdraw.business.basicdata.task.service.dto.TaskQueryCriteria;
import org.springframework.data.domain.Pageable;
import java.util.List;
import java.util.Map;
/**
* @author XiangHan
* @date 2021-10-22
*/
public interface TaskService {
/**
* 查询数据分页
* @param criteria 条件参数
* @param pageable 分页参数
* @return Map<String,Object>
*/
Map<String,Object> queryAll(TaskQueryCriteria criteria, Pageable pageable);
/**
* 查询所有数据不分页
* @param criteria 条件参数
* @return List<TaskDTO>
*/
List<TaskDTO> queryAll(TaskQueryCriteria criteria);
/**
* 根据ID查询
* @param id ID
* @return TaskDTO
*/
TaskDTO findById(Long id);
void create(Task resources);
void update(Task resources);
void delete(Long id);
List<Task> findByTemplateId(Long taskTemplateId);
}
package com.topdraw.business.basicdata.task.service.dto;
import lombok.Data;
import java.io.Serializable;
import java.sql.Timestamp;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class TaskDTO implements Serializable {
private Long id;
// 任务模板id
private Long taskTemplateId;
// 任务重复类型，-1：不限次；1：单次；>1：多次
private Integer taskRepeatType;
// 任务每日重置 0：不重置；1：重置
private Integer taskDailyReset;
// 行为量（完成此任务需要多少次相同行为的触发）
private Integer actionAmount;
// 任务生效时间
private Timestamp validTime;
// 任务失效时间
private Timestamp expireTime;
// 显示顺序
private Integer sequence;
// 获得成长值
private Long rewardExp;
// 获得积分
private Long rewardPoints;
// 积分过期时间（空为不过期）
private Long rewardPointsExpireTime;
// 能够获取该任务的用户分组，为空则都能获取
private String groups;
// 会员等级门槛（0表示无门槛）
private Integer memberLevel;
// 会员vip门槛（0表示没有门槛）
private Integer memberVip;
// 权益id
private Long rightsId;
// 权益数量（活动机会次数、优惠券数量、奖品数量）
private Integer rightsAmount;
// 权益2id
private Long rights2Id;
// 权益2数量
private Integer rights2Amount;
// 权益3id
private Long rights3Id;
// 权益3数量
private Integer rights3Amount;
// 状态 0：失效；1：生效
private Integer status;
// 创建时间
private Timestamp createTime;
// 更新时间
private Timestamp updateTime;
}
package com.topdraw.business.basicdata.task.service.dto;
import lombok.Data;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class TaskQueryCriteria{
}
package com.topdraw.business.basicdata.task.service.impl;
import com.topdraw.business.basicdata.task.domain.Task;
import com.topdraw.business.basicdata.task.repository.TaskRepository;
import com.topdraw.business.basicdata.task.service.TaskService;
import com.topdraw.business.basicdata.task.service.dto.TaskDTO;
import com.topdraw.business.basicdata.task.service.dto.TaskQueryCriteria;
import com.topdraw.business.basicdata.task.service.mapper.TaskMapper;
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;
import java.util.Objects;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Service
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
public class TaskServiceImpl implements TaskService {
@Autowired
private TaskRepository TaskRepository;
@Autowired
private TaskMapper TaskMapper;
@Override
public Map<String, Object> queryAll(TaskQueryCriteria criteria, Pageable pageable) {
Page<Task> page = TaskRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
return PageUtil.toPage(page.map(TaskMapper::toDto));
}
@Override
public List<TaskDTO> queryAll(TaskQueryCriteria criteria) {
return TaskMapper.toDto(TaskRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
}
@Override
public TaskDTO findById(Long id) {
Task Task = TaskRepository.findById(id).orElseGet(Task::new);
ValidationUtil.isNull(Task.getId(),"Task","id",id);
return TaskMapper.toDto(Task);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void create(Task resources) {
TaskRepository.save(resources);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void update(Task resources) {
Task Task = TaskRepository.findById(resources.getId()).orElseGet(Task::new);
ValidationUtil.isNull( Task.getId(),"Task","id",resources.getId());
Task.copy(resources);
TaskRepository.save(Task);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void delete(Long id) {
Assert.notNull(id, "The given id must not be null!");
Task Task = TaskRepository.findById(id).orElseThrow(
() -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", Task.class, id), 1));
TaskRepository.delete(Task);
}
@Override
public List<Task> findByTemplateId(Long taskTemplateId) {
return Objects.nonNull(taskTemplateId) ? this.TaskRepository.findByTaskTemplateId(taskTemplateId) : null;
}
}
package com.topdraw.business.basicdata.task.service.mapper;
import com.topdraw.base.BaseMapper;
import com.topdraw.business.basicdata.task.domain.Task;
import com.topdraw.business.basicdata.task.service.dto.TaskDTO;
import org.mapstruct.Mapper;
import org.mapstruct.ReportingPolicy;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface TaskMapper extends BaseMapper<TaskDTO, Task> {
}
package com.topdraw.business.basicdata.task.template.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="tr_task_template")
public class TaskTemplate implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
// 标识
@Column(name = "code")
private String code;
// 名称
@Column(name = "name")
private String name;
// 关注事件（和MQ topic相关）
@Column(name = "event")
private String event;
// 描述
@Column(name = "description")
private String description;
// 状态 0：失效；1：生效
@Column(name = "status")
private Integer status;
// 类型 0：活动任务模板
@Column(name = "type")
private Integer type;
// 模板参数，json
@Column(name = "params")
private String params;
@CreatedDate
@Column(name = "create_time")
private Timestamp createTime;
@LastModifiedDate
@Column(name = "update_time")
private Timestamp updateTime;
public void copy(TaskTemplate source){
BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
}
}
package com.topdraw.business.basicdata.task.template.repository;
import com.topdraw.business.basicdata.task.template.domain.TaskTemplate;
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 TaskTemplateRepository extends JpaRepository<TaskTemplate, Long>, JpaSpecificationExecutor<TaskTemplate> {
Optional<TaskTemplate> findFirstByCode(String code);
TaskTemplate findByEvent(String event);
}
package com.topdraw.business.basicdata.task.template.rest;
import com.topdraw.annotation.Log;
import com.topdraw.business.basicdata.task.template.domain.TaskTemplate;
import com.topdraw.business.basicdata.task.template.service.TaskTemplateService;
import com.topdraw.business.basicdata.task.template.service.dto.TaskTemplateQueryCriteria;
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 = "TaskTemplate管理")
@RestController
@RequestMapping("/api/TaskTemplate")
public class TaskTemplateController {
@Autowired
private TaskTemplateService TaskTemplateService;
@GetMapping
@ApiOperation("查询TaskTemplate")
public ResultInfo getTaskTemplates(TaskTemplateQueryCriteria criteria, Pageable pageable) {
return ResultInfo.successPage(TaskTemplateService.queryAll(criteria,pageable));
}
@GetMapping(value = "/all")
@ApiOperation("查询所有TaskTemplate")
public ResultInfo getTaskTemplates(TaskTemplateQueryCriteria criteria) {
return ResultInfo.success(TaskTemplateService.queryAll(criteria));
}
@Log
@PostMapping
@ApiOperation("新增TaskTemplate")
public ResultInfo create(@Validated @RequestBody TaskTemplate resources) {
TaskTemplateService.create(resources);
return ResultInfo.success();
}
@Log
@PutMapping
@ApiOperation("修改TaskTemplate")
public ResultInfo update(@Validated @RequestBody TaskTemplate resources) {
TaskTemplateService.update(resources);
return ResultInfo.success();
}
@Log
@DeleteMapping(value = "/{id}")
@ApiOperation("删除TaskTemplate")
public ResultInfo delete(@PathVariable Long id) {
TaskTemplateService.delete(id);
return ResultInfo.success();
}
@GetMapping(value = "/getByCode/{code}")
@ApiOperation(value = "根据标识查询")
public ResultInfo getByCode(@PathVariable String code) {
return ResultInfo.success(TaskTemplateService.getByCode(code));
}
}
package com.topdraw.business.basicdata.task.template.service;
import com.topdraw.business.basicdata.task.template.domain.TaskTemplate;
import com.topdraw.business.basicdata.task.template.service.dto.TaskTemplateDTO;
import com.topdraw.business.basicdata.task.template.service.dto.TaskTemplateQueryCriteria;
import org.springframework.data.domain.Pageable;
import java.util.List;
import java.util.Map;
/**
* @author XiangHan
* @date 2021-10-22
*/
public interface TaskTemplateService {
/**
* 查询数据分页
* @param criteria 条件参数
* @param pageable 分页参数
* @return Map<String,Object>
*/
Map<String,Object> queryAll(TaskTemplateQueryCriteria criteria, Pageable pageable);
/**
* 查询所有数据不分页
* @param criteria 条件参数
* @return List<TaskTemplateDTO>
*/
List<TaskTemplateDTO> queryAll(TaskTemplateQueryCriteria criteria);
/**
* 根据ID查询
* @param id ID
* @return TaskTemplateDTO
*/
TaskTemplateDTO findById(Long id);
void create(TaskTemplate resources);
void update(TaskTemplate resources);
void delete(Long id);
/**
* Code校验
* @param code
* @return TaskTemplateDTO
*/
TaskTemplateDTO getByCode(String code);
TaskTemplate findByEvent(String event);
}
package com.topdraw.business.basicdata.task.template.service.dto;
import lombok.Data;
import java.io.Serializable;
import java.sql.Timestamp;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class TaskTemplateDTO implements Serializable {
private Long id;
// 标识
private String code;
// 名称
private String name;
// 关注事件（和MQ topic相关）
private String event;
// 描述
private String description;
// 状态 0：失效；1：生效
private Integer status;
// 类型 0：活动任务模板
private Integer type;
// 模板参数，json
private String params;
private Timestamp createTime;
private Timestamp updateTime;
}
package com.topdraw.business.basicdata.task.template.service.dto;
import lombok.Data;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Data
public class TaskTemplateQueryCriteria{
}
package com.topdraw.business.basicdata.task.template.service.impl;
import com.topdraw.business.basicdata.task.template.domain.TaskTemplate;
import com.topdraw.business.basicdata.task.template.repository.TaskTemplateRepository;
import com.topdraw.business.basicdata.task.template.service.TaskTemplateService;
import com.topdraw.business.basicdata.task.template.service.dto.TaskTemplateDTO;
import com.topdraw.business.basicdata.task.template.service.dto.TaskTemplateQueryCriteria;
import com.topdraw.business.basicdata.task.template.service.mapper.TaskTemplateMapper;
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 TaskTemplateServiceImpl implements TaskTemplateService {
@Autowired
private TaskTemplateRepository TaskTemplateRepository;
@Autowired
private TaskTemplateMapper TaskTemplateMapper;
@Override
public Map<String, Object> queryAll(TaskTemplateQueryCriteria criteria, Pageable pageable) {
Page<TaskTemplate> page = TaskTemplateRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
return PageUtil.toPage(page.map(TaskTemplateMapper::toDto));
}
@Override
public List<TaskTemplateDTO> queryAll(TaskTemplateQueryCriteria criteria) {
return TaskTemplateMapper.toDto(TaskTemplateRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
}
@Override
public TaskTemplateDTO findById(Long id) {
TaskTemplate TaskTemplate = TaskTemplateRepository.findById(id).orElseGet(TaskTemplate::new);
ValidationUtil.isNull(TaskTemplate.getId(),"TaskTemplate","id",id);
return TaskTemplateMapper.toDto(TaskTemplate);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void create(TaskTemplate resources) {
TaskTemplateRepository.save(resources);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void update(TaskTemplate resources) {
TaskTemplate TaskTemplate = TaskTemplateRepository.findById(resources.getId()).orElseGet(TaskTemplate::new);
ValidationUtil.isNull( TaskTemplate.getId(),"TaskTemplate","id",resources.getId());
TaskTemplate.copy(resources);
TaskTemplateRepository.save(TaskTemplate);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void delete(Long id) {
Assert.notNull(id, "The given id must not be null!");
TaskTemplate TaskTemplate = TaskTemplateRepository.findById(id).orElseThrow(
() -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", TaskTemplate.class, id), 1));
TaskTemplateRepository.delete(TaskTemplate);
}
@Override
public TaskTemplateDTO getByCode(String code) {
return StringUtils.isNotEmpty(code) ? TaskTemplateMapper.toDto(TaskTemplateRepository.findFirstByCode(code).orElseGet(TaskTemplate::new))
: new TaskTemplateDTO();
}
@Override
public TaskTemplate findByEvent(String event) {
return StringUtils.isNotEmpty(event) ? this.TaskTemplateRepository.findByEvent(event) : null;
}
}
package com.topdraw.business.basicdata.task.template.service.mapper;
import com.topdraw.base.BaseMapper;
import com.topdraw.business.basicdata.task.template.domain.TaskTemplate;
import com.topdraw.business.basicdata.task.template.service.dto.TaskTemplateDTO;
import org.mapstruct.Mapper;
import org.mapstruct.ReportingPolicy;
/**
* @author XiangHan
* @date 2021-10-22
*/
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface TaskTemplateMapper extends BaseMapper<TaskTemplateDTO, TaskTemplate> {
}
package com.topdraw.config;
public class LocalConstants {
// 小屏侧
public static final String ENV_MOBILE = "mobile";
// 大屏侧
public static final String ENV_VIS = "vis";
// 大屏类型
public static final int DEVICE_VIS = 1;
// 小屏类型
public static final int DEVICE_MOBILE = 2;
}
package com.topdraw.config;
import cn.hutool.core.util.ObjectUtil;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
public class ServiceEnvConfig {
// uc两侧部署，需配置位于哪一侧 mobile小屏侧 vis大屏侧
public static String UC_SERVICE_TYPE;
@Value("${uc.service.type:mobile}")
public void setUcServiceType(String ucServiceType) {
UC_SERVICE_TYPE = ucServiceType;
}
public static boolean isMobile() {
return ObjectUtil.equals(UC_SERVICE_TYPE, LocalConstants.ENV_MOBILE);
}
public static boolean isVis() {
return ObjectUtil.equals(UC_SERVICE_TYPE, LocalConstants.ENV_VIS);
}
}
package com.topdraw.mq.config;
import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class RabbitMqConfig {
/** 路由(事件)--direct route.key*/
public static final String UC_ROUTE_KEY_DIRECT_EVENT_AAA = "uc.route.key.direct.event.aaa";
/** 队列-- */
public static final String UC_QUEUE_FANOUT_IPTV = "uc.fanout.iptv";
public static final String UC_QUEUE_FANOUT_WEIXIN = "uc.fanout.weixin";
/**
* 处理事件
* @return org.springframework.amqp.core.Queue
* @author XiangHan
* @date 2021/9/7 10:19 上午
*/
@Bean
public Queue eventDirect() {
return new Queue(UC_ROUTE_KEY_DIRECT_EVENT_AAA);
}
}
package com.topdraw.mq.consumer;
import com.topdraw.mq.domain.TableOperationMsg;
import com.topdraw.util.JSONUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;
import org.springframework.util.ClassUtils;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
@Component
@Slf4j
public class AutoRoute {
@Autowired
private ApplicationContext applicationContext;
public void route(TableOperationMsg tableOperationMsg) {
String interfaceName = tableOperationMsg.getInterfaceName();
try {
String methodName = tableOperationMsg.getMethodName();
ClassLoader defaultClassLoader = ClassUtils.getDefaultClassLoader();
log.info("AutoRoute -->>> route -->> " + defaultClassLoader);
Class<?> aClass = defaultClassLoader.loadClass(tableOperationMsg.getEntityName());
// Class<?> aClass = classLoader.loadClass(tableOperationMsg.getEntityName());
log.info("AutoRoute -->>> route -->> " + aClass);
Class<?> serviceImpl = Class.forName(interfaceName);
Method[] declaredMethods = serviceImpl.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
declaredMethod.setAccessible(true);
String name = declaredMethod.getName();
if (name.equalsIgnoreCase(methodName)) {
Class<?>[] parameterTypes = declaredMethod.getParameterTypes();
Class<?> parameterType = parameterTypes[0];
aClass = parameterType;
break;
} else {
continue;
}
}
String entityBody = tableOperationMsg.getEntityBody();
Object o = JSONUtil.parseMsg2Object(entityBody, aClass.getConstructor().newInstance().getClass());
Method method1 = serviceImpl.getDeclaredMethod(methodName, aClass);
method1.invoke(applicationContext.getBean(serviceImpl),o);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
}
}
package com.topdraw.mq.consumer;
import com.topdraw.config.ServiceEnvConfig;
import com.topdraw.mq.config.RabbitMqConfig;
import com.topdraw.mq.domain.DataSyncMsg;
import com.topdraw.mq.domain.TableOperationMsg;
import com.topdraw.util.JSONUtil;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
@Slf4j
public class MemberServiceConsumer {
private static final Logger LOG = LoggerFactory.getLogger(MemberServiceConsumer.class);
@Autowired
AutoRoute autoUser;
/**
* @param content
* @description 基础数据同步
* @author Hongyan Wang
* @date 2021/9/7 11:26 上午
*/
@RabbitHandler
@RabbitListener(queues = "#{memberServiceConsumer.platform()}")
public void memberServiceFanoutConsumer(String content) {
try {
log.info(" receive dataSync msg , content is : {} ", content);
TableOperationMsg dataSyncMsg = JSONUtil.parseMsg2Object(content, TableOperationMsg.class);
autoUser.route(dataSyncMsg);
LOG.info("memberServiceFanoutConsumer ====>>>> "+dataSyncMsg);
} catch (Exception e) {
log.error(" LocalDataSyncMsg || msg：{} || error：{} ", content, e.getMessage());
}
}
/**
* @return java.lang.String
* @description 根据环境获取队列名称
* @author Hongyan Wang
* @date 2021/9/8 4:00 下午
*/
public String platform() {
String platform = "";
if (ServiceEnvConfig.isMobile()) {
platform = RabbitMqConfig.UC_QUEUE_FANOUT_WEIXIN;
} else {
if (ServiceEnvConfig.isVis()) platform = RabbitMqConfig.UC_QUEUE_FANOUT_IPTV;
}
return platform;
}
}
package com.topdraw.mq.consumer;
import com.topdraw.mq.config.RabbitMqConfig;
import com.topdraw.mq.domain.DataSyncMsg;
import com.topdraw.resttemplate.RestTemplateClient;
import com.topdraw.util.JSONUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;
@Component
@Slf4j
public class UserCenterConsumer {
@Autowired
RestTemplateClient restTemplateClient;
/**
* 事件
* @param content
* @description 基础数据同步
* @author Hongyan Wang
* @date 2021/9/7 11:26 上午
*/
@RabbitHandler
@RabbitListener(queues = RabbitMqConfig.UC_ROUTE_KEY_DIRECT_EVENT_AAA)
public void ucEventConsumer(String content) {
log.info(" receive dataSync msg , content is : {} ", content);
DataSyncMsg dataSyncMsg = this.parseContent(content);
this.taskDeal(dataSyncMsg);
log.info("ucEventConsumer ====>>>> end");
}
/**
* 数据解析
* @param content
* @return
*/
private DataSyncMsg parseContent(String content) {
DataSyncMsg dataSyncMsg = JSONUtil.parseMsg2Object(content,DataSyncMsg.class);
Assert.notNull(dataSyncMsg,"ERROR -->> operationConsumer -->> parseContent -->> 【dataSyncMsg】 not be null !!");
DataSyncMsg.MsgData msgData = dataSyncMsg.getMsg();
Assert.notNull(msgData,"ERROR -->> operationConsumer -->> parseContent -->> 【msgData】 not be null !!");
return dataSyncMsg;
}
/**
* 任务处理
* @param dataSyncMsg
*/
private void taskDeal(DataSyncMsg dataSyncMsg) {
this.restTemplateClient.dealTask(dataSyncMsg);
}
}
package com.topdraw.mq.domain;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.validation.constraints.NotNull;
import java.io.Serializable;
/**
*
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class DataSyncMsg implements Serializable {
// 实体类型(表示需要修改的数据模型)
// @NotNull
// private EntityType entityType;
// 事件类型(用户的实际操作)
@NotNull
private String eventType;
// 消息体
private MsgData msg;
// 其他属性
private String extraData;
/**
* 消息体
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public static class MsgData {
private String remarks; //备注
@NotNull
private Integer event; // 具体事件 行为事件类型 1：登录；2：观影；3：参与活动；4：订购；10：跨屏绑定；11：积分转移；30：积分兑换商品；98：系统操作；99：其他
@NotNull
private Long memberId; // 会员id
@NotNull
private Integer deviceType; //设备类型 1：大屏；2：小屏（微信）3.小屏（xx）
@NotNull
private String appCode; //用户对应的应用code
private Long accountId; // 账号id
private Long orderId;
private Long activityId;
private Long mediaId;
private Long itemId;
}
}
package com.topdraw.mq.domain;
import lombok.Getter;
// 实体类型
@Getter
public enum EntityType {
// 用户
PERSON,
// 会员
MEMBER,
// 小屏-微信
WEIXIN_USER,
// 大屏
VIS_USER,
// 地址
PERSON_ADDRESS
}
package com.topdraw.mq.domain;
// 关注的事件
public enum EventType {
// 关注
SUBSCRIBE,
// 取消关注
UN_SUBSCRIBE,
// 绑定
BIND,
// 取消绑定
UN_BIND,
// 变更主账号
C_M_ACCOUNT,
// 获取积分
GAIN_POINT,
// 消耗积分
CONSUME_POINT,
// 观影
VIEWING
}
package com.topdraw.mq.domain;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
*
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class TableOperationMsg {
// 数据表操作类型
private TableOperationType tableOperationType;
// 模型名称
private String entityName;
// 消息体
private String entityBody;
private String interfaceName;
private String methodName;
}
package com.topdraw.mq.domain;
// 数据表操作类型
public enum TableOperationType {
// 新增
ADD,INSERT,DOADD,DOINSERT,
// 修改
UPDATE,DOUPDATE,
// 删除
DELETE,DODELETE
}
package com.topdraw.resttemplate;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.topdraw.business.basicdata.member.address.domain.MemberAddress;
import com.topdraw.business.basicdata.member.domain.Member;
import com.topdraw.business.basicdata.member.relatedinfo.domain.MemberRelatedInfo;
import com.topdraw.mq.domain.DataSyncMsg;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.http.ResponseEntity;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;
import javax.annotation.PostConstruct;
import java.util.HashMap;
import java.util.Map;
@Slf4j
@Component
public class RestTemplateClient {
private static RestTemplate restTemplate;
private static String BASE_URL;
@Autowired
private Environment environment;
@PostConstruct
private void init() {
BASE_URL = environment.getProperty("api.baseUrl");
SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
// 设置连接超时
factory.setConnectTimeout(5000);
// 设置读取超时
factory.setReadTimeout(8000);
restTemplate = new RestTemplate(factory);
}
public JSONObject dealTask(DataSyncMsg dataSyncMsg) {
JSONObject resultSet = null;
String url = BASE_URL + "/api/TaskOperation/dealTask";
log.info("request uc : url is " + url + ", dataSyncMsg is " + dataSyncMsg);
String content = JSON.toJSONString(dataSyncMsg);
HashMap<Object, Object> objectObjectHashMap = new HashMap<>();
objectObjectHashMap.put("content", content);
restTemplate.postForEntity(url, objectObjectHashMap, String.class);
/* ResponseEntity<String> responseEntity = restTemplate.postForEntity(url, objectObjectHashMap, String.class);
if (responseEntity.getStatusCode().is2xxSuccessful()) {
String entityBody = responseEntity.getBody();
JSONObject jsonObject = JSONObject.parseObject(entityBody);
if (jsonObject.getInteger("businessCode").equals(200)) {
resultSet = jsonObject.getJSONArray("resultSet").getJSONObject(0);
}
}
log.info("uc response: " + resultSet.toJSONString());
return resultSet;*/
return null;
}
public JSONObject getMemberInfo(Long memberId) {
JSONObject resultSet = null;
String url = BASE_URL + "/api/member/findById/" + memberId;
log.info("request uc : url is " + url + ", memberId is " + memberId);
ResponseEntity<String> responseEntity = restTemplate.getForEntity(url, String.class);
if (responseEntity.getStatusCode().is2xxSuccessful()) {
String entityBody = responseEntity.getBody();
JSONObject jsonObject = JSONObject.parseObject(entityBody);
if (jsonObject.getInteger("businessCode").equals(200)) {
resultSet = jsonObject.getJSONArray("resultSet").getJSONObject(0);
}
}
log.info("uc response: " + resultSet.toJSONString());
return resultSet;
}
public String createMember(Member member) {
String entityBody = "";
String url = BASE_URL + "/api/member/create";
log.info("request uc : url is " + url + ", memberId is " + JSONObject.toJSONString(member));
ResponseEntity<String> responseEntity = restTemplate.postForEntity(url, member, String.class);
if (responseEntity.getStatusCode().is2xxSuccessful()) {
entityBody = responseEntity.getBody();
}
return entityBody;
}
public String updateMember(Member member) {
String entityBody = "";
String url = BASE_URL + "/api/member/update";
log.info("request uc : url is " + url + ", memberId is " + JSONObject.toJSONString(member));
restTemplate.put(url, member);
return entityBody;
}
public String createMemberAddress(MemberAddress member) {
JSONObject resultSet = null;
String url = BASE_URL + "/api/MemberAddress/create";
log.info("request uc : url is " + url + ", memberId is " + JSONObject.toJSONString(member));
ResponseEntity<String> responseEntity = restTemplate.postForEntity(url, member, String.class);
String entityBody = "";
if (responseEntity.getStatusCode().is2xxSuccessful()) {
entityBody = responseEntity.getBody();
}
log.info("uc response: " + entityBody);
return entityBody;
}
public void updateMemberAddress(MemberAddress member) {
String url = BASE_URL + "/api/MemberAddress/update";
log.info("request uc : url is " + url + ", memberId is " + JSONObject.toJSONString(member));
restTemplate.put(url, member);
}
public void deleteMemberAddress(Long id) {
String url = BASE_URL + "/api/MemberAddress/delete/" + id;
log.info("request uc : url is " + url + ", memberId is " + id);
restTemplate.delete(url);
}
public JSONObject getMemberProfile(Long memberId) {
JSONObject resultSet = null;
String url = BASE_URL + "/api/MemberRelatedInfo/getMemberRelatedInfos";
log.info("request uc : url is " + url + ", memberId is " + memberId);
ResponseEntity<String> responseEntity = restTemplate.getForEntity(url, String.class);
if (responseEntity.getStatusCode().is2xxSuccessful()) {
String entityBody = responseEntity.getBody();
JSONObject jsonObject = JSONObject.parseObject(entityBody);
if (jsonObject.getInteger("businessCode").equals(200)) {
resultSet = jsonObject.getJSONArray("resultSet").getJSONObject(0);
}
}
log.info("uc response: " + resultSet.toJSONString());
return resultSet;
}
public String getMemberAddress(Map<String, Object> param) {
String entityBody = "";
String url = BASE_URL + "/api/MemberAddress/pageMemberAddress?page=" + param.get("page") + "&size=" + param.get("size") + "&memberId=" + param.get("memberId");
log.info("request uc : url is " + url + ", param is " + param);
ResponseEntity<String> responseEntity = restTemplate.getForEntity(url, String.class);
if (responseEntity.getStatusCode().is2xxSuccessful()) {
entityBody = responseEntity.getBody();
}
log.info("uc response: " + entityBody);
return entityBody;
}
public String getMemberRelatedInfo(Map<String, Object> param) {
String entityBody = "";
String url = BASE_URL + "/api/MemberRelatedInfo/pageMemberRelatedInfos?page=" + param.get("page") + "&size=" + param.get("size") + "&memberId=" + param.get("memberId");
log.info("request uc : url is " + url + ", memberId is " + param);
ResponseEntity<String> responseEntity = restTemplate.getForEntity(url, String.class);
if (responseEntity.getStatusCode().is2xxSuccessful()) {
entityBody = responseEntity.getBody();
}
log.info("uc response: " + entityBody);
return entityBody;
}
public void deleteMemberRelatedInfo(Long memberRelatedId) {
String url = BASE_URL + "/api/MemberRelatedInfo/delete/" + memberRelatedId;
log.info("request uc : url is " + url + ", memberId is " + memberRelatedId);
restTemplate.delete(url, String.class);
}
public String addMemberRelatedInfo(MemberRelatedInfo resources) {
String entityBody = null;
String url = BASE_URL + "/api/MemberRelatedInfo/create";
log.info("request uc : url is " + url + ", memberRelatedId is " + JSONObject.toJSONString(resources));
ResponseEntity<String> responseEntity = restTemplate.postForEntity(url, resources, String.class);
if (responseEntity.getStatusCode().is2xxSuccessful()) {
entityBody = responseEntity.getBody();
// JSONObject jsonObject = JSONObject.parseObject(entityBody);
// if (jsonObject.getInteger("businessCode").equals(200)) {
// resultSet = jsonObject.getJSONArray("resultSet").getJSONObject(0);
// }
}
log.info("uc response: " + entityBody);
return entityBody;
}
public String updateMemberRelatedInfo(MemberRelatedInfo resources) {
String resultSet = "";
String url = BASE_URL + "/api/MemberRelatedInfo/update";
log.info("request uc : url is " + url + ", memberRelatedId is " + JSONObject.toJSONString(resources));
restTemplate.put(url, resources);
return resultSet;
}
}
package com.topdraw.util;
import java.util.Date;
public class DateUtil {
public static Date newDate(){
return new Date();
}
public static long currentTimestamp(){
return System.currentTimeMillis();
}
}
package com.topdraw.util;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.management.ManagementFactory;
import java.net.InetAddress;
import java.net.NetworkInterface;
/**
* 生成订单ID, 雪花算法代码实现
*/
public class IdWorker {
private static final Logger LOG = LoggerFactory.getLogger(IdWorker.class.getName());
// 时间起始标记点，作为基准，一般取系统的最近时间（一旦确定不能变动）
private final static long twepoch = 1288834974657L;
// 机器标识位数
private final static long workerIdBits = 5L;
// 数据中心标识位数
private final static long datacenterIdBits = 5L;
// 机器ID最大值
private final static long maxWorkerId = -1L ^ (-1L << workerIdBits);
// 数据中心ID最大值
private final static long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
// 毫秒内自增位
private final static long sequenceBits = 12L;
// 机器ID偏左移12位
private final static long workerIdShift = sequenceBits;
// 数据中心ID左移17位
private final static long datacenterIdShift = sequenceBits + workerIdBits;
// 时间毫秒左移22位
private final static long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
private final static long sequenceMask = -1L ^ (-1L << sequenceBits);
/* 上次生产id时间戳 */
private static long lastTimestamp = -1L;
// 0，并发控制
private long sequence = 0L;
private final long workerId;
// 数据标识id部分
private final long datacenterId;
public IdWorker(){
this.datacenterId = getDatacenterId(maxDatacenterId);
this.workerId = getMaxWorkerId(datacenterId, maxWorkerId);
}
/**
* @param workerId 工作机器ID
* @param datacenterId 序列号
*/
public IdWorker(long workerId, long datacenterId) {
if (workerId > maxWorkerId || workerId < 0) {
throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0", maxWorkerId));
}
if (datacenterId > maxDatacenterId || datacenterId < 0) {
throw new IllegalArgumentException(String.format("datacenter Id can't be greater than %d or less than 0", maxDatacenterId));
}
this.workerId = workerId;
this.datacenterId = datacenterId;
}
/**
* 获取下一个ID
* @return
*/
public synchronized long nextId() {
long timestamp = timeGen();
if (timestamp < lastTimestamp) {
throw new RuntimeException(String.format("Clock moved backwards. Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
}
if (lastTimestamp == timestamp) {
// 当前毫秒内，则+1
sequence = (sequence + 1) & sequenceMask;
if (sequence == 0) {
// 当前毫秒内计数满了，则等待下一秒
timestamp = tilNextMillis(lastTimestamp);
}
} else {
sequence = 0L;
}
lastTimestamp = timestamp;
// ID偏移组合生成最终的ID，并返回ID
long nextId = ((timestamp - twepoch) << timestampLeftShift)
| (datacenterId << datacenterIdShift)
| (workerId << workerIdShift) | sequence;
return nextId;
}
private long tilNextMillis(final long lastTimestamp) {
long timestamp = this.timeGen();
while (timestamp <= lastTimestamp) {
timestamp = this.timeGen();
}
return timestamp;
}
private long timeGen() {
return System.currentTimeMillis();
}
/**
* 获取 maxWorkerId
*/
protected static long getMaxWorkerId(long datacenterId, long maxWorkerId) {
StringBuffer mpid = new StringBuffer();
mpid.append(datacenterId);
String name = ManagementFactory.getRuntimeMXBean().getName();
if (!name.isEmpty()) {
/*
* GET jvmPid
*/
mpid.append(name.split("@")[0]);
}
/*
* MAC + PID 的 hashcode 获取16个低位
*/
return (mpid.toString().hashCode() & 0xffff) % (maxWorkerId + 1);
}
/**
* 数据标识id部分
*/
protected static long getDatacenterId(long maxDatacenterId) {
long id = 0L;
try {
InetAddress ip = InetAddress.getLocalHost();
NetworkInterface network = NetworkInterface.getByInetAddress(ip);
if (network == null) {
id = 1L;
} else {
byte[] mac = network.getHardwareAddress();
if (null == mac) {
return 1L;
}
id = ((0x000000FF & (long) mac[mac.length - 1])
| (0x0000FF00 & (((long) mac[mac.length - 2]) << 8))) >> 6;
id = id % (maxDatacenterId + 1);
}
} catch (Exception e) {
LOG.warn(" getDatacenterId: " + e.getMessage());
}
return id;
}
public static long generator(){
IdWorker idWorker = new IdWorker();
return idWorker.nextId();
}
public static void main(String[] args) {
IdWorker idWorker = new IdWorker();
System.out.println(idWorker.nextId());
}
}
package com.topdraw.util;
import com.alibaba.fastjson.JSON;
public class JSONUtil<T> {
public static <T> T parseMsg2Object(String content , Class<T> clazz) {
T t = JSON.parseObject(content, clazz);
return t;
}
}
package com.topdraw.util;
import java.util.Random;
public class RandomUtil {
/**
* 获取随机积分
* @param max
* @param min
* @return
*/
public static long getRandomPoints(Integer min,Integer max) {
Random random = new Random();
int s = random.nextInt(max)%(max-min+1) + min;
return s;
}
public static void main(String[] args) {
for (int i=0;i<30;i++) {
long randomPoints = getRandomPoints(1, 10);
System.out.println(randomPoints);
}
}
}
package com.topdraw.util;
import java.sql.Timestamp;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
public class TimestampUtil {
public static Timestamp now(){
return new Timestamp(System.currentTimeMillis());
}
public static Timestamp now(LocalDateTime localDateTime) {
long epochSecond = localDateTime.toInstant(ZoneOffset.of("+8")).getEpochSecond();
return new Timestamp(epochSecond);
}
public static long localDateTime2Timestamp(LocalDateTime localDateTime){
long epochSecond = localDateTime.atZone(ZoneOffset.systemDefault()).toEpochSecond();
return epochSecond;
}
public static Timestamp long2Timestamp(long timestamp){
Timestamp timestamp1 = Timestamp.from(Instant.ofEpochSecond(timestamp));
return timestamp1;
}
public static long Timestamp2long(Timestamp timestamp){
return timestamp.toInstant().getEpochSecond();
}
public static void main(String[] args) {
LocalDateTime of = LocalDateTime.of(2021, 10, 28, 11, 00, 00);
long l = localDateTime2Timestamp(of);
Timestamp timestamp = long2Timestamp(l);
System.out.println(timestamp.toString());
}
}
___________ .___
\__ ___/___ ______ __| _/___________ __ _ __
| | / _ \\____ \ / __ |\_ __ \__ \\ \/ \/ /
| |( <_> ) |_> > /_/ | | | \// __ \\ /
|____| \____/| __/\____ | |__| (____ /\/\_/
|__| \/ \/
:: UserCenter :: Spring Boot - ${spring-boot.version}
#配置数据源
spring:
datasource:
# 测试/演示库
#url: jdbc:log4jdbc:mysql://139.196.37.202:3306/tj_user_0819?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false
#username: root
#password: Topdraw1qaz
url: jdbc:log4jdbc:mysql://122.112.214.149:3306/tj_user?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false
username: root
password: root
driverClassName: net.sf.log4jdbc.sql.jdbcapi.DriverSpy
# driverClassName: com.mysql.jdbc.Driver
#Druid
type: com.alibaba.druid.pool.DruidDataSource
druid:
# 初始化配置
initial-size: 3
# 最小连接数
min-idle: 3
# 最大连接数
max-active: 15
# 获取连接超时时间
max-wait: 5000
# 连接有效性检测时间
time-between-eviction-runs-millis: 90000
# 最大空闲时间
min-evictable-idle-time-millis: 1800000
test-while-idle: true
test-on-borrow: false
test-on-return: false
validation-query: select 1
# 配置监控统计拦截的filters
filters: stat
stat-view-servlet:
url-pattern: /druid/*
reset-enable: false
web-stat-filter:
url-pattern: /*
exclusions: "*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*"
#配置 Jpa
jpa:
hibernate:
# 生产环境设置成 none，避免程序运行时自动更新数据库结构
ddl-auto: none
servlet:
multipart:
file-size-threshold: 2KB
max-file-size: 100MB
max-request-size: 200MB
redis:
#数据库索引
database: 6
host: 127.0.0.1
port: 6379
password:
#连接超时时间
timeout: 5000
rabbitmq:
host: 122.112.214.149 # rabbitmq的连接地址
#host: 139.196.192.242 # rabbitmq的连接地址
port: 5672 # rabbitmq的连接端口号
#virtual-host: /member_center # rabbitmq的虚拟host
#username: member_center # rabbitmq的用户名
#password: Tjlh@2021 # rabbitmq的密码
virtual-host: / # rabbitmq的虚拟host
username: guest # rabbitmq的用户名
password: guest # rabbitmq的密码
publisher-confirms: true #如果对异步消息需要回调必须设置为true
#jwt。依赖的common中有需要jwt的部分属性。
jwt:
header: Authorization
secret: mySecret
# token 过期时间/毫秒，6小时 1小时 = 3600000 毫秒
expiration: 7200000
# 在线用户key
online: online-token
# 验证码
codeKey: code-key
# token 续期检查时间范围（60分钟，单位毫秒），在token即将过期的一段时间内用户操作了，则给用户的token续期
detect: 3600000
# 续期时间，2小时，单位毫秒
renew: 7200000
#是否允许生成代码，生产环境设置为false
generator:
enabled: true
#是否开启 swagger-ui
swagger:
enabled: true
# 文件存储路径(相对路径)
file:
path: system/file
avatar: system/avatar
upload: upload
# 文件大小 /M
maxSize: 100
avatarMaxSize: 5
uc:
service:
# uc两侧部署，需配置位于哪一侧 mobile小屏侧 vis大屏侧
type: mobile
api:
# baseUrl: http://139.196.4.234:8447
baseUrl: http://localhost:8447
#配置数据源
spring:
datasource:
# 测试/演示库
#url: jdbc:log4jdbc:mysql://139.196.37.202:3306/tj_user_0819?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false
#username: root
#password: Topdraw1qaz
url: jdbc:log4jdbc:mysql://122.112.214.149:3306/tj_user?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false
username: root
password: root
driverClassName: net.sf.log4jdbc.sql.jdbcapi.DriverSpy
# driverClassName: com.mysql.jdbc.Driver
#Druid
type: com.alibaba.druid.pool.DruidDataSource
druid:
# 初始化配置
initial-size: 3
# 最小连接数
min-idle: 3
# 最大连接数
max-active: 15
# 获取连接超时时间
max-wait: 5000
# 连接有效性检测时间
time-between-eviction-runs-millis: 90000
# 最大空闲时间
min-evictable-idle-time-millis: 1800000
test-while-idle: true
test-on-borrow: false
test-on-return: false
validation-query: select 1
# 配置监控统计拦截的filters
filters: stat
stat-view-servlet:
url-pattern: /druid/*
reset-enable: false
web-stat-filter:
url-pattern: /*
exclusions: "*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*"
#配置 Jpa
jpa:
hibernate:
# 生产环境设置成 none，避免程序运行时自动更新数据库结构
ddl-auto: none
servlet:
multipart:
file-size-threshold: 2KB
max-file-size: 100MB
max-request-size: 200MB
redis:
#数据库索引
database: 6
host: 127.0.0.1
port: 6379
password:
#连接超时时间
timeout: 5000
rabbitmq:
host: 122.112.214.149 # rabbitmq的连接地址
#host: 139.196.192.242 # rabbitmq的连接地址
port: 5672 # rabbitmq的连接端口号
#virtual-host: /member_center # rabbitmq的虚拟host
#username: member_center # rabbitmq的用户名
#password: Tjlh@2021 # rabbitmq的密码
virtual-host: / # rabbitmq的虚拟host
username: guest # rabbitmq的用户名
password: guest # rabbitmq的密码
publisher-confirms: true #如果对异步消息需要回调必须设置为true
#jwt。依赖的common中有需要jwt的部分属性。
jwt:
header: Authorization
secret: mySecret
# token 过期时间/毫秒，6小时 1小时 = 3600000 毫秒
expiration: 7200000
# 在线用户key
online: online-token
# 验证码
codeKey: code-key
# token 续期检查时间范围（60分钟，单位毫秒），在token即将过期的一段时间内用户操作了，则给用户的token续期
detect: 3600000
# 续期时间，2小时，单位毫秒
renew: 7200000
#是否允许生成代码，生产环境设置为false
generator:
enabled: true
#是否开启 swagger-ui
swagger:
enabled: true
# 文件存储路径(相对路径)
file:
path: system/file
avatar: system/avatar
upload: upload
# 文件大小 /M
maxSize: 100
avatarMaxSize: 5
uc:
service:
# uc两侧部署，需配置位于哪一侧 mobile小屏侧 vis大屏侧
type: mobile
api:
# baseUrl: http://139.196.4.234:8447
baseUrl: http://localhost:8447
#配置数据源
spring:
datasource:
# 测试/演示库
#url: jdbc:log4jdbc:mysql://139.196.37.202:3306/tj_user_0819?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false
#username: root
#password: Topdraw1qaz
url: jdbc:log4jdbc:mysql://122.112.214.149:3306/tj_user?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false
username: root
password: root
driverClassName: net.sf.log4jdbc.sql.jdbcapi.DriverSpy
# driverClassName: com.mysql.jdbc.Driver
#Druid
type: com.alibaba.druid.pool.DruidDataSource
druid:
# 初始化配置
initial-size: 3
# 最小连接数
min-idle: 3
# 最大连接数
max-active: 15
# 获取连接超时时间
max-wait: 5000
# 连接有效性检测时间
time-between-eviction-runs-millis: 90000
# 最大空闲时间
min-evictable-idle-time-millis: 1800000
test-while-idle: true
test-on-borrow: false
test-on-return: false
validation-query: select 1
# 配置监控统计拦截的filters
filters: stat
stat-view-servlet:
url-pattern: /druid/*
reset-enable: false
web-stat-filter:
url-pattern: /*
exclusions: "*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*"
#配置 Jpa
jpa:
hibernate:
# 生产环境设置成 none，避免程序运行时自动更新数据库结构
ddl-auto: none
servlet:
multipart:
file-size-threshold: 2KB
max-file-size: 100MB
max-request-size: 200MB
redis:
#数据库索引
database: 6
host: 127.0.0.1
port: 6379
password:
#连接超时时间
timeout: 5000
rabbitmq:
host: 122.112.214.149 # rabbitmq的连接地址
#host: 139.196.192.242 # rabbitmq的连接地址
port: 5672 # rabbitmq的连接端口号
#virtual-host: /member_center # rabbitmq的虚拟host
#username: member_center # rabbitmq的用户名
#password: Tjlh@2021 # rabbitmq的密码
virtual-host: / # rabbitmq的虚拟host
username: guest # rabbitmq的用户名
password: guest # rabbitmq的密码
publisher-confirms: true #如果对异步消息需要回调必须设置为true
#jwt。依赖的common中有需要jwt的部分属性。
jwt:
header: Authorization
secret: mySecret
# token 过期时间/毫秒，6小时 1小时 = 3600000 毫秒
expiration: 7200000
# 在线用户key
online: online-token
# 验证码
codeKey: code-key
# token 续期检查时间范围（60分钟，单位毫秒），在token即将过期的一段时间内用户操作了，则给用户的token续期
detect: 3600000
# 续期时间，2小时，单位毫秒
renew: 7200000
#是否允许生成代码，生产环境设置为false
generator:
enabled: true
#是否开启 swagger-ui
swagger:
enabled: true
# 文件存储路径(相对路径)
file:
path: system/file
avatar: system/avatar
upload: upload
# 文件大小 /M
maxSize: 100
avatarMaxSize: 5
uc:
service:
# uc两侧部署，需配置位于哪一侧 mobile小屏侧 vis大屏侧
type: mobile
api:
# baseUrl: http://139.196.4.234:8447
baseUrl: http://localhost:8447
server:
port: 8449
spring:
application:
name: member-engine
freemarker:
check-template-location: false
profiles:
active: dev
jackson:
time-zone: GMT+8
data:
redis:
repositories:
enabled: false
#配置 Jpa
jpa:
properties:
hibernate:
dialect: org.hibernate.dialect.MySQL5InnoDBDialect
open-in-view: true
task:
pool:
# 核心线程池大小
core-pool-size: 10
# 最大线程数
max-pool-size: 30
# 活跃时间
keep-alive-seconds: 60
# 队列容量
queue-capacity: 50
#登录图形验证码有效时间/分钟
loginCode:
expiration: 2
#默认上传图片类型
default-image-type: -1
#数据库类型转Java类型
tinyint=Integer
smallint=Integer
mediumint=Integer
int=Integer
integer=Integer
bigint=Long
float=Float
double=Double
decimal=BigDecimal
bit=Boolean
char=String
varchar=String
tinytext=String
text=String
mediumtext=String
longtext=String
date=Timestamp
datetime=Timestamp
timestamp=Timestamp
# If you use SLF4J. First, you need to tell log4jdbc-log4j2 that you want to use the SLF4J logger
log4jdbc.spylogdelegator.name=net.sf.log4jdbc.log.slf4j.Slf4jSpyLogDelegator
log4jdbc.auto.load.popular.drivers=false
log4jdbc.drivers=com.mysql.cj.jdbc.Driver
\ No newline at end of file
<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true" scanPeriod="60 seconds" debug="false">
<contextName>UserCenter</contextName>
<!--定义参数,后面可以通过${app.name}使用-->
<property name="app.name" value="member-engine"/>
<property name="log.path" value="./logs"/>
<property name="log.pattern" value="%d [%thread] %-5level %logger{36} [%file : %line] - %msg%n"/>
<!--输出到控制台-->
<appender name="console" class="ch.qos.logback.core.ConsoleAppender">
<!-- encoder 默认配置为PatternLayoutEncoder -->
<!--定义控制台输出格式-->
<encoder>
<pattern>%black(%contextName-) %red(%d{yyyy-MM-dd HH:mm:ss}) %green([%thread]) %highlight(%-5level) %boldMagenta(%logger{36}) - %msg %n</pattern>
<charset>utf-8</charset>
</encoder>
</appender>
<!--获取比info级别高(包括info级别)但除error级别的日志-->
<appender name="info" class="ch.qos.logback.core.rolling.RollingFileAppender">
<filter class="ch.qos.logback.classic.filter.LevelFilter">
<level>ERROR</level>
<onMatch>DENY</onMatch>
<onMismatch>ACCEPT</onMismatch>
</filter>
<encoder>
<pattern>${log.pattern}</pattern>
</encoder>
<!--滚动策略-->
<file>${log.path}/${app.name}-info.log</file>
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!--路径-->
<fileNamePattern>${log.path}/info/${app.name}-%d{yyyy-MM-dd}.log</fileNamePattern>
<maxHistory>30</maxHistory>
<totalSizeCap>10GB</totalSizeCap>
</rollingPolicy>
</appender>
<appender name="error" class="ch.qos.logback.core.rolling.RollingFileAppender">
<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
<level>ERROR</level>
</filter>
<encoder>
<pattern>${log.pattern}</pattern>
</encoder>
<!--滚动策略-->
<file>${log.path}/${app.name}-error.log</file>
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!--路径-->
<fileNamePattern>${log.path}/error/${app.name}-%d{yyyy-MM-dd}.log</fileNamePattern>
<maxHistory>30</maxHistory>
<totalSizeCap>10GB</totalSizeCap>
</rollingPolicy>
</appender>
<!--普通日志输出到控制台-->
<root level="info">
<appender-ref ref="console" />
<appender-ref ref="info" />
<appender-ref ref="error" />
</root>
<!--监控sql日志输出 -->
<logger name="jdbc.sqlonly" level="INFO" additivity="false">
<appender-ref ref="console" />
<appender-ref ref="info" />
</logger>
<logger name="jdbc.resultset" level="ERROR" additivity="false">
<appender-ref ref="console" />
<appender-ref ref="info" />
</logger>
<!-- 如想看到表格数据，将OFF改为INFO -->
<logger name="jdbc.resultsettable" level="OFF" additivity="false">
<appender-ref ref="console" />
</logger>
<logger name="jdbc.connection" level="OFF" additivity="false">
<appender-ref ref="console" />
<appender-ref ref="info" />
</logger>
<logger name="jdbc.sqltiming" level="OFF" additivity="false">
<appender-ref ref="console" />
<appender-ref ref="info" />
</logger>
<logger name="jdbc.audit" level="OFF" additivity="false">
<appender-ref ref="console" />
<appender-ref ref="info" />
</logger>
</configuration>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
<style>
@page {
margin: 0;
}
</style>
</head>
<body style="margin: 0px;
padding: 0px;
font: 100% SimSun, Microsoft YaHei, Times New Roman, Verdana, Arial, Helvetica, sans-serif;
color: #000;">
<div style="height: auto;
width: 820px;
min-width: 820px;
margin: 0 auto;
margin-top: 20px;
border: 1px solid #eee;">
<div style="padding: 10px;padding-bottom: 0px;">
<p style="margin-bottom: 10px;padding-bottom: 0px;">尊敬的用户，您好：</p>
<p style="text-indent: 2em; margin-bottom: 10px;">您正在申请邮箱验证，您的验证码为：</p>
<p style="text-align: center;
font-family: Times New Roman;
font-size: 22px;
color: #C60024;
padding: 20px 0px;
margin-bottom: 10px;
font-weight: bold;
background: #ebebeb;">${code}</p>
<div style="list-style: none;
margin-top: 22px;
maigin-bottom: 10px;
font-size: 14px;
color: #555;">
<p style="line-height: 12px;">Github：<a hover="color: #DA251D;" style="color: #999;" href="https://github.com/elunez/eladmin" target="_blank">https://github.com/elunez/eladmin</a></p>
</div>
<div class="foot-hr hr" style="margin: 0 auto;
z-index: 111;
width: 800px;
margin-top: 30px;
border-top: 1px solid #DA251D;">
</div>
<div style="text-align: center;
font-size: 12px;
padding: 20px 0px;
font-family: Microsoft YaHei;">
Copyright &copy;${.now?string("yyyy")} EL-ADMIN 后台管理系统 All Rights Reserved.
</div>
</div>
</div>
</body>
</html>
package ${package}.rest;
import com.topdraw.common.ResultInfo;
import com.topdraw.annotation.Log;
import ${package}.domain.${className};
import ${package}.service.${className}Service;
import ${package}.service.dto.${className}QueryCriteria;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Pageable;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import io.swagger.annotations.*;
import java.io.IOException;
import javax.servlet.http.HttpServletResponse;
/**
* @author ${author}
* @date ${date}
*/
@Api(tags = "${className}管理")
@RestController
@RequestMapping("/api/${changeClassName}")
public class ${className}Controller {
@Autowired
private ${className}Service ${changeClassName}Service;
@GetMapping
@ApiOperation("查询${className}")
public ResultInfo get${className}s(${className}QueryCriteria criteria, Pageable pageable) {
return ResultInfo.successPage(${changeClassName}Service.queryAll(criteria,pageable));
}
@GetMapping(value = "/all")
@ApiOperation("查询所有${className}")
public ResultInfo get${className}s(${className}QueryCriteria criteria) {
return ResultInfo.success(${changeClassName}Service.queryAll(criteria));
}
@Log
@PostMapping
@ApiOperation("新增${className}")
public ResultInfo create(@Validated @RequestBody ${className} resources) {
${changeClassName}Service.create(resources);
return ResultInfo.success();
}
@Log
@PutMapping
@ApiOperation("修改${className}")
public ResultInfo update(@Validated @RequestBody ${className} resources) {
${changeClassName}Service.update(resources);
return ResultInfo.success();
}
@Log
@DeleteMapping(value = "/{${pkChangeColName}}")
@ApiOperation("删除${className}")
public ResultInfo delete(@PathVariable ${pkColumnType} ${pkChangeColName}) {
${changeClassName}Service.delete(${pkChangeColName});
return ResultInfo.success();
}
<#if columns??>
<#list columns as column>
<#if column.columnName == 'code'>
@GetMapping(value = "/getByCode/{code}")
@ApiOperation(value = "根据标识查询")
public ResultInfo getByCode(@PathVariable String code) {
return ResultInfo.success(${changeClassName}Service.getByCode(code));
}
</#if>
</#list>
</#if>
}
package ${package}.service.dto;
import lombok.Data;
<#if hasTimestamp>
import java.sql.Timestamp;
</#if>
<#if hasBigDecimal>
import java.math.BigDecimal;
</#if>
import java.io.Serializable;
<#if !auto && pkColumnType = 'Long'>
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
</#if>
/**
* @author ${author}
* @date ${date}
*/
@Data
public class ${className}DTO implements Serializable {
<#if columns??>
<#list columns as column>
<#if column.columnComment != ''>
// ${column.columnComment}
</#if>
<#if column.columnKey = 'PRI'>
<#if !auto && pkColumnType = 'Long'>
// 处理精度丢失问题
@JsonSerialize(using= ToStringSerializer.class)
</#if>
</#if>
private ${column.columnType} ${column.changeColumnName};
</#list>
</#if>
}
package ${package}.domain;
import lombok.Data;
import lombok.experimental.Accessors;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import javax.persistence.*;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;
<#if hasTimestamp>
import java.sql.Timestamp;
</#if>
<#if hasBigDecimal>
import java.math.BigDecimal;
</#if>
<#if hasCode>
import java.util.UUID;
</#if>
import java.io.Serializable;
/**
* @author ${author}
* @date ${date}
*/
@Entity
@Data
@EntityListeners(AuditingEntityListener.class)
@Accessors(chain = true)
@Table(name="${tableName}")
public class ${className} implements Serializable {
<#if columns??>
<#list columns as column>
<#if column.columnComment != ''>
// ${column.columnComment}
</#if>
<#if column.columnKey = 'PRI'>
@Id
<#if auto>
@GeneratedValue(strategy = GenerationType.IDENTITY)
</#if>
</#if>
<#if column.columnName == 'create_time'>
@CreatedDate
</#if>
<#if column.columnName == 'update_time'>
@LastModifiedDate
</#if>
@Column(name = "${column.columnName}"<#if column.columnKey = 'UNI'>,unique = true</#if><#if column.isNullable = 'NO' && column.columnKey != 'PRI'>, nullable = false</#if>)
private ${column.columnType} ${column.changeColumnName};
</#list>
</#if>
public void copy(${className} source){
BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
}
}
package ${package}.service.mapper;
import com.topdraw.base.BaseMapper;
import ${package}.domain.${className};
import ${package}.service.dto.${className}DTO;
import org.mapstruct.Mapper;
import org.mapstruct.ReportingPolicy;
/**
* @author ${author}
* @date ${date}
*/
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface ${className}Mapper extends BaseMapper<${className}DTO, ${className}> {
}
package ${package}.service.dto;
import lombok.Data;
<#if queryHasTimestamp>
import java.sql.Timestamp;
</#if>
<#if queryHasBigDecimal>
import java.math.BigDecimal;
</#if>
<#if queryColumns??>
import com.topdraw.annotation.Query;
</#if>
/**
* @author ${author}
* @date ${date}
*/
@Data
public class ${className}QueryCriteria{
<#if queryColumns??>
<#list queryColumns as column>
<#if column.columnQuery = '1'>
// 模糊
@Query(type = Query.Type.INNER_LIKE)
</#if>
<#if column.columnQuery = '2'>
// 精确
@Query
</#if>
private ${column.columnType} ${column.changeColumnName};
</#list>
</#if>
}
package ${package}.repository;
import ${package}.domain.${className};
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import java.util.Optional;
/**
* @author ${author}
* @date ${date}
*/
public interface ${className}Repository extends JpaRepository<${className}, ${pkColumnType}>, JpaSpecificationExecutor<${className}> {
<#if columns??>
<#list columns as column>
<#if column.columnKey = 'UNI'>
${className} findBy${column.capitalColumnName}(${column.columnType} ${column.columnName});
</#if>
</#list>
</#if>
<#if columns??>
<#list columns as column>
<#if column.columnName == 'code'>
Optional<${className}> findFirstByCode(String code);
</#if>
</#list>
</#if>
}
package ${package}.service;
import ${package}.domain.${className};
import ${package}.service.dto.${className}DTO;
import ${package}.service.dto.${className}QueryCriteria;
import org.springframework.data.domain.Pageable;
import java.util.Map;
import java.util.List;
import java.io.IOException;
import javax.servlet.http.HttpServletResponse;
/**
* @author ${author}
* @date ${date}
*/
public interface ${className}Service {
/**
* 查询数据分页
* @param criteria 条件参数
* @param pageable 分页参数
* @return Map<String,Object>
*/
Map<String,Object> queryAll(${className}QueryCriteria criteria, Pageable pageable);
/**
* 查询所有数据不分页
* @param criteria 条件参数
* @return List<${className}DTO>
*/
List<${className}DTO> queryAll(${className}QueryCriteria criteria);
/**
* 根据ID查询
* @param ${pkChangeColName} ID
* @return ${className}DTO
*/
${className}DTO findById(${pkColumnType} ${pkChangeColName});
void create(${className} resources);
void update(${className} resources);
void delete(${pkColumnType} ${pkChangeColName});
<#if columns??>
<#list columns as column>
<#if column.columnName == 'code'>
/**
* Code校验
* @param code
* @return ${className}DTO
*/
${className}DTO getByCode(String code);
</#if>
</#list>
</#if>
}
package ${package}.service.impl;
import ${package}.domain.${className};
<#if columns??>
<#list columns as column>
<#if column.columnKey = 'UNI'>
<#if column_index = 1>
import com.topdraw.exception.EntityExistException;
</#if>
</#if>
</#list>
</#if>
import com.topdraw.utils.ValidationUtil;
import com.topdraw.utils.FileUtil;
import ${package}.repository.${className}Repository;
import ${package}.service.${className}Service;
import ${package}.service.dto.${className}DTO;
import ${package}.service.dto.${className}QueryCriteria;
import ${package}.service.mapper.${className}Mapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.dao.EmptyResultDataAccessException;
<#if !auto && pkColumnType = 'Long'>
import cn.hutool.core.lang.Snowflake;
import cn.hutool.core.util.IdUtil;
</#if>
<#if !auto && pkColumnType = 'String'>
import cn.hutool.core.util.IdUtil;
</#if>
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.util.Assert;
import com.topdraw.utils.PageUtil;
import com.topdraw.utils.QueryHelp;
import com.topdraw.utils.StringUtils;
import java.util.List;
import java.util.Map;
import java.io.IOException;
import javax.servlet.http.HttpServletResponse;
import java.util.ArrayList;
import java.util.LinkedHashMap;
/**
* @author ${author}
* @date ${date}
*/
@Service
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
public class ${className}ServiceImpl implements ${className}Service {
@Autowired
private ${className}Repository ${changeClassName}Repository;
@Autowired
private ${className}Mapper ${changeClassName}Mapper;
@Override
public Map<String, Object> queryAll(${className}QueryCriteria criteria, Pageable pageable) {
Page<${className}> page = ${changeClassName}Repository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
return PageUtil.toPage(page.map(${changeClassName}Mapper::toDto));
}
@Override
public List<${className}DTO> queryAll(${className}QueryCriteria criteria) {
return ${changeClassName}Mapper.toDto(${changeClassName}Repository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
}
@Override
public ${className}DTO findById(${pkColumnType} ${pkChangeColName}) {
${className} ${changeClassName} = ${changeClassName}Repository.findById(${pkChangeColName}).orElseGet(${className}::new);
ValidationUtil.isNull(${changeClassName}.get${pkCapitalColName}(),"${className}","${pkChangeColName}",${pkChangeColName});
return ${changeClassName}Mapper.toDto(${changeClassName});
}
@Override
@Transactional(rollbackFor = Exception.class)
public void create(${className} resources) {
<#if !auto && pkColumnType = 'Long'>
Snowflake snowflake = IdUtil.createSnowflake(1, 1);
resources.set${pkCapitalColName}(snowflake.nextId());
</#if>
<#if !auto && pkColumnType = 'String'>
resources.set${pkCapitalColName}(IdUtil.simpleUUID());
</#if>
<#if columns??>
<#list columns as column>
<#if column.columnKey = 'UNI'>
if(${changeClassName}Repository.findBy${column.capitalColumnName}(resources.get${column.capitalColumnName}()) != null) {
throw new EntityExistException(${className}.class,"${column.columnName}",resources.get${column.capitalColumnName}());
}
</#if>
</#list>
</#if>
${changeClassName}Repository.save(resources);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void update(${className} resources) {
${className} ${changeClassName} = ${changeClassName}Repository.findById(resources.get${pkCapitalColName}()).orElseGet(${className}::new);
ValidationUtil.isNull( ${changeClassName}.get${pkCapitalColName}(),"${className}","id",resources.get${pkCapitalColName}());
<#if columns??>
<#list columns as column>
<#if column.columnKey = 'UNI'>
<#if column_index = 1>
${className} ${changeClassName}1 = null;
</#if>
${changeClassName}1 = ${changeClassName}Repository.findBy${column.capitalColumnName}(resources.get${column.capitalColumnName}());
if(${changeClassName}1 != null && !${changeClassName}1.get${pkCapitalColName}().equals(${changeClassName}.get${pkCapitalColName}())){
throw new EntityExistException(${className}.class,"${column.columnName}",resources.get${column.capitalColumnName}());
}
</#if>
</#list>
</#if>
${changeClassName}.copy(resources);
${changeClassName}Repository.save(${changeClassName});
}
@Override
@Transactional(rollbackFor = Exception.class)
public void delete(${pkColumnType} ${pkChangeColName}) {
Assert.notNull(id, "The given id must not be null!");
${className} ${changeClassName} = ${changeClassName}Repository.findById(id).orElseThrow(
() -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", ${className}.class, id), 1));
${changeClassName}Repository.delete(${changeClassName});
}
<#if columns??>
<#list columns as column>
<#if column.columnName == 'code'>
@Override
public ${className}DTO getByCode(String code) {
return StringUtils.isNotEmpty(code) ? ${changeClassName}Mapper.toDto(${changeClassName}Repository.findFirstByCode(code).orElseGet(${className}::new))
: new ${className}DTO();
}
</#if>
</#list>
</#if>
}
import request from '@/utils/request'
export function add(data) {
return request({
url: 'api/${changeClassName}',
method: 'post',
data
})
}
export function del(${pkChangeColName}) {
return request({
url: 'api/${changeClassName}/' + ${pkChangeColName},
method: 'delete'
})
}
export function edit(data) {
return request({
url: 'api/${changeClassName}',
method: 'put',
data
})
}
export function download${className}(params) {
return request({
url: 'api/${changeClassName}/download',
method: 'get',
params,
responseType: 'blob'
})
}
<#if columns??>
<#list columns as column>
<#if column.columnName == 'code'>
export function getByCode(code) {
return request({
url: 'api/${changeClassName}/getByCode/' + code,
method: 'get'
})
}
</#if>
</#list>
</#if>
<template>
<el-dialog :append-to-body="true" :close-on-click-modal="false" :visible.sync="dialog" :title="isAdd ? '新增' : '编辑'" width="960px" @closed="doClose">
<el-form ref="form" :model="form" :rules="rules" size="small" label-width="80px" style="padding: 30px;margin: -20px 0">
<el-row>
<#if columns??>
<#list columns as column>
<#if column.changeColumnName != '${pkChangeColName}'>
<#if column.columnName != 'images' && column.columnName != 'create_time' && column.columnName != 'update_time'>
<el-col :span="12">
<el-form-item label="<#if column.columnComment != ''>${column.columnComment}<#else>${column.changeColumnName}</#if>" <#if column.isNullable =
'NO'>prop="${column.changeColumnName}"</#if>>
<#if column.columnName = 'code'>
<el-input v-model="form.${column.changeColumnName}" prop="code"/>
<#elseif column.columnType = 'Timestamp'>
<el-date-picker v-model="form.${column.changeColumnName}" type="datetime"/>
<#elseif column.columnName = 'image'>
<images-upload ref="upload" :limit="5" :image.sync="form.image" :images.sync="form.images" upload-entity="${changeClassName}" />
<#else>
<el-input v-model="form.${column.changeColumnName}"/>
</#if>
</el-form-item>
</el-col>
</#if>
</#if>
</#list>
</#if>
</el-row>
</el-form>
<div slot="footer" class="dialog-footer">
<el-button type="text" @click="cancel">取消</el-button>
<el-button :loading="loading" type="primary" @click="doSubmit">确认</el-button>
</div>
</el-dialog>
</template>
<script>
import { add, edit } from '@/api/${changeClassName}'
<#if columns??>
<#list columns as column>
<#if column.columnName == 'code'>
import { getByCode } from '@/api/${changeClassName}'
</#if>
</#list>
</#if>
import ImagesUpload from '@/components/ImagesUpload/index'
export default {
components: { ImagesUpload },
props: {
isAdd: {
type: Boolean,
required: true
},
dictMap: {
type: Object,
required: true
}
},
data() {
return {
loading: false, dialog: false,
form: {
<#if columns??>
<#list columns as column>
${column.changeColumnName}: ''<#if column_has_next>,</#if>
</#list>
</#if>
},
rules: {
<#if columns??>
<#list columns as column>
<#if column.columnName == 'code'>
code: [
{ required: true, message: '请输入标识', trigger: 'blur' }, { validator: this.validateCode, trigger: 'blur' }
],
</#if>
</#list>
</#if>
<#function filter columns>
<#local result = []>
<#list columns as column>
<#if column.columnKey != 'PRI' && column.isNullable = 'NO'>
<#local result = result + [column]>
</#if>
</#list>
<#return result>
</#function>
<#assign filteredData = filter(columns)>
<#list filteredData as column>
${column.changeColumnName}: [
{ required: true, message: '${column.columnComment}不能为空', trigger: 'blur' }
]<#sep>,</#sep>
</#list>
}
}
},
methods: {
<#if columns??>
<#list columns as column>
<#if column.columnName == 'code'>
validateCode(rule, value, callback) {
// 当为编辑状态且code未改变时不进行校验
if (!this.isAdd && this.form.originalCode === value) {
callback()
} else {
getByCode(value)
.then(res => {
typeof (res) === 'undefined' || res.id === null || this.form.id === res.id
? callback()
: callback(new Error('该code已存在!'))
})
.catch((err) => {
console.log(err)
callback()
})
}
},
</#if>
</#list>
</#if>
cancel() {
this.dialog = false
},
doSubmit() {
if (this.isAdd) {
this.doAdd()
} else this.doEdit()
},
doAdd() {
this.$refs['form'].validate((valid) => {
if (valid) {
this.loading = true
add(this.form).then(() => {
this.$notify({
title: '添加成功',
type: 'success',
duration: 2500
})
this.dialog = false
this.loading = false
this.$parent.init()
}).catch(err => {
this.loading = false
console.log(err)
})
} else {
this.$notify({
title: '警告',
message: '信息不合法',
type: 'warning',
duration: 2000
})
}
})
},
doEdit() {
this.$refs['form'].validate((valid) => {
if (valid) {
this.loading = true
edit(this.form).then(() => {
this.$notify({
title: '修改成功',
type: 'success',
duration: 2500
})
this.loading = false
this.dialog = false
this.$parent.init()
}).catch(err => {
console.log(err)
this.loading = false
})
} else {
this.$notify({
title: '警告',
message: '信息不合法',
type: 'warning',
duration: 2000
})
}
})
},
doClose() {
this.resetForm()
},
resetForm() {
this.$refs['form'].resetFields()
this.form = {
<#if columns??>
<#list columns as column>
<#if column.columnName == 'code'>
originalCode: '',
</#if>
${column.changeColumnName}: ''<#if column_has_next>,</#if>
</#list>
</#if>
}
}
}
}
</script>
<style scoped>
</style>
<#--noinspection ALL-->
<template>
<div class="app-container">
<!--工具栏-->
<div class="head-container">
<#if hasQuery>
<!-- 搜索 -->
<el-select v-model="query.type" clearable placeholder="聚合筛选条件" class="filter-item" style="width: 130px">
<el-option v-for="item in queryTypeOptions" :key="item.key" :label="item.display_name" :value="item.key"/>
</el-select>
<el-input v-model="query.value" clearable placeholder="输入搜索内容" style="width: 200px;" class="filter-item" @keyup.enter.native="toQuery"/>
<el-button class="filter-item" size="mini" type="success" icon="el-icon-search" @click="toQuery">搜索</el-button>
</#if>
<!-- 新增 -->
<div style="display: inline-block;margin: 0 2px;">
<el-button
v-permission="['admin','${changeClassName}:add']"
class="filter-item"
size="mini"
type="primary"
icon="el-icon-plus"
@click="add">新增</el-button>
</div>
</div>
<!--表单组件-->
<eForm ref="form" :is-add="isAdd" :dict-map="dictMap"/>
<!--表格渲染-->
<el-table v-loading="loading" :data="data" size="small" style="width: 100%;" @row-dblclick="edit">
<#if columns??>
<#list columns as column>
<#if column.columnShow = 'true'>
<#if column.columnType != 'Timestamp'>
<el-table-column prop="${column.changeColumnName}" label="<#if column.columnComment != ''>${column.columnComment}<#else>${column.changeColumnName}</#if>" <#if column.columnName = 'id' || column.columnName = 'name' || column.columnName = 'code'>sortable </#if>/>
<#else>
<el-table-column prop="${column.changeColumnName}" label="<#if column.columnComment != ''>${column.columnComment}<#else>${column.changeColumnName}</#if>">
<template slot-scope="scope">
<span>{{ parseTime(scope.row.${column.changeColumnName}) }}</span>
</template>
</el-table-column>
</#if>
</#if>
</#list>
</#if>
<el-table-column label="操作" width="120px" fixed="right" align="center">
<template slot-scope="scope">
<el-button v-permission="['admin','${changeClassName}:edit']" size="mini" type="primary" icon="el-icon-edit" @click="edit(scope.row)"/>
<el-popover
v-permission="['admin','${changeClassName}:del']"
:ref="scope.row.${pkChangeColName}"
placement="top"
width="180">
<p>确定删除本条数据吗？</p>
<div style="text-align: right; margin: 0">
<el-button size="mini" type="text" @click="$refs[scope.row.${pkChangeColName}].doClose()">取消</el-button>
<el-button :loading="delLoading" type="primary" size="mini" @click="subDelete(scope.row.${pkChangeColName})">确定</el-button>
</div>
<el-button slot="reference" type="danger" icon="el-icon-delete" size="mini"/>
</el-popover>
</template>
</el-table-column>
</el-table>
<!--分页组件-->
<el-pagination
:total="total"
:current-page="page + 1"
style="margin-top: 8px;"
layout="total, prev, pager, next, sizes"
@size-change="sizeChange"
@current-change="pageChange"/>
</div>
</template>
<script>
import initData from '@/mixins/initData'
import initDict from '@/mixins/initDict'
import { getAttrByValueFromDict } from '@/utils/common-util'
import { del, download${className} } from '@/api/${changeClassName}'
<#if hasTimestamp>
import { parseTime, downloadFile } from '@/utils/index'
</#if>
import eForm from './form'
export default {
components: { eForm },
mixins: [initData, initDict],
data() {
return {
delLoading: false<#if hasQuery>,</#if>
<#if hasQuery>
queryTypeOptions: [
<#if queryColumns??>
<#list queryColumns as column>
{ key: '${column.changeColumnName}', display_name: '<#if column.columnComment != ''>${column.columnComment}<#else>${column.changeColumnName}</#if>' }<#if column_has_next>,</#if>
</#list>
</#if>
]
</#if>
}
},
created() {
this.$nextTick(() => {
this.init()
this.getDictMap('')
})
},
methods: {
<#if hasTimestamp>
parseTime,
</#if>
getAttrByValueFromDict,
beforeInit() {
this.url = 'api/${changeClassName}'
const sort = '${pkChangeColName},desc'
this.params = { page: this.page, size: this.size, sort: sort }
<#if hasQuery>
const query = this.query
const type = query.type
const value = query.value
if (type && value) { this.params[type] = value }
</#if>
return true
},
subDelete(${pkChangeColName}) {
this.delLoading = true
del(${pkChangeColName}).then(res => {
this.delLoading = false
this.$refs[${pkChangeColName}].doClose()
this.dleChangePage()
this.init()
this.$notify({
title: '删除成功',
type: 'success',
duration: 2500
})
}).catch(err => {
this.delLoading = false
this.$refs[${pkChangeColName}].doClose()
console.log(err.response.data.message)
})
},
add() {
this.isAdd = true
this.$refs.form.dialog = true
},
edit(data) {
this.isAdd = false
const _this = this.$refs.form
_this.form = {
<#if columns??>
<#list columns as column>
<#if column.columnName == 'code'>
originalCode: data.code,
</#if>
${column.changeColumnName}: data.${column.changeColumnName}<#if column_has_next>,</#if>
</#list>
</#if>
}
_this.dialog = true
},
// 导出
download() {
this.beforeInit()
this.downloadLoading = true
download${className}(this.params).then(result => {
downloadFile(result, '${className}列表', 'xlsx')
this.downloadLoading = false
}).catch(() => {
this.downloadLoading = false
})
}
}
}
</script>
<style scoped>
</style>
package com.topdraw;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
@SpringBootTest(classes = MemberEngineApplication.class)
@RunWith(SpringRunner.class)
public class BaseTest {
}
package com.topdraw.resttemplate;
import com.alibaba.fastjson.JSONObject;
import com.topdraw.BaseTest;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
public class RestTemplateTest extends BaseTest {
@Autowired
RestTemplateClient apiUtil;
@Test
public void t(){
JSONObject memberInfo = this.apiUtil.getMemberInfo(5L);
System.out.println(memberInfo);
}
}